Saravanan666/pypi-org huggingface dataset:
Package: salomon
SalomonSage mAker modeL cOpy froM One account to aNotherSolves everlasting issues with Amazon SageMaker:Make copy of a SageMaker model from one account to another (or from one environment to another)Freeze SageMaker model, so that model used for SageMaker endpoints is immutable and safe from incidental modifications by data scientistsSingle-command operation for model copy (fills gaps present in Terraform, CloudFormation, etc.)(currently works only with SageMaker Model Package. TODO: add SageMaker Model support.)InstallationpipinstallsalomonMake a copy of SageMaker Model PackageUsecopy_model_package()function. It makes a copy of SageMaker Model Package.1. Reads source_arn SageMaker Model Package
2. Replaces paths for data files with `dst_s3_path`
3. Replaces docker image URIs with `dst_ecr`
4. Makes a copy of data files to `dst_s3_path`
5. Pulls docker images and then pushes to `dst_ecr`
6. Creates new SageMaker Model Package in current AWS account.Example:Prepare IAM role that can access both source and destination SageMaker resources, ECRs and S3 filesAuthenticate to all source docker registries, for example:awsecrget-login-password--regioneu-central-1|dockerlogin--usernameAWS--password-stdin492215442770.dkr.ecr.eu-central-1.amazonaws.com# all other ECRs ...Execute below code with IAM role created in point 1.fromsalomonimportcopy_model_packagecopy_model_package(source_arn="arn:aws:sagemaker:eu-central-1:1111111111:model-package/source-model-package/1",dst_group_name="copy-of-model-package",dst_s3_path="s3://bucket-in-22222222222/copy-of-model-package",dst_ecr="22222222222.dkr.ecr.eu-central-1.amazonaws.com/copy-of-model-package")
Package: saloon
SaloonSaloon is a hacking environment that is rapidly available from Docker Hub. Compared to the estimated 30 minute setup with Kali or Parrot, Saloon takes roughly 5 minutes to install and 1 second to boot.🚀 InstallationInstall from PyPIpipxinstallsaloon🧨 Running SaloonOnce the container image is built, you can attach to Saloon with Docker# Get a shellsaloon# Run a command and then exitsaloon--nmap-p80-sC-sVscanme.nmap.orgSaving files between runsPersistence is not available yet.NetworkingNetworking is not available, but soon you will be able to do things like set up a netcat listener an accept incoming connections or set up a Burp Suite proxy.Running GUI applicationsNote: Not available on Linux yetThe Docker container is compatible with X11. You just need to set your local XServer to listen on 127.0.0.1.macOS ExampleInstall XQuartzbrewinstall--caskxquartzEnableXQuartz>Preferences>Security>Allow connections from network clientsAdd your local IP as an xhostxhost+127.0.0.1Other ExamplesComing soon. Accepting pull requests for Windows and Linux examples.
Package: salopette
salopetteis an APACHE licensed library written in Python.Installation:From source use$ python setup.py installor install from PyPi$ pip install salopetteLicenseApache v2.0 License
Copyright 2014-2015 Martin Simon

 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at

   http://www.apache.org/licenses/LICENSE-2.0

 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.Buy me a coffee?If you feel like buying me a coffee (or a beer?), donations are welcome:WDC : WbcWJzVD8yXt3yLnnkCZtwQo4YgSUdELkj
HBN : F2Zs4igv8r4oJJzh4sh4bGmeqoUxLQHPki
DOGE: DRBkryyau5CMxpBzVmrBAjK6dVdMZSBsuS
Package: salopylib
Libreria con 4 mÃ³dulos para el ajuste de datos con Kernels diferentes.Modulo 1.Cuenta con una clase que realiza el ajuste de datos de fecha vs cantidad a una curva suave por medio de un kernel gaussiano mediante el metodo ajusteGauss, y los grafica, con el metodo de plotG.Modulo 2.Cuenta con una clase que realiza el ajuste de datos de fecha vs cantidad a una curva suave por medio de un kernel Tricube mediante el mÃ©todo ajuste3C, y los grafica, con el metodo de plot3C.Modulo 3.Cuenta con una clase que realiza el ajuste de datos de fecha vs cantidad a una curva suave por medio de un kernel de Epanechnikov mediante el mÃ©todo ajusteEpa, y los grafica, con el metodo de plotE.MÃ³dulo 4.Cuenta con una clase que realiza la comparacion grafica entre los kernels Gaussiano, Tricube y Epanechnikov para ajuste de datos de fecha vs cantidad a una curva suave y hace su respectiva graficaciÃ³n en el mÃ©todo plotComp,Todos los metodos necesitan los siguientes datos:
path: direccion en que se encuentra el archivo csv que contiene los datos.
h: factor que determina la "suavidad" de la curva y la exactitud del ajuste. Entre menor sea su valor
mas suave sera la curva de ajuste pero mas se alejara de los datos ingresados y viceversa.Nota: La columnas del archivo csv a usar deben tener el nombre literal: fecha_actualizacion y       nuevos_casos
Package: salsa20
Bindings for the NaCL implementation of Salsa20 and XSalsa20 by D. J. Bernstein (taken from libsodium).Compatible with Python 2.6, 2.7 and 3.3.The library performs a self-test at each import.Installationpip install salsa20Usagedef Salsa20_keystream(length, nonce, key)
def Salsa20_xor(message, nonce, key)

def XSalsa20_keystream(length, nonce, key)
def XSalsa20_xor(message, nonce, key)Use[X]Salsa20_keystreamto generate a keystream of the desired length, or pass[X]Salsa20_xora plaintext or a ciphertext to have it XOR’d with the keystream.Being a stream cipher,[X]Salsa20_xordoes both encryption and decryption.All values must be binary strings (stron Python 2,byteson Python 3)Example>>> from salsa20 import XSalsa20_xor
>>> from os import urandom
>>> IV = urandom(24)
>>> KEY = b'*secret**secret**secret**secret*'
>>> ciphertext = XSalsa20_xor(b"IT'S A YELLOW SUBMARINE", IV, KEY)
>>> print(XSalsa20_xor(ciphertext, IV, KEY).decode())
IT'S A YELLOW SUBMARINE
Package: salt-analytics-framework
It’s a framework which extendsSaltthrough the use of anenginethat can collect,
process and forward analytics/metrics data.InstallInstalling Salt Analytics Framework is as simple as:python-mpipinstallsalt-analytics-frameworkConfigurationThe minimal configuration to start salt analytics withSaltis to add it to Salt’s engines
configuration:engines:-analyticsExample Pipelinebeacons:memusage:-interval:5-percent:0.01%status:-interval:5-time:-all-loadavg:-allanalytics:collectors:beacons-collector:plugin:beaconsbeacons:-"*"processors:noop-processor:plugin:noopforwarders:disk-forwarder:plugin:diskpath:/var/cache/saltfilename:events-dumped.txtpretty_print:truepipelines:my-pipeline:collect:beacons-collectorprocess:noop-processorforward:disk-forwarderUsageTBDContributingThe salt-analytics-framework project team welcomes contributions from the community.
For more detailed information, refer toCONTRIBUTING.DocumentationThe full documentation can be seenhere.ExamplesSome examples of custom pipelines are provided.  You can find them atexamples.
Package: saltant-py
saltant SDK for Pythonsaltant-py is a Python SDK forsaltant. It lets you perform any
action possible on the saltant API (some much more conveniently) within
the comforts (hopefully) of Python. As a refresher, you might want to
look atsaltant's API referenceto see what actions are possible.The documentation for saltant-py is fairly comprehensive, and can be
found atsaltant-py.readthedocs.io.InstallationUsing pip,pip install saltant-pyor, from source, after cloning this repository, runpython setup.py installwherepythonis in versions 2.7 or 3.5+.UsageAfter connecting to the saltant server withfromsaltant.clientimportfrom_envclient=from_env()# uses env varsorfromsaltant.clientimportClientclient=Client(base_api_url='https://shahlabjobs.ca/api/',auth_token='p0gch4mp101fy451do9uod1s1x9i4a')You can perform API operations on task types:# Load in a task typemy_task_type=client.container_task_types.get(id=1)# Edit the description of the task typemy_task_type.description="this description is better"# Push the description upstreammy_task_type.put()You can launch task instances:# Launch a task instancemy_task_instance=client.container_task_instances.create(task_type_id=my_task_type.id,task_queue_id=1,arguments={"launch_code":12345},)# Wait for the task instance to finishmy_task_instance.wait_until_finished()And much more! (See the docs for more details.)See alsosaltant-cli, a saltant CLI.
Package: saltaway
Saltaway is a Python package that aims to ease the process of archiving
web pages at multiple archives.Installation is simple:pipinstallsaltawayIt can be used from the command line:saltawayhttps://example.orgAnd in Python:importsaltawaysaltaway.push('https://example.org')There is currently support for theInternet Archive’s Wayback Machineandarchive.is.
Package: salt-cellar
ReadmeA essential tool for retreiving current and past data from the South African Large Telescope.Based on original code from the SALT ELS-WebViewer and powered by SQLalchemy and the pymysql database driver.Please contact SALT Software for a username and password for access to the database.Let's Get To Itfrom salt_cellar import salt_cellar

cellar = salt_cellar.SaltCellar("mysql+pymysql://username:password@db.suth.saao.ac.za/els_view")

results = cellar.single_query(
    [
        "BMS:analogue status:Glycol tank temp>dbl",
    ],
    start=datetime(2020, 1, 23, 18, 0, 0),
    end=datetime(2020, 1, 23, 18, 10, 0),
)

for row in results:
    print(row)DevelopmentRequirementsPython 3.6PipenvClone from BitBucketRun installation command:make installCopyconfig.py.exampletoconfig.pyand update theusernameandpasswordExecute./example.pyThis project uses Semantic Versioning, for more details seehttps://semver.org/
Package: saltclass
|Travis|_.. |Travis| image::https://travis-ci.com/bagheria/saltclass.svg?token=fYbdQUbpnoucyHyb3fs2&branch=master.. _Travis:https://travis-ci.com/bagheria/saltclasssaltclasssaltclass (Short and Long Text Classifier) is a Python module for text classification built under the MIT license.
The project was started in 2018 at the Department of Methodology & Statistics, Utrecht University.Short text classification can be defined simply as follows: Given a set of documents with representation D and a set of labels C, define a function F that will assign a value from the set of C to each document in D. Since short text is characterized by shortness in the length, and sparsity in the representation, we try to optimize D and F in such a way that results in better performance in managing and analyzing EHR text data.Figure below presents the semantic flowchart of the proposed intra-clustering method. In this framework, the clustering procedure is used as the heart of the approach, where it pumps cluster information throughout the body of text via the smoothing system, supplying text length and other information. This method is a hybrid technique, using benefits of different modules, including dictionary- and topic-based approaches, smoothing methods, and cluster information... image::https://github.com/bagheria/saltclass/blob/master/Architecture.pngInstallationTo install via pip::$ pip install saltclass
$ pip install --upgrade saltclassMethods overview.. image::https://github.com/bagheria/saltclass/blob/master/methods.pngSample Usage.. code:: pythonExample 1:
>>> import saltclass
>>> train_X = [[10, 0, 0], [0, 20, 0], [4, 13, 5]]
>>> train_y = [0, 1, 1]
>>> vocab = ['statistics', 'medicine', 'crime']
>>> object_from_df = saltclass.SALT(train_X, train_y, vocabulary=vocab, language='en')
>>> X = [[10, 12, 0], [14, 3, 52]]
>>> object_from_df.enrich(method='kmeans', include_unlabeled=True, unlabeled_matrix=X)
>>> object_from_df.train(classifier='KNN', k=5)Example 2:
>>> object_from_df.enrich(method='lda', include_unlabeled=True, unlabeled_dir='/Data/unlabeled/')
>>> object_from_df.train(classifier='nn', alpha=0.01, hidden_layer_sizes=(50,), max_iter=10, solver='adam', activation='relu')Example 3:
>>> object_from_file = SALT.data_from_dir(train_dir='/train/', language='nl')
>>> object_from_df.enrich(include_unlabeled=False)
>>> object_from_df.train(classifier='svm', kernel='sigmoid')
>>> object_from_df.print_info()>>> prediction = object_from_df.predict(data_file='second_test.txt')
>>> print(object_from_df.vocabulary)
>>> print(object_from_df.newdata)
>>> print([k for (k, v) in object_from_df.vocabulary.items() if object_from_df.newdata[0][v] != 0])
>>> print(prediction)Dependenciessaltclass requires:

- Python (>= 3.5)
- NumPy (>= 1.11.0)
- SciPy (>= 0.17.0)
- LDA
- Scikit-learn (>= 0.20.0)
- Matplotlib (>= 3.0)
- Tqdm
- Language_check
Package: saltcli
saltcliA CLI with autocompletion and syntax highlighting for salt commands.Free software: ISC licenseDocumentation:https://saltcli.readthedocs.org.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.0.1 (2015-09-01)First release on PyPI.
Package: salt-cloud
Salt Cloud is a tool for provisioning salted minions across various cloud
providers. Currently supported providers are:-Amazon EC2-GoGrid-HP Cloud (using OpenStack)-Joyent-Linode-OpenStack-Rackspace (using OpenStack)-Parallels-DigitalOcean-IBM Smart Cloud Enterprise-SoftLayerThe salt-cloud command can be used to query configured providers, create VMs on
them, deploy salt-minion on those VMs and destroy them when no longer needed.Salt Cloud requires Salt to be installed, but does not require any Salt daemons
to be running. However, if used in a salted environment, it is best to run Salt
Cloud on the salt-master, so that it can properly lay down salt keys when it
deploys machines, and then properly remove them later. If Salt Cloud is run in
this manner, minions will automatically be approved by the master; no need to
manually authenticate them later.DocumentationInstallation instructions, and getting started guides.https://salt-cloud.readthedocs.org/en/latest/IRC ChatJoin the vibrant, helpful and positive Salt Stack chat room in Freenode at
#salt. There is no need to introduce yourself, or ask permission to join in,
just help and be helped! Make sure to wait for an answer, sometimes it may take
a few moments for someone to reply.http://webchat.freenode.net/?channels=salt
Package: salt-confd
Lightweight Salt package à laconfdmanagement of local application configuration files.WhyPlease note that the intent of this software package is not to compete againstconfdor other popular equivalents; it was born purely out of my personal
preference / bias of using Salt for managing files (and others). Salt is
typically at the opposite end of “lightweight” and this package aims to
alleviate this, however it still cannot get better thanconfd- from this
perspective. Alas, it’s written in Python (please let’s not have this discussion
over here 😄).In short, here’s why I took this approach:Why not? It’s fun.I like Salt, and it offers a variety of well-known templating languages to
manage the files, including Jinja, Mako, Cheetah, or even pure Python - and
others. In other words, I find that I prefer to use something I’m already
comfortable with, particularly in environments where Salt is already a
requirement.What I find missing inconfdis the possibility to manage the local config
files based on more environment parameters - e.g., have idempotent templates
that can be used across a number of distributions (as in opposite to having
separate files / directory tree / or even repositories for different
base operating system distribution); with Salt, this can be very easily done
using the Grains.Not only local templates: it often happens to have your template on a server
elsewhere; at the end of the day, you need the resulting config file, not its
source.
With Salt Confd, you can use source files directly available via HTTP, S3,
SWIFT, SVN, or FTP.Salt covers a large variety of backends to fetch the data from (including
Redis, Vault, Consul, etcd, and so on).Salt is easily extensible (not by forking the project), but in
your own environment by simply putting the module for your backend of choice
under a specific path.Or, to put this differently, if you need a different backend, or an additional
feature, you won’t need to fork the entire project and re-compile it; instead,
you can preserve the existing usage and just provide it with your own code
implementing the feature or backend you need.Installation$pipinstallsalt-confd
Package: salt-container-map
Salt Container-MapConfiguration management and implicit dependency setup for Docker containers in SaltStack.Project:https://github.com/merll/salt-container-mapDocs: Basic usage is provided in thestate
module.
Details about container configurations are available in thedocs for
Docker-Map.OverviewThis package contains SaltStack modules for configuring Docker
containers. They do not replace, but complement Salt’s built-indockeriomodule in the following aspects:Container dependencies that have to be followed during startup and
shutdown do not have to be modelled viarequireorrequire_in. Instead, these are implicitly defined through their
shared volumes and links.For the purpose of sharing data between containers, virtual volumes
can be created via a minimal runnable image (tianon/trueobtained
from the public Docker registry). These are considered during the
dependency check and become adjusted with necessary file system
permissions during startup.When the configuration of a container is modified, the affected
containers and their dependents can automatically be shut down and
recreated.Image updates can also result in an automated shutdown and recreation
of containers and their dependents, without explicitwatchoronchanges.An example is documented in the state module.InstallationBesides the usual package installation, a few simple post-installation
steps are required. They are described in thedocs.ModulesCustom rendererContainer configurations can be set in both pillars and states. Pillars
have the advantage that they are loaded automatically before any state
(e.g.container_map.updated) or execution module uses it. Usually
the disadvantage is that pillars cannot refer to other pillars. This
package however provides a custom rendererlazy_yamlalong with
custom tags!pillarand!grain, which are resolved to their
values on the minion just before the container maps and their
configurations are instantiated.By default, container maps are loaded from a pillarcontainer_maps.
This can be changed in the configuration by setting the configuration
valuecontainer_map.pillar_name.State and execution moduleThe modules distributed to the minions provide the functionality as
outlined in the overview. A usage example is included in thestate
module
documentation.
Package: salt-cumin
Cumin contains a Python library and CLI scripts for accessing a remotesalt-apiinstance.cuminabstracts the HTTP calls tosalt-apiso existing Python
projects can easily integrate with a remote Salt installation just by
instantiating a class.ThecuminCLI 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).Installationpipinstallsalt-cuminUsageexportSALTAPI_USER=saltdevSALTAPI_PASS=saltdevSALTAPI_EAUTH=pamcumin'*'test.pingcumin'*'test.kwarghello=dollyExamples leveraging the runner client.cumin-runreactor.listcumin-runreactor.addevent='test/provision/*'reactors='/srv/salt/state/reactor/test-provision.sls'ConfigurationYou can configure cumin 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=pam
Package: salt-cumulus
salt-cumulusSalt-cumulus is a small salt state, providing an easy way to configure the configuration of a cumulus switch.It provides a simple interface to applynetcommands 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-cumulusUsageYou can use in your sls files the following state:test_config:
    cumulus.managed:
      - source: salt://configAssuming the config file look like:net add time ntp server ch.pool.ntp.orgThe state will parse the lines in your templated file and run each command starting withnet addornet del. Others elements are ignored, so you may add comments or other data as you like, but we suggest you starts comments with#.WarningRunning this state will abort any pending configuration first: you should avoid using thenetcommand at the same time!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: saltedmd5
To use Salted MD5:fromsaltedmd5importSalting# user = Salting(<password>, <grams-of-salt>)user_1=Salting('mypassword',<grams-of-salt>)user_1.seasoning()Result:user_1.showinfo(){'password':'mypassword','salted_password':'45f6717a673f740c636479a9b7b98b9c','salt':'8LG6et9315DjPuupKBpD'}''' check_authentication(<to-be-checked-password>) '''user_1.check_authentication('mypassword')Passwordsmatched!!''' create_json(<name-of-file>) '''user_1.create_json('user_1')JSONcreated!!Available Methods.seasoning().show_info()create_json(name_of_file)check_authentication(new_user_password)Installationsaltedmd5 can be installed from PyPI:pipinstallsaltedmd5What it issaltedmd5 is a work based onhashlib. It aims to provide developers with a Python functionality to generate simplesalted password hashingwhich concerns the security of user account systems.ChangesPlease refer toCHANGELOGGetting InvolvedEverybody is welcome, please feel free to get on board :)