Saravanan666/pypi-org huggingface dataset:
Package: sami-ai
SAMI AI V0.6Overviewsami_ai is an advanced artificial intelligence library designed to assist with the development of sophisticated and efficient software solutions.FeaturesPowerful AI capabilitiesFast and efficient algorithmsEasy-to-use interfaceThe reply settings feature has become availableInstallationYou can install sami-ai using pip:pip install sami-ai==0.6Example:SAMI AIfrom sami_ai import sami_ai


user_input = input("Enter Your Msg: ")
result = sami_ai(user_input)
print(result["response"])DEVILS GPTfrom sami_ai import Devils_GPT


user_input = input("Enter Your Msg: ")
key = input("Enter Your key openai: ")
model = input("Enter Your model openai: ")
result = Devils_GPT(user_input,key,model)
print(result["response"])WORM GPTfrom sami_ai import Worm_GPT


user_input = input("Enter Your Msg: ")
key = input("Enter Your key openai: ")
model = input("Enter Your model openai: ")
result = Worm_GPT(user_input,key,model)
print(result["response"])
Package: samino
SAminoSAmino is unofficial client forAminoappsAPI in Python.InstallationYou can use eitherpython3 setup.py installorpip3 install saminoto install. This module is tested on Python 3.9+.ContributingSAmino is open source module, anyone can contribute. Please see theGithub RepositoryFeaturesFaster than otherAminoappspython modulesSupports async and sockets, eventsEasy and sample to useNoToo many requests.Continual updates and bug fixesHave alot of useful functionsExamplesGet SessionIDimportsaminoclient=samino.Client()client.login("< email >","< password >")print(client.sid)Login with SessionIDimportsaminoclient=samino.Client()client.sid_login("< sid >")print(client.sid)Send a message in chatimportsaminoclient=samino.Client()client.login("< email >","< password >")path=client.get_from_link("< chat link >")local=samino.Local(path.comId)local.send_message(path.objectId,"< message >")
Package: samklang-media
Samklang Media contains a storage for Django that will save files using a hash of the contents as part of their filename. It will also add a symlink to this from the original filename.A way to upload files using drag and drop and file multi select is also provided, using javascript and mootools.ContributorsSigurd Gartmann <sigurdga-samklang@sigurdga.no>
Jørgen Bergquist <gismos@gmail.com>Thanks toFerdinand Beyer for his description of sha1-hashing in git:http://stackoverflow.com/questions/552659/assigning-git-sha1s-without-gitArian Stolwijk, Djamil Legato for the file uploading mechanism using mootools.
Package: samklang-payment
Samklang Payment is a way to get monetary contributions through a payment provider. At this time it is only possible to get donations, and the only backend API supported is from NETS.Extending this app to an online shop should be relatively easy.ContributorsSigurd Gartmann <sigurdga-samklang@sigurdga.no>Thanks toDigitalt Personvern (Chris, Hanna and Fredrik) for resolving the non-technical issues related to testing.
Package: saml2art
saml2artCLI tool which enables you to login and retrieve Artifactory credentials using OKTA Identity Provider.The process is:Configure Okta app url, Artifactory host, usernamePrompt user for credentialsLog in to Okta Identity Provider using form based authenticationBuild a SAML assertionLogin to Artifactory using the SAML assertion and retrieve a session cookieGenerate API KeyStore it in a netrc file (~/.netrc)Installation and usageInstallationsaml2artcan be installed by runningpip install saml2art. It requires Python 3.7.0+.UsageConfigurationThis step needs to be run firstThe configuration is stored by default in "~/.saml2art"usage: saml2art configure [-h] [--artifactory-host ARTIFACTORYURL]
                          [--okta-app-url OKTAAPPURL] [--username USERNAME]

optional arguments:
  -h, --help            show this help message and exit
  --artifactory-host ARTIFACTORYURL
                        Your Artifactory host
  --okta-app-url OKTAAPPURL
                        Your Artifactory Okta app url
  --username USERNAME   Your IdP usernameLoginThe login command will connect to OKTA and obtain a SAML assertion.
Then it will login to Artifactory and create an API Key for you.The API Key will be stored in ~/.netrc with the Artifactory host name.The recommended way is to run -saml2art loginYou will be prompted for the password in the terminal.usage: saml2art login [-h] [--password PASSWORD]

optional arguments:
  -h, --help           show this help message and exit
  --password PASSWORD  Your IdP password
Package: samlaws
samlawsConfiguración aws cli en conexiones mediante SAMLGetting StartedThese instructions will get you a copy of the project up and running on your local machine for development and testing purposes. See deployment for notes on how to deploy the project on a live system.Prerequisitespython3 >= 3.6
python3-pip
pylama
bandit3Deploymentpip3 install pyVarfilterAuthorsEsteban Barón-Initial work-gomibayaLicenseThis project is licensed under the MIT License - see theLICENSEfile for details
Package: sam-learner
Safe Action Model LearningSAM learner is an algorithm to efficiently andsafelylearn action models of STRIPS problems.This repository contains two variations of the algorithm:The classic SAM learning algorithm.Lightweight version of ESAM learning algorithm.The code is also available as a package to download inPyPI.Requirements:The repository's code is currently running usingPython>= 3.8.
In addition, This code is currently depending on the on version 1.3 ofpyperplan.Installation:From the Python package index (PyPI):pip install sam-learnerFeatures:The repository offers two variants of the SAM learning algorithm, the classical SAM learning algorithm as well as a
lightweight version of theExtendedSAM learning algorithm.Classical SAM Learning:Learnliftedaction model of classical PDDL problems.Currently, supports PDDL-1.2 only.Export learned domain via domain export functionality.Extended SAM Learning:Learnliftedaction model of classical PDDL problems.Extends SAM to also learn action models in case that there is an ambiguity in the actions' execution process.Currently, supports PDDL-1.2 only.Export learned domain via domain export functionality.New Feature:Now the code outputs trajectories in a format that FAMA action model learning can read and translate.
Package: sammen
y# SammenTogether (Dansk: sammen) - watch multiple artifacts to ensure special events come together or go away.License: MIT|Country of origin: Switzerland|Export control classification number(ECCN): EAR99Third party dependencies are documented in the folderthird-party.DocumentationUser and developerdocumentation of sammen.Bug TrackerAny feature requests or bug reports shall go to thetodos of sammen.Primary Source repositoryThe main source ofsammenis on a mountain in central Switzerland.
We use distributed version control (git).
There is no central hub.
Every clone can become a new source for the benefit of all.
The preferred public clones ofsammenare:on codeberg- a democratic community-driven, non-profit software development platform operated by Codeberg e.V.at sourcehut- a collection of tools useful for software development.ContributionsPlease do not submit "pull requests" (I found no way to disable that "feature" on GitHub).
If you like to share small changes under the repositories license please kindly do so by sending a patchset.
You can either send such a patchset per email usinggit send-emailor
if you are a sourcehut user by selecting "Prepare a patchset" on the summary page of your fork atsourcehut.StatusExperimental.Note: The default branch isdefault.
Package: sammhelper
What is it?sammhelperis a Python package that supports mathematical modeling in the field of urban water management. It provides all functions required in the ETH Zurich lectureSystems Analysis and Mathematical Modeling in Urban Water Management.Main Featuressammhelperprovides wrapper functions for:Ideal reactors modelingSensitivity functionsParameter identificationError propagationMonte Carlo simulationPID controllerWhere to get itThe source code is currently hosted on ... (TBD).
The binary installer for the latest released version is available at the Python Package Index (PyPI):pip install sammhelperDependenciesNumpyScipy...DocumentationThe official documentation is hosted on ...BackgroundWork onsammhelperstarted at theChairs of Urban Water Management(ETH Zurich) in 2021 and has been under active development since then.Getting Helpsww@ifu.baug.ethz.ch
Package: sammi
SAMMIpyThis package provides a wrapper for running the Semi-Automated Metabolic Map Illustrator (SAMMI) from Python scripts and the Python command line. The SAMMI tool can be found atwww.sammitool.com. The package works with theCOBRApytoolbox and requires an internet connection to render maps. For more complex, up-to-date examples and to learn how to use the tool please check out the examples in the Jupyter Notebook file.DocumentationThe SAMMIpy documentation can be foundhere.InstallationTo install the package runpip install sammifrom the Python command line.UsageTo use the SAMMI package runimport sammifrom within your python code. The functionsammi.plotreads the template fileindex.htmllocated atsammi.__path__[0] + '\\browser', and outputs the generated map to the same folder in the file defined within the function (defaulting toindex_load.html).To open previously generated maps usesammi.openmap(htmlName). Once maps are generated they can be exported in the SAMMI specific format to be shared and saved.HelpFor help checkhelp(sammi.plot)within Python or read the SAMMIpy documentationhere. Users can also look at the examples provided in the documentation and the Jupyter Notebook in this folder. All of the examples provided in the notebook can be run usingsammi.test(n)wherenranges from zero to eleven.
Package: sam-ml-py
SAM_MLa library created by Samuel Brinkmanngetting started (with SMAC3 library)pre-installations(needed forsmaclibrary)You need to installswigfor thesmaglibrary that is used for hyperparameter tuning.Linux(seesmac installation guide):apt-get install swigMacOS (withhomebrew):brew install swigWindows (seeswigwin)install the package to your activated virtual environment(python version 3.10 and higher is needed)pip install "sam-ml-py[with_swig]"getting started (without SMAC3 library)install the package to your activated virtual environment(python version 3.10 and higher is needed)pip install sam-ml-pystart using itnow you can import the package, e.g.:from sam_ml.models.classifier import RFC

RandomForestClassifier = RFC()--> Look into thedocsof the repo for more information.
Package: sammon-mapping
Sammon MappingSammon mapping is a nonlinear dimensionality reduction technique that is used to represent high-dimensional data in a lower dimensional space while preserving the pairwise distances between data points as much as possible. The technique was introduced by John W. Sammon Jr. in 1969.The Sammon Mapping algorithm tries to minimize a stress function that quantifies the difference between the pairwise distances in the original high-dimensional space and the pairwise distances in the lower dimensional space. The algorithm iteratively adjusts the positions of the data points in the lower dimensional space until the stress function is minimized.Python Library ImplementationThe sammon function in this library provides an implementation of the Sammon Mapping algorithm. The function takes the following parameters:Function DocumentationThe sammon function implements the Sammon Mapping algorithm in Python. The function takes the following parameters:x: array-like, shape (n_samples, n_features)
The input data.n: int, optional (default: 2)
The dimensionality of the output space. The default is 2.display: int, optional (default: 0)
Whether to display the iteration information or not. The default is 0.inputdist: str, optional (default: 'raw')
The type of distance metric used in the input space.Possible values are:'raw': Euclidean distance'pcorr': Pearson correlation distance'spear': Spearman correlation distancemaxhalves: int, optional (default: 20)
The maximum number of times the step halving procedure can be applied. The default is 20.maxiter: int, optional (default: 500)
The maximum number of iterations. The default is 500.tolfun: float, optional (default: 1e-9)
The tolerance for the change in the stress function. The default is 1e-9.init: str, optional (default: 'pca')
The type of initialization used for the output space.Possible values are:'pca': Principal component analysis initialization'random': Random initializationThe function returns:y: array-like, shape (n_samples, n_components)
The transformed output data.stress: float
The final value of the stress function.ReferenceThis implementation is based on the algorithm described in the following paper:Sammon, J. W. (1969).A nonlinear mapping for data structure analysis.IEEE Transactions on Computers, C-18(5), 401-409. doi:10.1109/T-C.1969.222678
Package: sammy-sjsu-dev2
sammySammy is a tool for managing SJSU-Dev2 firmware projects and to install external
packages such as platforms and libraries.Quick Start# Install sammy tool via PIPpipinstallsammy-sjsu-dev2# Create a projectsammystartnew_project# Enter projectcdnew_project# Build main.cpp source code into .elf, .bin, .hex etc. Default platform is the# LPC40xx series.sammybuildDependenciespython3.6 and abovegitUsageRunsammy --helpto get information about how to use sammy and what it can do.
A quick guide on the most common commands for sammy are listed here.Usage: sammy [OPTIONS] COMMAND [ARGS]...

  Sammy is a tool for managing SJSU-Dev2 firmware projects and to install
  external packages such as platforms and libraries.

Options:
  --help  Show this message and exit.

Commands:
  build       Build Application
  build-test  Build Test Executable
  install     Download and install library to project
  list        List libraries available from the SJSU-Dev2 organization
  remove      Delete library from project
  start       Start a new firmware project.Building CodeBuilding code is as simple as runningsammy buildin a SJSU-Dev2 directory
with amain.cppin it.$ sammy build --help
Usage: sammy build [OPTIONS] [SOURCE]

  Build Application

Options:
  -o, --optimization TEXT   [default: g]
  -p, --platform TEXT       [default: lpc40xx]
  -l, --linker_script TEXT  [default: default.ld]
  -t, --toolchain TEXT      [default: gcc-arm-none-eabi-picolibc]
  -c, --compiler TEXT       [default: arm-none-eabi-g++]
  --help                    Show this message and exit.Installing PackagesTo install a package you need to specify a library name such aslibesp8266orliblpc40xx. This will scan SJSU-Dev2 repo list and if it exists will download
the repo to thepackagesdirectory and link the library to thelibrarydirectory. If the package you want to install is not apart of the SJSU-Dev2 repo
you can specify a URL to an git project and it will be installed.$ sammy install --help
Usage: sammy install [OPTIONS] LIBRARY

  Download and install library to project

Options:
  -d, --project_directory PATH
  -t, --tag TEXTYou can list the SJSU-Dev2 projects by using the following comamnd:sammy listYou can uninstall a package by running:sammy remove <package_name>Build Test FilesYou can build host tests programs usingsammy build-test file.test.cpp. The
extension does not matter, but SJSU-Dev2 follows the.test.cppextension
pattern.Usage: sammy build-test [OPTIONS] TEST_SOURCE_CODE

  Build Test Executable

Options:
  -c, --compiler TEXT  [default: g++-10]
  -r, --run
Package: samosila-core
SamosilaOverviewSamosila is my attempt to recreate anOpenAI Compatible Serverfor generating text, images, embeddings, and storing them in vector databases. It also includes a chat functionality.The server's request and responses are very similar to OpenAI's API with additional fields needed for different providers. It usesLangchainfor the LLM part (Robust and powerful with callbacks) and provider SDKs for image generation and more.
Package: samourai-Adafruit-Blinka
IntroductionThis repository contains a selection of packages emulating the CircuitPython API
for devices or hosts running CPython or MicroPython. Working code exists to emulate these CircuitPython packages:analogio- analog input/output pins, using pin identities from board+microcontroller packagesbitbangio- software-driven interfaces for I2C, SPIboard- breakout-specific pin identitiesbusio- hardware-driven interfaces for I2C, SPI, UARTdigitalio- digital input/output pins, using pin identities from board+microcontroller packagesmicrocontroller- chip-specific pin identitiesmicropython- MicroPython-specific moduleneopixel_write- low-level interface to NeoPixelspulseio- contains classes that provide access to basic pulse IO (PWM)pwmio- contains classes that provide access to basic pulse IO (PWM)For details, see theBlinka API reference.DependenciesThe emulation described above is intended to provide a
CircuitPython-like API for devices which are running CPython or
Micropython. Since corresponding packages should be built-in to any
standard CircuitPython image, they have no value on a device already
running CircuitPython and would likely conflict in unhappy ways.The test suites in the test/src folder undertesting.universalare by design
intended to run oneitherCircuitPythonorCPython/Micropython+compatibility layer to prove conformance.Installing from PyPIOn supported GNU/Linux systems like the Raspberry Pi, you can install the driver locallyfrom
PyPI. To install for current user:pip3installAdafruit-BlinkaTo install system-wide (this may be required in some cases):sudopip3installAdafruit-BlinkaTo install in a virtual environment in your current project:mkdirproject-name&&cdproject-namepython3-mvenv.envsource.env/bin/activatepip3installAdafruit-BlinkaUsage ExampleAt the time of writing (git:7fc1f8ab),
the following sequence runs through some basic testing of the digitalio compatibility layer…fromtestingimporttest_module_nametest_module_name("testing.universal.digitalio")An example log from running the suites ishere.ContributingContributions are welcome! Please read ourCode of Conductbefore contributing to help this project stay welcoming.Building locallySphinx documentationSphinx is used to build the documentation based on rST files and comments in the code. First,
install dependencies (feel free to reuse the virtual environment from above):python3-mvenv.envsource.env/bin/activatepipinstallSphinxsphinx-rtd-themeAdafruit-PlatformDetectNow, once you have the virtual environment activated:cddocssphinx-build-E-W-bhtml._build/htmlThis will output the documentation todocs/_build/html. Open the index.html in your browser to
view them. It will also (due to -W) error out on any warning like Travis will. This is a good way to
locally verify it will pass.
Package: samourai-circuitpython-dps310
IntroductionLibrary for the DPS310 Precision Barometric Pressure SensorDependenciesThis driver depends on:Adafruit CircuitPythonBus DeviceRegisterPlease ensure all dependencies are available on the CircuitPython filesystem.
This is easily achieved by downloadingthe Adafruit library and driver bundle.Installing from PyPIOn supported GNU/Linux systems like the Raspberry Pi, you can install the driver locallyfrom
PyPI. To install for current user:pip3installadafruit-circuitpython-dps310To install system-wide (this may be required in some cases):sudopip3installadafruit-circuitpython-dps310To install in a virtual environment in your current project:mkdirproject-name&&cdproject-namepython3-mvenv.envsource.env/bin/activatepip3installadafruit-circuitpython-dps310Usage Exampleimporttimeimportboardimportadafruit_dps310i2c=board.I2C()# uses board.SCL and board.SDAdps310=adafruit_dps310.DPS310(i2c)whileTrue:print("Temperature =%.2f*C"%dps310.temperature)print("Pressure =%.2fhPa"%dps310.pressure)print("")time.sleep(1.0)Caveat: by default the library initializes the IC with constant temperature and pressure measurements at 64Hz with 64 samples. It is not possible to change the IC’s mode, temperature_oversample_count or pressure_oversample_count on-the-fly so resetting the IC and operation parameteres is required. For instance, to set the mode to continuous pressure measurement at 1Hz with 2 samples:dps310.reset()dps310.pressure_oversample_count=adafruit_dps310.SampleCount.COUNT_2dps310.pressure_rate=adafruit_dps310.Rate.RATE_1_HZdps310.mode=adafruit_dps310.Mode.CONT_PRESSUREdps310.wait_pressure_ready()Known IssuesLibrary extensive features might not be compatible with memory limited boards. Library might not
load in SAMD21 boards and others with 32KB of RAM or less.ContributingContributions are welcome! Please read ourCode of Conductbefore contributing to help this project stay welcoming.DocumentationFor information on building library documentation, please check outthis guide.
Package: samourai-circuitpython-scratch
IntroductionExample library for testing updates to cookiecutterDependenciesThis driver depends on:Adafruit CircuitPythonPlease ensure all dependencies are available on the CircuitPython filesystem.
This is easily achieved by downloadingthe Adafruit library and driver bundleor individual libraries can be installed usingcircup.Installing from PyPINoteThis library is not available on PyPI yet. Install documentation is included
as a standard element. Stay tuned for PyPI availability!On supported GNU/Linux systems like the Raspberry Pi, you can install the driver locallyfrom
PyPI.
To install for current user:pip3installsamourai-circuitpython-scratchTo install system-wide (this may be required in some cases):sudopip3installsamourai-circuitpython-scratchTo install in a virtual environment in your current project:mkdirproject-name&&cdproject-namepython3-mvenv.envsource.env/bin/activatepip3installsamourai-circuitpython-scratchUsage ExampleSee examples directory.ContributingContributions are welcome! Please read ourCode of Conductbefore contributing to help this project stay welcoming.DocumentationFor information on building library documentation, please check outthis guide.