Saravanan666/pypi-org huggingface dataset:
Package: salto
saltoPlaying with embedding vectorsInstallationYou can install this library fromPyPIpipinstallsaltoor from the GitHub repo:pipinstallgit+https://github.com/krzjoa/salto.gitMotivationThe goal of thesaltopackage is to explore embeddings and check,
how the distance between two points (vectors) can be interpreted.
We get two arbitrary selected points, such as embedding vectors foriceandfiredraw a straight line passing trough the both these points. Then, we treat the
newly created line as a new axis by projecting the rest of the points onto this line.Drawn using:https://www.geogebra.org/m/JMMKv7cxI named the packagesalto, which meanssomersaultin many languages or simplyjumpin Romance languages like Italian, where this word originally comes from.
It's because the operation of changing space for me resembles a kind of acrobatics 😉.Usageimportnumpyasnpimportspacyimportsaltonlp=spacy.load('en_core_web_md')fire=nlp('fire')ice=nlp('ice')ice_fire_axis=salto.axis(ice.vector,fire.vector)cold=['ice cream','polar','snow','winter','fridge','Antarctica']warm=['boiling water','tropical','sun','summer','oven','Africa']cold_vecs=[nlp(w).vectorforwincold]warm_vecs=[nlp(w).vectorforwinwarm]cold_values=[ice_fire_axis(p)forpincold_vecs]warm_values=[ice_fire_axis(p)forpinwarm_vecs]ice_fire_axis.plot({'values':cold_values,'labels':cold,'color':'tab:blue'},{'values':warm_values,'labels':warm,'color':'tab:red'},poles={'negative':{'label':'ice','color':'blue'},'positive':{'label':'fire','color':'red'}})
Package: saltobserver
This is a simple webapp for presenting data as offered bySalt’s Redis
Returnerwritten inFlask.A static demo is availablehere.Featuresa simple and responsive interface based onpurecss(and their exampleemail layoutto be exact)three main views:a function view showing all minions that ran a particular function (as
shown on the screenshot)a history view for looking at a minion’s history with a specific functiona job view listing all minions which ran a specific joba customizable navbar, which links to function viewssearchpages for everythinglive updates for the function view using websockets andRedis’ Keyspace Notificationsa collapsible representation of raw job data using the awesomerenderjsonRunning it from PyPIJust install it usingpip install saltobserver. As always, it is
recommended to do so in a virtualenv. After that, the commandrun_saltobserverwill be available within this virtualenv. If you want to
use non-default settings (at least look at thedefaults) prefix the command
withexportSALTOBSERVER_SETTINGS=/path/to/config. Other than that, you may
pass gunicorn options to therun_saltobservercommand, they will be passed
on so that you can configure gunicorn for use with a proxy server.A typical deployment could use this command with supervisord:$ export SALTOBSERVER_SETTINGS=/home/saltobserver/config.cfg run_saltobserver -u saltobserver --bind unix:/var/run/saltobserver/socketRunning it with DockerInstall a recent docker version (at least 1.2) and rungit clone https://github.com/analogbyte/saltobserver.git
cd saltobserver
docker build -t saltobserver .
docker run -d --restart=always --name=saltobserver -p 8000:8000 -e REDIS_HOST=redis.example.org saltobserverThis exposes saltobserver to port 8000 and it tries to connect to redis.example.org as redis host. Change the env var or use docker links as suits your needs.
Instead of building it yourself, feel free to use automated build from Docker Hub:docker pull analogbyte/saltobserverRunning it from SourceIf your minions return their data to some Redis instance, it is as
simple as cloning this repo runningscripts/run_saltobserver(and putting
that behind a reverse proxy, if needed). This usesGunicorn, which is pretty
flexible and can be configured for pretty much any setup.Note that your Redis instance has to have a version greater than v2.8.0
for the live updates to work.Also look at the configuration insaltobserver/config.py.
Package: salt-os10
salt-os10Salt-os10 is a small salt state, providing an easy way to configure the configuration of a Dell OS10 switch.It provides a simple interface to apply configuration commands from a template.It does not provide anything else for the moment. Most of others changes can be done via usual salt states.This is abeta version. Use it at your own risk!InstallationSimply run the following command on your switch:pip install salt-os10UsageYou can use in your sls files the following state:test_config:
    os10.managed:
      - source: salt://configAssuming the config file look like:ntp server ch.pool.ntp.orgThe state will parse the lines in your templated file and run it in a 'configure terminal' transation.ParameterssourceSource file. Behave as thesourceargument offile.managed.hashHash of the file. Behave as thehashargument offile.managed.hash_nameType of hash. Behave as thehash_nameargument offile.managed.skip_verifySkip hash verification. Behave as theskip_verifyargument offile.managed.engineTemplate format. Default tojinja. Behave as thetemplateargument offile.managed.contextData pased to the template. Behave as the as thecontextargument offile.managed.defaultsDefault values for the context. Behave as thedefaultsargument offile.managed.commitCommit changes when the state is applied. Default toTrue, setting it toFalsewill revert changes (but will try to run them).
Package: salt-packets
portable, reusable, self-managed salt projectsInstallation$ pip install -r requirements.txt

$ pip install setup.pyDevelopmentThis project includes a number of helpers in theMakefileto streamline common development tasks.Environment SetupThe following demonstrates setting up and working with a development environment:### create a virtualenv for development

$ make virtualenv

$ source env/bin/activate


### run spack cli application

$ spack --help


### run pytest / coverage

$ make testReleasing to PyPiBefore releasing to PyPi, you must configure your login credentials:~/.pypirc:[pypi]
username = YOUR_USERNAME
password = YOUR_PASSWORDThen use the included helper function via theMakefile:$ make dist

$ make dist-uploadDeploymentsDockerIncluded is a basicDockerfilefor building and distributingsalt-packets,
and can be built with the includedmakehelper:$ make docker

$ docker run -it spack --help
Package: salt-pepper
Pepper contains a Python library and CLI scripts for accessing a remotesalt-apiinstance.pepperlibabstracts the HTTP calls tosalt-apiso existing Python
projects can easily integrate with a remote Salt installation just by
instantiating a class.ThepepperCLI script allows users to execute Salt commands from computers
that are external to computers running thesalt-masterorsalt-miniondaemons as though they were running Salt locally. The long-term goal is to add
additional CLI scripts maintain the same interface as Salt’s own CLI scripts
(salt,salt-run,salt-key, etc).It does not require any additional dependencies and runs on Python 2.5+ and
Python 3. (Python 3 support is new, please file an issue if you encounter
trouble.)Installationpipinstallsalt-pepperUsageBasic usage is in heavy flux. You can run pepper using the script in %PYTHONHOME%/scripts/pepper (a pepper.cmd wrapper is provided for convenience to Windows users).exportSALTAPI_USER=saltdevSALTAPI_PASS=saltdevSALTAPI_EAUTH=pampepper'*'test.pingpepper'*'test.kwarghello=dollyExamples leveraging the runner client.pepper--clientrunnerreactor.listpepper--clientrunnerreactor.addevent='test/provision/*'reactors='/srv/salt/state/reactor/test-provision.sls'ConfigurationYou can configure pepper through the command line, using environment variables
or in a configuration file$HOME/.pepperrcwith the following syntax :[main]
SALTAPI_URL=https://localhost:8000/
SALTAPI_USER=saltdev
SALTAPI_PASS=saltdev
SALTAPI_EAUTH=pamContributingPlease feel free to get involved by sending pull requests or join us on the
Salt mailing list or on IRC in #salt or #salt-devel.This repo follows the samecontributing guidelinesas Salt and uses
separate develop and master branches for in-progress additions and bug-fix
changes respectively.
Package: saltshaker-sn
This repo is a refactoring of the SALT training code
for modeling Type Ia supernovae, originally developed by J. Guy.
When using the SALT3 model, please cite arXiv 2104.07795 (<em>https://arxiv.org/abs/2104.07795</em>).We are also developing an additional testing and simulation framework.
Please feel free to message us with any questions and see
<em>https://saltshaker.readthedocs.io/en/latest/</em> for
information on the ongoing work.
Package: salt-sls
Run a single SLS file locally with Salt, without the need for a master or minion setup. This agentless and simplified approach allows faster deployment and testing of SLS files.Aboutsalt-slsis an innovation for those who want a lightweight approach to using SaltStack. With this tool, you can run a single SLS file on your local machine without setting up the more extensive master or minion infrastructure. Whether you’re testing a new SLS or need a quick execution,salt-slsis your friend.What is POP?This project is built withpop, a Python-based
implementation ofPlugin Oriented Programming (POP). POP seeks to bring
together concepts and wisdom from the history of computing in new ways to solve
modern computing problems.For more information:Intro to Plugin Oriented Programming (POP)pop-awesomepop-createGetting StartedPrerequisitesPython 3.8+git(if installing from source, or contributing to the project)InstallationIf wanting to usesalt-sls, you can do so by either
installing from PyPI or from source.Install from PyPIpipinstallsalt-slsInstall from source# clone repogitclonegit@vmware/pop/salt-sls.gitcdsalt-sls# Setup venvpython3-mvenv.venvsource.venv/bin/activatepipinstall.UsageExamplesTo run your SLS files, you can use either the standard Python command or the convenientslscommand.
You can also set specific configuration options through amy_config.yamlfile.Using the standard Python command in the cloned repo:pythonrun.pyexamples/test.slsOr using theslscommand from pypi:echo"test:\n  test.nop:\n    - name: state">test.slsslstest.slsConfigurationSet up configuration options forsalt-slsthrough amy_config.yamlfile. Here’s an example:# my_config.yamlsalt_sls:cachedir:/var/log/salt# Add any minion config opts you want to use under the "minion_opts" key.# Refer to the [official minion config documentation](https://docs.saltproject.io/en/latest/ref/configuration/minion.html) for details.minion_opts:{}RoadmapReference theopen issuesfor a list of
proposed features (and known issues).AcknowledgementsImg Shieldsfor making repository badges easy.
Package: salt-ttp
SALTSTACK TTPRepository to store TTP based SALTSTACK modules:salt-ttp execution modulesalt-ttp runner moduleTTP modulespull requestMotivationTTPis a library for parsing semi structured text using templates.TTP execution and runner modules allow to run commands against minions to obtain text output, parse it using TTP templates and return structured data.Sample use cases that TTP can help to address:reporting across several minions by parsing text output and returning text tablestransforming text data in structured format for storing in minetime series data can be produced using TTP templates and pushed to databases using returnerscompliance testing by parsing text into structured data with further processing and analysis to detect deviationsGiven that text data can be transformed into structured data of arbitrary hierarchy, this modules can significantly expand functionality in the area of minions state analysis and processing.InstallationTo use TTP execution module make sure to install salt-ttp on minion, to use TTP runner module make sure to install salt-ttp on master.FromPyPi distribution:pip install salt-ttpFrom GitHub repository:python -m pip install git+https://github.com/dmulyalin/salt-ttpTo use templates fromTTP templates collection, need to install them as well:pip install ttp_templatesHow to useRun commands to explore doc strings for further usage:salt minion-id sys.doc ttp
Package: salt-verifier
A library that provides both a client and server that can be used to verify a
salt minion’s public key before it is accepted by the master. The server is
meant to run on the minion and listen on port 4533. In order to verify the
public key of the minion, the client generates random challenge messages that
the minion must sign.Installation$ pip install salt-verifierUsageRun the server:$ salt-verifier-serverIt will load the private key of the current minion from/etc/salt/pki/minion/minion.pem.From the master, verify the minion by using the client library like so:from saltverifier.client import is_valid_server_public_key

if is_valid_server_public_key('tcp://minion-ip:4533', 'SOME_PUBLIC_KEY_STR'):
    do-something-when-the-public-is-valid
else:
    do-something-when-the-public-is-invalidInstall an Upstart ScriptFor convenience this package provides a command
Package: salty-gmailer
Salty GmailerSalty Gmailer is a configuration based Gmail automation tool. Configuration is based off of YAML files that utilize
the Gmail search query (q=...) and the addition and subtraction of labels to manage emails.Seeherefor the library of search operators supported.Usageusage: gmailer [-h] [paths ...]

Configuration based automation for gmail.

positional arguments:
paths path containing the rule.yaml files

options:
-h, --help show this help message and exitCurrently, the only arguments are locations of YAML configuration files.For example, if you YAML configuration files were in a relative path to your current
location namedrules, you would execute the program asgmailer ./rulesConfigurationSee the following example of a YAML rule:name: Trash
description: Sends messages to trash
search:
- older_than: 1m
- from: "github_ OR"
- from: notifications-noreply@linkedin.com
  add_labels:
- TRASH
  remove_labels:Currently, name and description are for logging purposes only.searchtakes a list of key/value pairs to filter email messages to act on.  These are taken directly from the Gmail search
query operators.add_labelsis a list of labels to add that match the search criteria, while its inverseremove_labelswill remove labels that match any search criteria.
This rule will find all emails older than 1 month that are from 'github_' or 'notifications-noreply@linkedin.com' and adds the label 'TRASH' to any emails that match, trashing the emails.TODO - Add Tox
Package: salty-ilthermo
salty========To get started using these components in your own software, please go to therepository README_... _README: https://github.com/wesleybeckner/afm-miner/README.mdLicense=======``salty`` is licensed under the terms of the MIT license. See the file"LICENSE" for information on the history of this software, terms & conditionsfor usage, and a DISCLAIMER OF ALL WARRANTIES.All trademarks referenced herein are property of their respective holders.Copyright (c) 2015--, Wesley Beckner, The University of WashingtoneScience Institute.
Package: saltype
READMESaltypestands forSymbolicAlgebraLightType, and is also
a common additive in food preparation, which makes the name fit in the palette
of software developed by me. Salt (as NaCl) is also a substance that can be
found in high quantities in nature. This can be seen in parallel tosaltypebeing developed to obtain derivatives of large scale systems, well at least a
couple of thousand variables.How do I get set up?pip install saltypeThere are no dependencies outside the standard python library to usesaltype.BTW: I first called thissalt, thensalty, and each time somebody else created another package on
pypi with the same name. Now I'll try to upload this before it happens again.TeaserThe core functionality is demonstrated by this very simple example:from saltype import Leaf
from saltype.tools import Derivative

x = Leaf(3.0)
y = 3 * x**2 + 2*x + 1

dy_dx = Derivative([y], [x])[0, 0]
print(dy_dx.value)  # = 6 * x + 2 = 20In applications, we use this package to generate and evaluate Jacobian matrices of O(10000). Then it takes typically O(10) seconds to generate the Jacobian and O(1) second to evaluate it in each iteration. Of course, our Jacobians are also sparse, with less than 50 non-zero elements per row.For developing ...sphinxis required to build the documentation, andpytestis handy to run the tests, though
they also run on the stdlibunittestmodule.To build the documentation from the repo, enter the gendoc directory and runmake htmlAs being generic functionality ofsphinx, this should work on Linux, Wintendo and Mac.There are a number of unit tests in theunittestdirectory. RunContribution guidelinesWell, let's first get a star on github, before we talk about somebody else being
interested in taking this further. Honestly, for many purposes,casadiis a better
choice here, but if you just need something lightweight, maybe on embedded systems,
then this might actually be the niece forsalttype.Contributions in the shape of coding and suggestions are welcome.
The issue tracker is open for that.
Package: saltypie
Saltypie - salt-api client and state return parser.InstallationpipinstallsaltypieLocal client exampleCode:fromsaltypieimportSaltfromsaltypie.outputimportStateOutputsalt=Salt(url='https://192.168.70.11:8000',username='saltapiuser',passwd='abc123',trust_host=True)ret=salt.execute(client=Salt.CLIENT_LOCAL,target='*',fun='state.apply',pillar={'sleep':1})sout=StateOutput(ret)print(sout)Output:+ minion01 ---------------------------------------------------------+
| State                         Plot          %       ms     Result |
+-------------------------------------------------------------------+
| test succeed with changes     ||||||||||||  42.13%  0.404  True   |
| test succeed without changes  ||||||||      29.61%  0.284  True   |
| test no operation             ||||||||      28.26%  0.271  True   |
+-------------------------------------------------------------------+
| Total elapsed time: 0.96ms                                        |
+-------------------------------------------------------------------+Runner client exampleCode:fromsaltypieimportSaltfromsaltypie.outputimportOrchestrationOutputsalt=Salt(url='https://192.168.70.10:8000',username='saltapiuser',passwd='abc123',trust_host=True)salt.eauth='pam'ret=salt.execute(client=Salt.CLIENT_RUNNER,fun='state.orch',args=['orch_fail'],pillar={'sleep':1})orchout=OrchestrationOutput(ret,salt)print(orchout.summary_table(max_bar_size=100,time_unit='s'))Output:+ Orchestration -----------------------------------------------------------------+
   | Step                        Plot                       %       Time(s)  Result |
   +--------------------------------------------------------------------------------+
   | Step01                      |||||||||||||||||||||||||  25.20%   5.13    True   |
   | Step02                      ||||||||||||||||||||||||   24.69%   5.03    True   |
   | Step03                      ||||||||||||||||||||||||   24.79%   5.05    True   |
   | Step04                      |||||||||||||||||||||||||  25.32%   5.16    False  |
   +--------------------------------------------------------------------------------+
   | Total elapsed time: 20.37s                                                     |
   +--------------------------------------------------------------------------------+Terminal safe modeAll output classes have thesafeproperty that is set toFalseif the terminal encoding is dectected to beutf-8. To always use safe mode set it toTrue:Example:fromsaltypieimportSaltfromsaltypie.outputimportStateOutput,OrchestrationOutputsout=StateOutput(ret)sout.safe=True# play with the tables here ...orchout=OrchestrationOutput(ret,salt)orchout.safe=True# play with the tables here ...Disable table coloringSet the output objectcoloredproperty toFalse:Example:fromsaltypieimportSaltfromsaltypie.outputimportOrchestrationOutputorchout=OrchestrationOutput(ret,salt)orchout.colored=False# play with the tables here ...More exampleshttps://gitlab.com/cathaldallan/saltypie/tree/master/examplesDocumentationhttps://cathaldallan.gitlab.io/saltypie/
Package: saluda
Projecto pruebas en pythonPaquete que instala la aplicacion saluda, solo para probar como empaquetar con python usando dependencias y descargando desde PyPi.Aspectos técnicosLuego es importante incluir en el archivosetup.pyinclude_package_data=True,InstalaciónDentro del direcotrio del proyecto pruebas ejecutar:## Uso


## Contribuciones
Son bienvenidos las peticiones de pull, vea primero la lista de asuntos en discución de que le gutaría modificar.

## Liciencia
[MIT](https://opensource.org/licenses/mit-license.php)
Package: saludador
Projecto pruebas en pythonPaquete que instala una simple aplicación de linea de comandos que saca un mensaje por pantalla
en color, usando la librería rich.Instalaciónpip install saludadorUsoen la linea de comandos:> saludaContribucionesSon bienvenidos las peticiones de pull, vea primero la lista de asuntos en discución de que le gutaría modificar.LicienciaMIT
Package: salut
Introduction============Salut is a Gevent based wrapper around the pybonjour library to facilitatethe use of bonjour in a cleaner way.Salut is composed of two main classes, the Announcer and the Browser. Each havea set of callbacks to respond to events without locking the main greenlet.Example=======```pythonclass AnnouncerExample(object):def run(self):self._announcer = salut.Announcer('ServiceName','_regtype._tcp',5000,self._registered_callback)while True:gevent.sleep(1)def stop(self):self._announcer.stop()def _registered_callback(self, domain, regtype, name):print('announcing: %s%s%s' % (domain, regtype, name))``````pythonclass BrowseExample(object):def run(self):self._browser = salut.Browser('ServiceName','_regtype._tcp',self._resolved_callback,self._unresolved_callback)while True:gevent.sleep(1)def stop(self):self._browser.stop()def _resolved_callback(self, ip, port):print('resolved service to %s:%s' % (ip, port))def _unresolved_callback(self):print('lost service %s' % self._service_name)```License=======Salut is licensed under Apache License 2.0http://www.apache.org/licenses/LICENSE-2.0
Package: salutations-maker
Salutation-Maker : A package to greet them all.Short blurb about what your product does.One to two paragraph statement about your product and what it does.InstallationOS X & Linux:npminstallmy-crazy-module--saveWindows:editautoexec.batUsage exampleA few motivating and useful examples of how your product can be used. Spice this up with code blocks and potentially more screenshots.For more examples and usage, please refer to the [Wiki][wiki].Development setupDescribe how to install all development dependencies and how to run an automated test-suite of some kind. Potentially do this for multiple platforms.makeinstall
npmtestRelease History0.2.1CHANGE: Update docs (module code remains unchanged)0.2.0CHANGE: RemovesetDefaultXYZ()ADD: Addinit()0.1.1FIX: Crash when callingbaz()(Thanks @GenerousContributorName!)0.1.0The first proper releaseCHANGE: Renamefoo()tobar()0.0.1Work in progressMetaYour Name –@YourTwitter–YourEmail@example.comDistributed under the XYZ license. SeeLICENSEfor more information.https://github.com/yourname/github-linkContributingFork it (https://github.com/yourname/yourproject/fork)Create your feature branch (git checkout -b feature/fooBar)Commit your changes (git commit -am 'Add some fooBar')Push to the branch (git push origin feature/fooBar)Create a new Pull Request
Package: salute-speech
# Sber Salute Speech Python APIbeware each audio channel is decoded so in many cases downmix to 1 channel is recommendedUsage:` salute_speech--help`Transcribe video to txt:` ffmpeg-ivideo.mp4-ac1-ar16000 audio.wav salute_speechtranscribe-audioaudio.wav-otranscript.txt `Transcribe video to vtt:` ffmpeg-ivideo.mp4-ac1-ar16000 audio.wav salute_speechtranscribe-audioaudio.wav-otranscript.vtt `Supported formats:txtvttsrttsv