Saravanan666/pypi-org huggingface dataset:
Package: distributions-study
distributions_studydistributions_study is a Python library for dealing with Gaussian and
Binomial Distribution and allows you to perform analysis of both. For
extensions, you can read the data from txt file for both the
distribution types. Analysis of the data will be easy with the help of
different methods this package contains1. calculate_mean
2. calculate_stdev
3. pdf
4. plot_bar  #for binomial distribution
5. plot_histogram #for Gaussian distribution
6. plot_bar_pdf #plotting PDF for Binomial distribution
7. plot_histogram_pdf   #plotting PDF for Gaussian distribution
8. read_data_file  #for reading the .txt file

Data formats for txt file

1. Gaussian : comma separated values
2. Binomial : 0,1 list of experiment outcomesInstallationUse the package managerpipto install distributions_study.pipinstalldistributions_studyUsageimportdistributions_studydistributions_study.Gaussian(10,4)# returns Gaussian distribution object with mean 10, standard deviation 4distributions_study.Binomial(0.4,25)# returns Binomial distribution object with success event probability 0.4, size of distribution 25ContributingPull 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: distributionsx
The Packagedistributionsxdoes:calculate mean, standard deviation, pdf and sum of normal and binomial distributions (when p value is same for both).plot histogram for normal distribution and bar plot  for binomial distribution.plot pdfFilesGeneralDistribution.py: It has the parent class Distribution inherited by Gaussiandistribution and Binomialdistribution in Gaussiandistribution.py and Binomialdistribution.py files respectively. It's read_data_file method reads the text data file, save it in self.data in init magic method and also calculate mean and standard deviation and save it on the self object.Gaussiandistribution.py: This file contains the child class Gaussiandistribution that inherits from GeneralDistribution and caculate mean, standard deviation for normal distribution using mathematical formulas written in python using in built modules (math) and other libraries (numpy). It also codes the magic method for the addition of two normal distributions by adding their means and summing their standard deviations by taking the square root of the sum of the square of the standard deviations of both distributions objects. It also has methods for plotting the histogram, and calculating and plotting the pdf. Thereprmethod outputs the characteristics of the Gaussian instance.Binomialdistribution.py: This file contains the child class Binomialdistribution that inherits from GeneralDistribution and caculate mean, standard deviation for binomial distribution. It also codes the magic method for addition of two binomial distributions when the probability of the success(p) for both is same. It also has methods for plotting bar graph, and calculating and plotting the pdf. Thereprmethod outputs the characteristics of the Binomial instance.Package installation:pip install distributionsxExamplesopen a python shell in terminal after installing the package.pythonimport the package in the python shell.from distributionsx import Gaussian, BinomialCreate a Gaussian object with mean 10 and standard deviation 5 and check the output in the terminal:Gaussian(10, 5)Create a Gaussian object with probability 0.5 and number of trials 10 and check the output (mean, standard deviation, probability of an event occuring, and number of trials) in the terminal:Binomial(0.5, 10)
Package: distributor
“Let me show, where your service”What is it?When you have many frontend servers - it’s a big headache to know, which of them listens your service now, especially, if you often need to move some services between groups of frontend balancers.
Moreover, if you have so many domain names, it is also difficult to monitor their actuality without automatic systems.Distributoris a web app, which can get Nginx and HAproxy configurations from your frontend servers, and clearly show which of your frontends listen each service and ip address.How it works?Distributorcan get configs from GitLab, where frontends push their Nginx and HAproxy configs, also it can get dns zone transfers and handle list of your domains from nic.ru.If your fronts doesn’t push their configs, you need to customize code to get configs from other places.Usagesudo-uwww-datadistributor-gen-cconfig.ini-ldistributor.log-o/var/www/Where config.ini is your config file as described in documentation, and /var/www/ is the directory, which published by some static web-server.
Package: district42-exp-types
district42 experimental typesdistrict42experimental typesInstallationpip3installdistrict42-exp-typesUsagenumericfromdistrict42importschema,register_typefromdistrict42_exp_types.numericimportNumericSchemaregister_type("numeric",NumericSchema)print(schema.numeric)uuidfromdistrict42importschema,register_typefromdistrict42_exp_types.uuidimportUUIDSchemaregister_type("uuid",UUIDSchema)print(schema.uuid)uuid_strfromdistrict42importschema,register_typefromdistrict42_exp_types.uuid_strimportUUIDStrSchemaregister_type("uuid_str",UUIDStrSchema)print(schema.uuid_str)sdictfromdistrict42importschema,register_typefromdistrict42_exp_types.sdictimportSDictSchemaregister_type("sdict",SDictSchema)print(schema.sdict)unorderedfromdistrict42importschema,register_typefromdistrict42_exp_types.unorderedimportUnorderedSchemaregister_type("unordered",UnorderedSchema)print(schema.unordered)
Package: district5
District 5Python 3 DB-API and SQLAlchemy dialect to connect toduckdbover http i.e (Radio-Duck)(inspiried by my favourite movieMighty ducks- district5 was the original team name for the mighty ducks )Requirementsinstall mambahttps://mamba.readthedocs.io/en/latest/install dockercd PROJECT_DIR
mamba create -n district5 python=3.9
mamba activate district5
mamba install poetry
poetry installRun Tests#-without integration test
pytest -m "not integration_test" 
#-with integration test
docker run -d -p 8000:8000 -t jaihind213/radio-duck:latest
pytestLet's try it out:#python 3.9^
pip install district5
#start the duckdb server i.e. radio-duck
docker run -p 8000:8000 -t jaihind213/radio-duck:latest
#the duckdb starts up with a sample table whose ddl is: 
#'create table pond(duck_type string, total int)'
echo "we will try to query that"from sqlalchemy import create_engine, text
from sqlalchemy.dialects import registry

registry.register(
    "radio_duck.district5", "radio_duck.sqlalchemy", "RadioDuckDialect"
)


#run docker instance of radio-duck
#docker run -p 8000:8000 -t jaihind213/radio-duck:latest
engine = create_engine(
    "radio_duck+district5://user:pass@localhost:8000/?api=/v1/sql/&scheme=http"
)
# Establish a database connection
conn = engine.connect()

# Define a SQL query using qmark style or positional style
try:
    query_1 = text("""SELECT duck_type, total FROM pond where total > :total""")
    params = {"total": 0}
    result = conn.execute(query_1, params)
    # Fetch and print the results
    for row in result:
        print(row)

    print("--------------")
    query_2 = "SELECT duck_type, total FROM pond where total > ?"
    result = conn.execute(query_2, (0,))

    for row in result:
        print(row)

except Exception as e:
    print(f"An error occurred: {e}")

finally:
    # Close the database connection
    conn.close()
    engine.dispose()
Package: distri-package
The purpose of this package is to help users analyze Binomial and Gaussian distributions.InstallTo pip install type:pip install distri_packFilesBinomialdistribution.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.
Package: distro-names
distro-namesA way to search OS distribution names and versionsAren't you tired of searching things like "Which version is Ubuntu Trusty again", or "is Debian 8stretchorwheezy"? Well, I am... so I wrote this small python script to match OS versions with their names and vice versa.Simply use the CLI to search like this:$distrotrusty
Flavour:Ubuntu
FullName:TrustyThar
Name:trusty
Versions:14.04,14.04.6or use the version:$distrodebian7Flavour:Debian
Name:wheezy
Versions:7InstallUsing Python pip:$pipinstalldistro-namesContributingPlease feel free to contribute to this humble project - you can add distro names and versions todistro/data.pyor improve the search capabilities indistro/distro.py.This is apure Pythonimplementation, so no libs are required. If you'd like to contribute, only PyTest and make are required...
Package: distronode-core
DistronodeDistronode is a radically simple IT automation system. It handles
configuration management, application deployment, cloud provisioning,
ad-hoc task execution, network automation, and multi-node orchestration. Distronode makes complex
changes like zero-downtime rolling updates with load balancers easy. More information on the Distronodewebsite.Design PrinciplesHave an extremely simple setup process with a minimal learning curve.Manage machines quickly and in parallel.Avoid custom-agents and additional open ports, be agentless by
leveraging the existing SSH daemon.Describe infrastructure in a language that is both machine and human
friendly.Focus on security and easy auditability/review/rewriting of content.Manage new remote machines instantly, without bootstrapping any
software.Allow module development in any dynamic language, not just Python.Be usable as non-root.Be the easiest IT automation system to use, ever.Use DistronodeYou can install a released version of Distronode withpipor a package manager. See ourinstallation guidefor details on installing Distronode
on a variety of platforms.Power users and developers can run thedevelbranch, which has the latest
features and fixes, directly. Although it is reasonably stable, you are more likely to encounter
breaking changes when running thedevelbranch. We recommend getting involved
in the Distronode community if you want to run thedevelbranch.Get InvolvedReadCommunity Informationfor all
kinds of ways to contribute to and interact with the project,
including mailing list information and how to submit bug reports and
code to Distronode.Join aWorking Group,
an organized community devoted to a specific technology domain or platform.Submit a proposed code update through a pull request to thedevelbranch.Talk to us before making larger changes
to avoid duplicate efforts. This not only helps everyone
know what is going on, but it also helps save time and effort if we decide
some changes are needed.For a list of email lists, IRC channels and Working Groups, see theCommunication pageCoding GuidelinesWe document our Coding Guidelines in theDeveloper Guide. We particularly suggest you review:Contributing your module to DistronodeConventions, tips, and pitfallsBranch InfoThedevelbranch corresponds to the release actively under development.Thestable-2.Xbranches correspond to stable releases.Create a branch based ondeveland set up adev environmentif you want to open a PR.See theDistronode release and maintenancepage for information about active branches.RoadmapBased on team and community feedback, an initial roadmap will be published for a major or minor version (ex: 2.7, 2.8).
TheDistronode Roadmap pagedetails what is planned and how to influence the roadmap.AuthorsDistronode was created byKhulnaSoft Ltdand has contributions from over 5000 users (and growing). Thanks everyone!Distronodeis sponsored byRed Hat, Inc.LicenseGNU General Public License v3.0 or laterSeeCOPYINGto see the full text.
Package: distroscraper
distroscraperScrapes Linux distribution web pages for new torrent files and adds
them to Transmission.  I want to give back to the Free Software
community and one way I can do that is by seeding their torrents.For legitimate redistrbution of permitted content only.Included are scrapers for these distributions:Arch LinuxDebianFedoraLinux MintRaspberry PiWould love to include, if they would provide alegitimatetorrent:OPNsenseIf your favorite distribution is not mentioned, you can open an
issue, or contribute a pull request.  Take a look at the other
files in /distroscraper/scrape and make it look like those in general.InstallationCreate and configure a Python Virtual Environment for distroscraper:python-mvenv/home/myser/.venv_distroscraper
./home/myuser/.venv_distroscraper/bin/activate
pipinstalldistroscraperCreate a shell script (I call mine "scrape-and-add.sh") to run
the scrapers and pipe output through the transmission torrent adder.
For the below script you will also need the 'jq' command line JSON
processing tool.#!/bin/bashVENV_PATH=/path/to/venvDISTROS="distroscraper.scrape.archlinuxdistroscraper.scrape.centosdistroscraper.scrape.debiandistroscraper.scrape.fedoradistroscraper.scrape.linuxmintdistroscraper.scrape.raspberrypi"TM_ARGS="--host localhost--port 9091--user myuser--password supersecret--download-dir /path/to/linuxdownloads"fordin$DISTROS;do$VENV_PATH/bin/python-m$d|\jq.href|\xargs$VENV_PATH/bin/python-mdistroscraper.tm_add_torrent$TM_ARGSdoneCreate a systemd timer or cron job to run scrape-and-add.sh periodically.
Transmission is smart enough not to add the same torrent multiple times.Here is an example systemd service file for use with a timer.  The file
name is intended to be /etc/systemd/system/distroscraper.service.[Unit]Description=scrape linux distributions[Service]User=serviceGroup=serviceType=oneshotNice=19ExecStart=/home/service/scrape-and-add.shAnd here is the corresponding timer file.  Note the randomized delay
ensures that these happen "more or less" daily, but that everyone
isn't hitting the download pages simultaneously at midnight.
Call this file /etc/systemd/system/distroscraper.timer.[Unit]Description=scrape distributions daily[Timer]OnCalendar=00:00RandomizedDelaySec=86400Persistent=trueUnit=distroscraper.service[Install]WantedBy=timers.targetReportingIf you want to ingest transmissions stats into some logging solution
like ELK or Graylog, you can use this which will produce some JSON
that can be massaged into these systems:python-mdistroscraper.tm_get_statsFor Graylog, you may be interested in my
[GELF JSON Flattener|https://jefftickle.com/projects/gelf-flattener]
Package: distroverify
distroverifyUtility to verify any linux distro file (*.iso) for its integrity.Installationpip install distroverifyUsage> distroverify ubuntu-mate-16.04.5-desktop-amd64.iso
Distro Verify version 1.0.1
Utility to verify any linux distro file (*.iso) for its integrity

match success:  ubuntu-mate
verification url: http://cdimage.ubuntu.com/ubuntu-mate/releases/16.04.5/release/SHA1SUMS
calculating hash...
done
response hash: 2ace65436195d122b8ce0cfc106728c2922dd350
calculated hash: 2ace65436195d122b8ce0cfc106728c2922dd350
match:  TrueDocumentationDetailed docs are available athttps://distroverify.readthedocs.io/en/latest/.NotesSupported distros:Ubuntu - All family (exceptubuntu-serverbecause they no longer provide checksums for older versions)Debian (Live & DVD)Linux MintOpenSUSE LEAPFedora (Live & netinst)You shouldn't change the name of the iso file (for example,ubuntu-mate-19.04-desktop-amd64.iso) because this tool uses regular expressions to match them and then look up its hash on the corresponding distro's URL.
Package: distrowatchapi
# DistrowatchAPI
Very simple unofficial distrowatch apiIt allows to take a top of distributions from <a href=”https:\distrowatch.com”>distrowatch.com<a>:from api.distrowatch import Distrowatch
from api.periods import PeriodType
import asyncioasync def main():distrowatch = Distrowatch()
print(await distrowatch.get_top_of_distributions(10, PeriodType.LAST_MONTH))if __name__ == “__main__”:asyncio.run(main())
Package: distru
Distru packageThis is a simple project that is used to grasp how to publish
Python packages on PyPI. This package is used to generate or read data
from a specific distribution and make some functionality or visualize it.Installingpip install distruProject descriptionThis package works so far with two distributions, normal and binomial distribution.Package by default will generate random data from parameters you pass it or default parameters.Can read data from a file and the package will calculate its attributes automatically.Add two distributions of the same type together.Calculate some functions like PDF or PMF.Visualize distributions.
Package: distruct
diSTructpython package name: distruct
Implementation of Maxent-stress Optimization of Biomolecular systems.diSTructis in essence an implementation of the MaxEnt-Stress graph drawing algorithm (Gansner, E.; Hu, Y. and North, S. C.: "A Maxent-Stress Model for Graph Layout" inIEE Trans. Vis. Comput. Graph.2013) for generating biomolecular structures from distance constraints.RequirementsThe actual structure generation in diSTruct is build on the MaxEnt-stress graph drawing implementation inNetworKit.It aims to conveniently combine this with the PDB module inBiopython.It also depends onlxmland requirescython.Installation InstructionsFirst install NetworKit following the instructions in theirhomepage.
Make sure you can
import networkit
without error. Sometimes there are issues with automatically installing all dependenicies.
Simply install missing packages manually.Install cython, Biopython and lxml.
InstalldiSTructwithpip install distructPublicationsPlease cite@article{10.1093/bioinformatics/btz578,
    author = {Taubert, Oskar and Reinartz, Ines and Meyerhenke, Henning and Schug, Alexander},
    title = "{diSTruct v1.0: generating biomolecular structures from distance constraints}",
    journal = {Bioinformatics},
    year = {2019},
    month = {07},
    abstract = "{The distance geometry problem is often encountered in molecular biology and the life sciences at large, as a host of experimental methods produce ambiguous and noisy distance data. In this note, we present diSTruct; an adaptation of the generic MaxEnt-Stress graph drawing algorithm to the domain of biological macromolecules. diSTruct is fast, provides reliable structural models even from incomplete or noisy distance data and integrates access to graph analysis tools.diSTruct is written in C++, Cython and Python 3. It is available from https://github.com/KIT-MBS/distruct.git or in the Python package index under the MIT license.Supplementary data are available at Bioinformatics online.}",
    issn = {1367-4803},
    doi = {10.1093/bioinformatics/btz578},
    url = {https://doi.org/10.1093/bioinformatics/btz578},
    note = {btz578},
    eprint = {http://oup.prod.sis.lan/bioinformatics/advance-article-pdf/doi/10.1093/bioinformatics/btz578/29161648/btz578.pdf},
}TestsTo run the python tests install pytest an run python -m pytest in /path/to/distruct/tests
Package: distrunner
Distributed RunnerThis library allows for the easy construction and management of ephemeral Dask clusters on AWS via a simple context manager. This allows you to perform distributed and parallelized computations with ease.Installationpip install distrunnerUsageIn your scheduler (Airfow etc.) use something like this:from distrunner import DistRunner
import whatismyip

def main():
    with DistRunner(workers=10) as cldr:
        results = cldr.client.map(print_ip, range(10))
        outcome = cldr.client.gather(results)

        print(outcome)

def print_ip(x):
    return f"My IP address is {whatismyip.whatismyip()}"The "local" flag will determine whether a remote cluster is created. For example, the following will all run locally instead of spinning up infrastructure:from distrunner import DistRunner
import whatismyip

def main():
    with DistRunner(workers=10, local=True) as cldr:
        results = cldr.client.map(print_ip, range(10))
        outcome = cldr.client.gather(results)

        print(outcome)

def print_ip(x):
    return f"My IP address is {whatismyip.whatismyip()}"You will need to set the AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables to use the Fargate clusters (or run from an environment with an authorised IAM role).Running in Managed Workflows for Apache Airflow (MWAA)Running inside an AWS MWAA environment requires alittlemore setup than running locally. This is because of the way that requirements are handled in Airflow. You also need to ensure that any called functions are nested underneath the task in question. The above examples, refactored for Airflow, could read:REQUIREMENTS = [
    "distrunner>=1.3.0",
    "whatismyip,
    "coiled",
    "dask[complete]",
]

@dag(
    default_args=DEFAULT_ARGS,
    schedule_interval="@daily",
    catchup=False,
    dagrun_timeout=timedelta(hours=16),
    start_date=datetime(2023, 4, 16),
    tags=["api"],
)
def main_task():
    @task.virtualenv(
        task_id="main_task",
        requirements=REQUIREMENTS,
        system_site_packages=True,
    )
    def entry_point(requirements):
        
        def print_ip(x):
            return f"My IP address is {whatismyip.whatismyip()}"

        from distrunner.distrunner import DistRunner

        with DistRunner(
            workers=1,
            requirements=requirements,
            application_name="test_application",
        ) as cldr:
            results = cldr.client.map(snapshot_routes_body, range(1))
            cldr.client.gather(results)

    entry_point(REQUIREMENTS)

main_task()FeaturesContext manager handling of Dask Fargate clusters with scale-to-zero on completeEasy ability to switch between local and distributed/remote developmentWhat it DoesThis library allows you to easily run functions across a Dask cluster.CreditsAWS/BotoCoiledDaskGitGitPythonCopyright © Crossref 2023
Package: distsim
distsimSimulator of distributed system based on Pythonmultiprocessing.Processandmultiprocessing.Pipecommunication.Installation$pipinstalldistsimExamplesSeeexamples/folder.simple_network/- basic network with two interconnected nodes. One message per node is sent and received.nodes_with_arguments/- two nodes, no links, each accepts one argument.receive_any/- demonstration ofNode.receive_any()method.threads/- demonstration of spawning threads insideNodeinstance.