Saravanan666/pypi-org huggingface dataset:
Package: distributed-counter
Overviewdistributed_counteris a python package for maintaining counters across clusters of computers.
It leveragesAWS DynamoDBfor storage and atomicity of the counter.Installationdistributed_counteris compatible withpython2andpython3.
Simply usepipto install.pip install distributed_counterYou'll also want to set up youraws configurations.UsageThe interface fordistributed_counteris very simple.
Everything is done through theDistributedCounterclass.
To instantiate:from distributed_counter import DistributedCounter

counter = DistributedCounter('my_dynamo_table_name')You can pass anything inkwargsto DistributedCounter and they will be propagated to the boto3 Session, e.g.counter = DistributedCounter('mytable', region_name='us-west-1', aws_access_key_id='somekey',
                             aws_secret_access_key='somesecret')There are also special parametersconfigandendpoint_urlwhich get passed to the
DynamoDB ServiceResource.Table CreationThe dynamodb table has one HASH key calledkey. You can create the table yourself, or you can usecreate_table.counter.create_table()distributed_counteris smart enough to wait for the table to finish creation on your next call to the table.Getting/SettingNext, you can set a key usingputand get it withget:counter.put('mykey', 0)
counter.get('mykey')
0Increment/DecrementingFinally, you canincrement/decrement.counter.increment('mykey', 10)
10
counter.increment('mykey', 5)
15
counter.decrement('mykey', 14)
1Note that the returned value is the new value.You can useincrement/decrementwith a default.
This is the same as doing aputthen anincrement/decrement.counter.increment('nonexistantkey', 0, 0)
0
counter.increment('someotherkey', 0, 10)
10
counter.increment('yetanotherkey', 1, 10)
11Example UseLet's say we want to run a function every 100 calls to an API.
In your API, you can put:if not counter.increment('mykey', 1) % 100:
    run_function()
    counter.decrement('mykey', 100)This guarantees that no matter how many servers you have, every 100 calls to your API will run your function.The modulo is used instead of==because there is a corner case where hypothetically you could increment to 200 before
the decrement finishes.
Package: distributed-discovery
Distributed DiscoveryA process mining Python library based onPM4Pyto discover inter-organizational
processes.InstallationAt least Python version 3.7 is required.pip install distributed-discoveryUsageimportdistributed_discoveryasddlog=dd.read_xes("./event-log.xes")bpmn_diagrams,message_bpmn_nodes,sent_messages=dd.discover_bpmn(log)dd.view_bpmn(bpmn_diagrams,message_bpmn_nodes,sent_messages)
Package: distributed-mean-estimation
distributed-mean-estimationAlgorithms for Distributed Mean Estimation (DME) in PyTorch.InstallationInstall this library usingpip:pip install distributed-mean-estimationUsageUsage instructions go here.DevelopmentTo contribute to this library, first checkout the code. Then create a new virtual environment:cd distributed-mean-estimation
python -m venv venv
source venv/bin/activateNow install the dependencies and test dependencies:pip install -e ".[test]"To run the tests:pytest
Package: distributed-networking-utilities
Distributed computing patterns and utilities.Fast inter-nodes data exchanging in a distributed setup. Implementation of
a pattern for fast data sharing (numpy arrays, json objects, etc ..) among nodes
of a distributed system configuration. Makes use of ZeroMQ and python
multiprocessing.This projet might be usefull to construct massive processing sytems like Machine
Learning and Computer Vision setups that needs to cope with several connections
and processing requests.DISCLAIMER: This project is under construction.
Package: distributed-trajectories
Distributed TrajectoriesProvides some basics for manipulation with the descrete distributed trajectories  with the Spark engineFree software: MIT licenseDocumentation:https://distributed-trajectories.readthedocs.io.AcknowledgmentThis work up to 2021-04-30 was entirely supported by a research grant to Principal Investigator Raazesh Sainudiin titledMobile Phone Data for Society and Privacy for the Individual: From the Conflict to a Synergy in Transport Flows Analysisfrom  Research Center for Cyber Security at Tel Aviv University established by the State of Israel, the Prime Minister’s Office and Tel-Aviv University.FeaturesTODOInstallationclone the public repository:$gitclonegit://github.com/raalesir/distributed_trajectoriescreate a Python virtual environment$cddistributed_trajectories/distributed_trajectories&&python3-mvenvtaxiactivate  thevenv. Checkwhich pythonto point to the current directory.$sourcetaxi/bin/activateinstall dependencies:$pip3install-rrequirements.txtCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2021-03-08)First release on PyPI.
Package: distribute-install_component
This package adds a command to distribute to interact with the extra components
listed inextras_require.For example, you could write asetup.pycontaining:setup(
    name="Project-A",
    ...
    extras_require={
        'PDF': ["ReportLab>=1.2", "RXP"],
        'reST': ["docutils>=0.3"],
    }
 )Thendistribute-install_componentallows you to write:$ python setup.py install_component PDF reSTto install the dependencies needed for these features.Commandline Argumentsinstall_componenttakes a list of components to install dependencies for.
These must be listed in theextras_requiresection of the package.The-loption can be used to list the components available.Configuring a packageTo makedistribute-install_componentavailable in your package, you can add
it tosetup_requiresin yoursetup.py:setup(
    name='myproject',
    ...
    setup_requires=[
        'distribute-install_component',
    ]
)TipsYou can usedistribute-install_requiresto provide development
dependencies, such as documentation builders or testing packages:setup(
    name='myproject',
    ...
    setup_requires=[
        'distribute-install_component',
    ],
    extras_require={
        'test': ['nose==1.1.2', 'mock==0.8.0'],
        'docs': ['Sphinx>=1.1.3', 'sphinxcontrib-httpdomain==1.1.7'],
    }
)Then normal users can just run$ python setup.py installWhile developers can run$ python setup.py develop install_component test docs
Package: distribution-algebra
distribution-algebraA python package that implements an easy-to-use interface for random
variables, statistical distributions, and their algebra.This Python package is brought to you byVaibhav Karve.distribution-algebrarecognizes Normal, Lognormal, Beta and Poisson
distributions. The package implements an interface to easily construct
user-defined Univariate distributions as well Vectorized distributions.Additional features include:Aplotfunction for probability density/mass function plotting.Adrawfunction for drawing random samples of specified size from a given distribution.Addition and multiplication operations defined directly on distributions:For example, the sum of two Normal (Poisson) distributions is Normal (Poisson).The product of two Lognormal distributions is Lognormal.The sum of two arbitrary univariate distributions is expressed as a Vectorized distribution.This package is written in Python v3.10, and is publicly available
under theGNU-GPL-v3.0
license.Installation and usageTo get started on using this package,Install Python 3.10 or higher.python3.10 -m pip install distribution-algebraUse it in a python script (or interactive REPL)fromdistribution_algebraimportBeta,Lognormal,Normal,Poissonx:Normal=Normal(mean=1.0,var=9.0)y:Normal=Normal(mean=1.0,var=16.0)assertx+y==Normal(mean=2.0,var=25.0)
Package: distribution-pack
# Distribution PackThe package was build to calculate binomial and gaussian distributions.
This is an exercise for udacity data scientist nanodegree.# FilesBinomialdistribution.py- Binomial distribution class for calculating and visualizing a Binomial distribution.Gaussiandistribution.py- Gaussian distribution class for calculating and visualizing a Gaussian distribution.Generaldistribution.py-  Generic distribution class for calculating and visualizing a probability distribution.# Installationpip install distribution-pack# Requirementsseaborn==0.11.0plotly==4.14.1pandas==1.1.3numpy==1.19.2matplotlib==3.3.2
Package: distributionPackage
A tool for packaging a set of files for distribution using a YAML manifest definition from thepackageManifest project.Contents1Main Features2Installation3Getting Started4DOI Archive1Main FeaturesSimple default operationzip or tar-gzip package generation (or both)Specify project path to build package fromAppend manifest files to an existing tar or zip package2InstallationThe simplest way to acquiredistributionPackageis usingpip.pipinstalldistributionPackageIt’s highly recommended that you install the package into aPython virtual environment.3Getting StartedDefine a package manifest in a YAML file. The default name expected bydistributionPackageismanifest.yml. The example
below constructs a simple manifest for a hypothetical C++ project.-include:files:['README.md','LICENSE','VERSION']-global-include:files:['*.h','*.cpp']-prune:directory:'scripts'Assuming that you have installeddistributionPackageand that themakePackagecommand is in your path,makePackageBy defaultmakePackagewill acquire the manifest definitions from./manifest.yml, output a filedistribution-out.tar.gzin the current directory and assume that the current directory is the root directory of the
project to be packaged (for the basis of constructing the package file names from the manifest).Multiple manifest files may also be specified using the--manifestsargument. The YAML data from the files are concatenated in the same
order as the file names into a single manifest.Using the--helpoption will describe the various options available.>makePackage--helpusage:makePackage[-h][-a][-m[MANIFEST_PATH[MANIFEST_PATH...]]][-oOUTPUT][-pPACKAGE][-rPROJECTROOT][-n][-z]Buildadistributionpackagefromamanifestoptionalarguments:-h,--helpshowthishelpmessageandexit-a,--appendAppendtoanexistingdistributionpackage,ifitexists.Createdotherwise.(defaultdisabled)-m[MANIFEST_PATH[MANIFEST_PATH...]],--manifests[MANIFEST_PATH[MANIFEST_PATH...]]Manifestfile(s)tousetobuildthepackage.(defaultmanifest.yml)-oOUTPUT,--outputOUTPUTDirectorytoplacethegenerateddistributionfiles.Createdifnotpresent.(default./)-pPACKAGE,--packagePACKAGEFilenamestubofoutputpackage,notincludingsuffixorversioninfo.(defaultdistribution-out)-rPROJECTROOT,--project-rootPROJECTROOTProjectroottopackagefilesfrom.(default./)-n,--no-tarDisabletar,gzipoutputdistribution.(defaultenabled)-z,--zipEnablezipoutputdistribution.(defaultdisabled)4DOI Archive0.3.00.4.00.5.00.6.0
Package: distributions
# Distributions[![Build Status](https://travis-ci.org/posterior/distributions.svg?branch=master)](https://travis-ci.org/posterior/distributions)
[![Latest Version](https://badge.fury.io/py/distributions.svg)](https://pypi.python.org/pypi/distributions)
[![DOI](https://zenodo.org/badge/29212688.svg)](https://zenodo.org/badge/latestdoi/29212688)Distributions provides low-level primitives for
collapsed Gibbs sampling in Python and C++ including:special numerical functions,samplers and density functions from a variety of distributions,conjugate component models (e.g., gamma-Poisson, normal-inverse-chi-squared),clustering models (e.g., CRP, Pitman-Yor), andefficient wrappers for mixture models.Distributions powered a machine-learning-as-a-service for Prior Knowledge Inc.,
and now powers machine learning infrastructure at Salesforce.com.## InstallationFor python-only support (no C++) you can install with pip:pip install distributionsFor help with other builds, see
[the installation documentation](http://distributions.readthedocs.org/en/latest/installation.html).## DocumentationThe official documentation lives athttp://distributions.readthedocs.org/.Branch-specific documentation lives at[Overview](/doc/overview.rst)[Installation](/doc/installation.rst)## Authors (alphabetically)Jonathan Glidden <https://twitter.com/jhglidden>Eric Jonas <https://twitter.com/stochastician>Fritz Obermeyer <https://github.com/fritzo>Cap Petschulat <https://github.com/cap>Stephen Tu <https://github.com/stephentu>## LicenseCopyright (c) 2014 Salesforce.com, Inc. All rights reserved.Licensed under the Revised BSD License. See [LICENSE.txt](LICENSE.txt)
for details.
Package: distributions-asyn
Distributions-packageAuthor: Anastasia SyntychakiEmail:asyntychaki@gmail.comAbout:This is an OOP-based package nameddistributions-asynfor calculating and visualizing Gaussian and Binomial distributions of numerical data.Installation:Thedistributions-asynpackage requires Python 3.x versions. It has the following dependencies:MatplotlibMathIt is available at PyPI and can be installed using:pip install distributions-asynFile Descriptions:distributions-asyn/Generaldistribution.py:A generic distribution class that calculates and visualizes a probability distribution.distributions-asyn/Gaussiandistribution.py:A Gaussian distribution that inherits from the Generaldistribution. It calculates and visualizes a Gaussian distribution.distributions-asyn/Binomialdistribution.py:A Binomial distribution that inherits from the Generaldistribution. It calculates and visualizes a Binomial distribution.distributions-asyn/__init__.py:The package initialization file.distributions-asyn/setup.cfg:README.md metadata.distributions-asyn/license.txt:Copyright information.setup.py:Setup file with package metadata.
Package: distributions-bc
distributions_bc packagePrerequisitesPython 3.7.4+
matplotlib packageFilesContains 3 files:generaldistribution.pybinomialdistribution.pygaussiandistribution.pyDescriptiongeneraldistribution.py contains a Distribution classbinomialdistribution.py creates a Binomial class that inherits from the Distribution class. This Binomial class has attributes typically associated with a Binomial Distribution (n, p, k, mean, stdev etc.) that can be either specified or determined from a file read in. The Binomial class also has methods that allow the computation of the probability distribution function and its plotting. A magic method that allows the addition of 2 Binomial Objects with the same p is also presentgaussiandistribution.py creates a Gaussian class that inherits from the Distribution class. This Gaussian class has attributes typically associated with a Gaussian Distribution (mean, stdev) that can be either specified or determined from a file read in. The Binomial class also has methods that allow the computation of the probability distribution function and its the plotting. A magic method that allows the addition of 2 Gaussian Objects is also presentInstallationpipinstalldistributions_bcUsagefromdistributions_bcimportGaussiang1=Gaussian(mu=23,sigma=2)g1.mean# 23g1.stdev# 2g1.pdf(x=22)# 0.2787008074875851g1.read_data_file('numbers.txt')# Reads file and updates attributes and parametersAuthorsCharles GautheyLicensedistributions_bc is offered under the MIT license
Package: distributions-by-rrod
Gaussian DistributionThis package contains 3 main python files. GeneralDistribution,Gaussiandistribution and BinomialDistribution
	- General Distribution:
        The Generic distribution class is for calculating and visualizing a probability distribution.
        Also there is a function called read_data_file that reads in data from a txt file. The txt file should have
        one number (float) per line. The numbers are stored in the data attribute. Currently using numbers.txt as an example
    - Gaussian Distribution:
        The Gaussian distribution class for calculating and visualizing a Gaussian distribution.
	- Binomial Distribution:
	    The Binomial distribution class for calculating and visualizing a Binomial distribution.
	
	## Getting Started
	
	pip install distributions_by_rr
	
	
	These 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.
	Prerequisites
	
	please see requirements.txt


	## Running the tests
	
	tests.py is located in the tests folder. To run it:
	
	cd topackage
	python -m unittest test
	
	
	##Contributing
	Please submit pull requests

	
	##Authors
	RabiaR

	
	
	## License
	This project is licensed under the MIT License - see the LICENSE.md file for details
	Acknowledgments
		§ Hat tip to anyone whose code was used
		§ Inspiration
		§ etc
Package: distributions-for-dsnd
# Distributions
This package calculates Gaussian and binomial distributions and is part of an exercise of Udacity’s nano degree program in data science.## Installation
You can use pip to install the package:
‘’’python
pip install -ihttps://test.pypi.org/simple/distributions-for-dsnd
‘’’## Usage
‘’’python
from distributions_for_dsnd import Gaussian, Binomial# returns a Gaussian distribution with a mean and standard deviation equal to the input
Gaussian(10, 7)# returns a Binomial distribution with a probability and number of samples equal to the input
Binomial(0.4, 25)
‘’’
Package: distributions-gb001
distributions_gb001distributions_gb001 is a Python package  for calculating and visualizing a Gaussian distribution and binomial distribution.DescriptionWhat you can do with the package:
for Gaussian distribution and binomial distribution-   calculate mean and standard deviation.
-   calculate Probability density function
-   plot and visualize the normalized histogram of the data and a plot of the 
	probability density function along the same range or bar probability density function of a binomial distribution
-   add together two Gaussian or Binomial distributionsInstallationUse the package managerpipto install distributions_gb001.pipinstalldistributions_gb001Dependencymatplotlib (to visualize plotted histogram/bar)pipinstallmatplotlibUsageimportdistributions_gb001**-withoutdatafile**gaussian_one=distributions_gb001.Gaussian(22,3)binomial_one=distributions_gb001.Binomial(.9,20)gaussian_one.mean# returns 22binomial_one.stdev# returns 1.3416407864998736gaussian_one+gaussian_one# returns 'mean 44, standard deviation 4.242640687119285'**-withdatafile**gaussian_two=distributions_gb001.Gaussian()gaussian_two.read_data_file("/home/myname/Desktop/numbers.txt")# read in data from a txt filegaussian_two.calculate_mean()# calculate meangaussian_two.mean# returns mean valuegaussian_two.calculate_stdev(sample=True)# calculate standard deviation ......"""note -sample (bool): whether the data represents a sample or population which is set to True as default"""gaussian_two.stdev# returns standard deviation valuegaussian_two.pdf(x)# returns Probability density function output"""x (float): point for calculating the probability density function"""gaussian_two.plot_histogram_pdf(n_spaces=50)# visualize normalized histogram with your set spaces"""n_spaces (int): number of data points which is set to 50 as default"""binomial_two=distributions_gb001.Binomial()binomial_two.read_data_file("/home/myname/Desktop/numbers_bin.txt")# read in data from a txt filebinomial_two.calculate_mean()# calculate meanbinomial_two.mean# returns mean valuebinomial_two.calculate_stdev()# calculate standard deviation ......binomial_two.stdev# returns standard deviation valuebinomial_two.replace_stats_with_data()# to get new mean and standard deviation from the data set""" by default --- mean = 10.0standard deviation = 2.23606797749979"""binomial_two.mean# returns new mean valuebinomial_two.stdev# returns new standard deviation valuebinomial_two.pdf(k)# returns Probability density function output"""k (integer): point for calculating the probability density function"""binomial_two.plot_bar_pdf()# visualize normalized histogram with your set spaces"""n_spaces (int): number of data points which is set to 50 as default"""""""Note : make sure "matplotlib" is installed" to visualize"""""""Note : to provide GUI backend to show figures, make sure python Tkinter is installed - for linux/ubuntu --- sudo apt install python3-tk"""AuthorAbeeb Ridwan OlumideContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.Please make sure to update tests as appropriate.LicenseMIT
Package: distributions-harsh
distributions-harsh packageThis is a simple distributions package for calculating Gaussian and Binomial distributions.FilesGeneraldistribution.pyGeneric distribution class for calculating and visualizing a probability distribution.Gaussiandistribution.pyGaussian distribution class for calculating and visualizing a Gaussian distribution.Binomialdistribution.pyBinomial distribution class for calculating and visualizing a Binomial distribution.Installationpip install distributions-harsh
Package: distributions-kareem
Table of ContentsAbout The ProjectGetting StartedInstallationLicenseContactAcknowledgementsAbout The ProjectThis project was built for the Udacity Data Science Nanodegree Program.Getting StartedThis is an example of how you may give instructions on setting up your project locally.
To get a local copy up and running follow these simple example steps.Installationpip install distributions-kareemLicenseDistributed under the MIT License. SeeLICENSEfor more information.ContactKareem Ayyad-@kareem_ayyad-kareem@ayyad.netProject Link:https://github.com/kareemayyad/PyPi-Package-Gaussian-DistributionAcknowledgementsSome of the code used was provided by Andrew Paster, Udacity Instructor, as well as the detailed instructions for creating this project.Thanks!
Package: distributions-mx-hsl
Probability Distribution packageWithin this package a Binomial class and a Gaussian class is implemented.It helps generating and handling with Gaussian and Binomial distributions.Binomial classmean- representing the mean value of the distributionstdev- representing the standard deviation of the distributiondata_list-  list of floats to be extracted from the data filep- presenting the probability of an event occurringn- number of trialsGaussian classmean- representing the mean value of the distributionstdev- representing the standard deviation of the distribution
Package: distributions-ops-udacity
# distributions-udacity packageThe package contains modules that can be used to create Binomial and Gaussian distribution objects and perform operations on them.# FilesBinomialdistribution.py: Contains the Binomial class that can be used to create binomial distribution objects, given the number of trials and the probablity of an event occuring, or by reading in data from a data file.Gaussiandistribution.py: Contains the Gaussian class that can be used to create gaussian distribution objects, which can be initialized providing the distribution’s mean and standard deviation or reading in data from a file.Generaldistribution.py: Contains the Distribution class, with common dsitribution attributes and methods. Inherited by both, Binomial and Gaussian classes.# Installationpip install distributions-ops-udacity# Usage Example>>> from distributions import *
>>> Binomial(0.3, 10)
mean 3.0, standard deviation 1.4491376746189437, p 0.3, n 10
>>> Gaussian(10, 80)
mean 10, standard deviation 80
>>> bd1 = Binomial(0.4, 20)
>>> bd2 = Binomial(0.4, 30)
>>> bd1 + bd2
mean 20.0, standard deviation 3.4641016151377544, p 0.4, n 50
>>> gd1 = Gaussian(8, 20)
>>> gd2 = Gaussian(7, 30)
>>> gd1 + gd2
mean 15, standard deviation 36.05551275463989## Read line separated values from a file>>> gd1.read_data_file('/home/numbers.txt')
>>> gd1.calculate_mean()
78.0909090909091
>>> gd1.calculate_stdev()
92.87459776004906
>>> bd1.read_data_file('/home/numbers_binomial.txt')
>>> bd1.replace_stats_with_data()
(0.6153846153846154, 13)
>>> bd1.mean
8.0
>>> bd1.stdev
1.7541160386140584
Package: distributions-probmax
Distributions-MaxDistributions-Probmax is a Python library for basic operations with general probability distributions. It includes packages to handle and plot gaussian and binomial distributions out of the box.InstallationUse the package managerpipto install foobar.pipinstalldistributions-probmaxUsagefromdistributions_probmaximportGaussian,BinomialGaussian(10,7)Binomial(0.4,25)ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.Please make sure to update tests as appropriate.LicenseMIT