Saravanan666/pypi-org huggingface dataset:
Package: pydrobert-param
pydrobert-paramUtilities for the python packageparam.Whileparamis a great tool for keeping track of parameters, currently
serialization is restricted to pickling and unpickling objects.pydrobert-paramtakes the stance that parameter (de)serialization has an
intuitive and obvious representation in most cases. The developer can modify
howpydrobert-param(de)serializesparam.Parameterizedinstances according
to her needs.A teaser:importparamimportpydrobert.param.serializationasserialclassFoo(param.Parameterized):my_int=param.Integer(10)first,second=Foo(),Foo()first.my_int=30serial.serialize_to_json('foo.json',first)serial.deserialize_from_json('foo.json',second)assertfirst.my_int==second.my_intWhile the primary purpose ofpydrobert-paramis for parameter
(de)serialization, there is also code inpydrobert.param.optunafor
hyperparameter optimization viaOptuna. Check the
documentation for more complicated examples of serialization, as well as for
hyperparameter optimization.This is student-driven code, so don't expect a stable API. I'll try to use
semantic versioning, but the best way to keep functionality stable is by
pinning the version in the requirements or by forking.DocumentationLatestv0.4.0v0.3.1Installationpydrobert-paramis available via both PyPI and Conda.condainstall-csdrobertpydrobert-param
pipinstallpydrobert-param
pipinstallgit+https://github.com/sdrobert/pydrobert-param# bleeding edgeThere are also optional dependencies on PyPI:pipinstall'pydrobert-param[yaml]'# installs ruamel.yaml YAML backendpipinstall'pydrobert-param[optuna]'# installs optunapipinstall'pydrobert-param[types]'# installs numpy and pandas# (to handle all types)pipinstall'pydrobert-param[all]'# all of the aboveLicensing and How to CitePlease see thepydrobert pagefor more
details.
Package: pydrobert-pytorch
pydrobert-pytorchPyTorch utilities for Machine Learning. This is an eclectic mix of utilities
that I've used in my various projects. There is a definite leaning towards
speech, specifically end-to-end ASR. The primary benefitpydrobert-pytorchhas over other packages is modularity: you can pick and choose the
functionality you desire without subscribing to an entire ecosystem. You can
find out more about what the package offers in the documentation links below.This is student-driven code, so don't expect a stable API. I'll try to use
semantic versioning, but the best way to keep functionality stable is by
pinning the version in the requirements or by forking.DocumentationLatestStableInstallationpydrobert-pytorchis available through both Conda and PyPI.condainstall-csdrobertpydrobert-pytorch
pipinstallpydrobert-pytorchLicensing and How to CitePlease see thepydrobert pagefor more
details.Implementations ofpydrobert.torch.util.polyharmonic_splineandpydrobert.torch.util.sparse_image_warpare based off Tensorflow's codebase,
which is Apache 2.0 licensed.
Package: pydrobert-speech
pydrobert-speechThis pure-python library allows for flexible computation of speech features.For example, given feature configuration calledfbanks.json:{"name":"stft","bank":"fbank","frame_length_ms":25,"include_energy":true,"pad_to_nearest_power_of_two":true,"window_function":"hanning","use_power":true}You can compute triangular, overlapping filters likeKaldiorHTKwith the
commandsimportjsonfrompydrobert.speechimport*# get the feature computer readyparams=json.load(open('fbank.json'))computer=util.alias_factory_subclass_from_arg(compute.FrameComputer,params)# assume "signal" is a numpy float arrayfeats=computer.compute_full(signal)If you plan on using aPyTorchDataLoaderor Kaldi
tables in your ASR pipeline, you can compute all a corpus' features by
using the commandssignals-to-torch-feat-dir(requirespytorchpackage)
orcompute-feats-from-kaldi-tables(requirespydrobert-kaldipackage).This package can compute much more than f-banks, with many different
permutations. Consult the documentation for a more in-depth discussion of how
to use it.DocumentationLatestInstallationpydrobert-speechis available via both PyPI and Conda.condainstall-csdrobertpydrobert-speech
pipinstallpydrobert-speech
pipinstallgit+https://github.com/sdrobert/pydrobert-speech# bleeding edgeLicensing and How to CitePlease see thepydrobert pagefor more
details on how to cite this package.util.read_signalcan read NIST SPHERE files. To do so, code was adapted fromNIST sph2pipe
programand put intopydrobert.speech._sphere. License information can be found inLICENSE_sph2pipe. Please note that the license only permits the use of their
code to decode the "shorten" file type, not encode it.
Package: pydrogen
Python library for building embedded languages within Python that have alternative operational semantics or abstract interpretations.PurposeThis library allows programmers to free the building blocks that constitute Python syntax from the default Python semantics. It is designed to allow programmers to define quickly and to use immediately one or more alternative abstract interpretation or operational semantics for Python.Web:           pydrogen.org
Version:       0.0.2.0
Compatibility: Python 3
Dependencies:  ast, inspectPackage Installation and UsageThe package is available on PyPI:pip install pydrogenThe library can be imported in the usual way:import pydrogenSome usage examples can be found athttp://pydrogen.org.
Package: pydroid
pydroid - Make Android Device Automation Easy for Python DevelopersAndroid Testing Automation Framework. This pip package helps to automate the control of android devices using python. we can build android automation framework around it.Assumptions:Assuming python is installed on your system.adb is installed on your systemadb path is set in system environmentadbis installed on your system.Installtestdroidon your system using :pip install pydroidUsing pydroidread a the sample test script to familiarize with using pydroidpython3 sample_test_script.py
Package: pyDroidDepot
PyDroidDepotPyDroidDepot is an open-source project that aims to provide Python access to the Starwars Galaxy's Edge droid depot droids. It allows users to manually control their custom built droids using custom applications.InstallationPyDroidDepot can be installed usingpip, or by downloading the source code and running thesetup.pyscript.Installing with pipTo install PyDroidDepot usingpip, simply run:pip install pydroiddepotInstalling from sourceTo install PyDroidDepot from source, follow these steps:Download the source code from theGitHub repository.Extract the contents of the archive to a directory of your choice.Navigate to the directory containing thesetup.pyscript.Run the following command:python setup.py installExamplesPyDroidDepot comes with a few examples to help users get started. These examples can be found under theexamplesdirectory in the repository root.LicensePyDroidDepot is released under the MIT license. See the LICENSE file for more details.
Package: pydrology
PydrologyA Python package for accessing and processing hydrologic data.InstallationTo install pydrology, run the following within a virtual environment of choice.c:\> pip install pydrologyIf you want to work on developing Pydrology, you can clone the repository directly from GitHub.
You can also download the example Jupyter Notebooks directly.c:\> git clone https://github.com/alex-l-young/pydrology.gitCurrently supported data sourcesUSGS Streamflow ConditionsStream gage measurementsDischarge values from rating curvesNOAA SC-ACIS Daily MeteorologyMaximum TemperatureMinimum TemperatureAverage TemperaturePrecipitationSnow DepthNEXRAD Level-II Doppler Radar ReflectivityCurrently only base reflectivity.Map of stations and coverage availablehereAlways Something To-DoBuild out a module for basic statistics and plotting that can be done on the hydrology data.Extract dual-band radar data. And maybe NEXRAD Level-III?
Package: pydroneapi
pydroneapiA DRONE CI Server - Python helper scripts to manage API interactions and operations.This tool manages authentication against Drone CI and performs common Drone CI API operations using a Python wrapper.PrerequisitesDocker 18.09+MakeInstallationFrom PyPI:pip install pydroneapiFrom source:git clone --recursive https://github.com/bellyjay1005/pydroneapi
cd pydroneci
python setup.py installFrom Github directly:pip3 install pydroneapi@git+https://github.com/bellyjay1005/pydroneciUsageExample:frompydroneapiimportPyDroneAPI# Sync application github repository with Drone pipelinedrone=PyDroneAPI(drone_host='https://example.com',token='abcd1234',repo='bellyjay1005/test-repo',)sync_res=drone.synchronize_repository()ifnotsync_res[0]['id']:print('New Repository Not Synchronized. Error Message -%s',sync_res)returnFalseDevelopment & TestReferencemake helpfor more commands used for development and testing of source codes.
Package: py-droplets
py-dropletspy-dropletsprovides python code for representing physical droplets using
key parameters like position, size, or shape.
These droplets can also be represented as collections (emulsions) and over time.
Moreover, the package provides methods for locating droplets in microscope
images or phase field data from simulations.Installationpy-dropletsis available onpypi, so you should be able to install it
throughpip:pipinstallpy-dropletsAs an alternative, you can installpy-dropletsthroughcondausing theconda-forgechannel:condainstall-cconda-forgepy-dropletsUsageMore informationTutorial notebook in thetutorials folderExamples in theexamples folderFull documentation on readthedocsor asa single PDF file.
Package: pydroplist
pydroplistA python module to grab data from droplists online and list products on the next drop, given the brand being searched for.InstallationInstall viapip install pydroplist.UsageFirst import to your project withimport pydroplist.
To use, call the functionlatest('brand')– this returns a list of the products dropping. Input the brand you are looking for.
Currently only supports'supreme'as an argument – will be adding more later.
Package: pyDRTtools
pyDRTtoolsWe are pleased to introduce the pyDRTtools, is the python version of DRTtools for computing distribution relaxation times (DRT) from electrochemical impedance spectroscopy (EIS) data.What is the pyDRTtools? Why would I want it?pyDRTtools is a Python GUI that analyzes EIS data via the DRT model. pyDRTtools includes:an intuitive GUI for computing DRT based on Tikhonov regularizationseveral options for optimizing the estimation of the DRTa sampler that allows you to determine the credible intervals of your DRTan optimal selection of the regularization parameterHilbert-transform subroutines that allow you to assess and score the quality of your dataHopefully, by now you are inclined to think that this toolbox may be useful to the interpretation of your EIS data. If you are interested, you will find an explanation of the toolbox's capabilities it in the user's guide as well as in the references below.Distribution and Release InformationpyDRTtools is freely available under the MIT license from this site.System requirementsTo install and run pyDRTtools, you need: Python >= 3Installation detailsFor details about the installation procedures, you can consult the user manualmanualRun the following on anaconda prompt:conda create --name DRT pip ipython pandas matplotlib scikit-learn spyder
conda activate DRT
pip install cvxopt jupyterlab PyQt5
pip install -i https://test.pypi.org/simple/ pyDRTtools==0.2.8.82ipython!launchGUIDetailed installation instructions are available in the DRT toolbox user's guide (also included with the standard distribution).How to cite this work?Refer to the GitHub repository (https://github.com/ciuccislab/pyDRTtools) so that you can cite each function appropriately.How to get support?Just write tofrancesco.ciucci@ust.hkorfrancesco.ciucci@uni-bayreuth.de
Package: pydrugshortagesca
pydrugshortagescaA minimal python wrapper around thedrugshortagescanada.cadatabase APIDepends onrequestsmodule and will pass through exceptions from that library when they occur.InstallationInstall the package:pip install pydrugshortagescaYou can then configure yourdrugshortagescanada.causername and password in one of the following ways:Create configuration file in~/.config/pydrugshortagesca/config:email="username@domain.com"password="s3cr3t!"Or, set the following environment variables:exportDSC_EMAIL="username@domain.com"exportDSC_PASSWORD="s3cr3t!"You can test your installation by running the commandpydrugshortagesca. You
should not be prompted for a username or password, and it should return some
results in JSON format.Basic UsageInteracting with thedrugshortagescanada.cadatabase is done via theapi.Sessionobject:frompydrugshortagescaimportapi,exportimportjsonsession=api.Session(email="name@domain.com",password="123456")try:session.login()exceptExceptionase:print("Error with log in",e)print("Details:",session.response.content)else:# search() returns a batch of results.# Use the `limit` and `offset` parameters to adjust which batch to return.json_results=session.search(term="venlafaxine",offset=20)print("Total results{}".format(json_results['total']))# isearch() returns an iterator over all records returned by a search.# This may make several requests to the database if needed.results=session.isearch(term="venlafaxine",orderby='updated_date')forrecinresults:print(rec['updated_date'],rec['en_drug_brand_name'],rec['drug_strength'])# Custom filter functions can also be suppliedresults=session.isearch(_filter=lambdax:x['drug_strength']=='150.0MG',term="venlafaxine",orderby='updated_date'):forrecinresults:print(rec['updated_date'],rec['en_drug_brand_name'],rec['drug_strength'])# The export module provides utility functions for exporting results in tabular formcsvfile=open('shortages.csv','w')export.as_csv(session,csvfile,shortages=True,term="venlafaxine")CLIThere is also a commandline interface. Seepydrugshortagesca --helpfor details, but briefly:$pydrugshortagesca-ptermvenlafaxine--typeshortages--fmtcsv>shortages.csvLicenseMITContributingPull requests are very welcome!
Package: pydrumscore
What is it?PyDrumScore is a Python library for generating drum sheet music through code. It aims to provide a lean interface, relying on core Python features and data types. This allows the user to programatically bypass the relative complexity of modern scoring softwares, whose features often go beyond the scope of what is needed to create drum sheet music.How does it work?Two things are needed for the score generator:The scoremetadata, such as its title, its author, or the year it was created.A list ofmeasuresthat represent the music being played.The user's sole responsability is to fill these objects inside a python file. See here a complete example for a classic drum beat.""" basic_beat.py """# Import pydrumscoreimportpydrumscoreaspds# Enter relevant metadatametadata=pds.Metadata(workTitle="BasicBeat")# Measures of the song; fill this!measures=[]# Add a measuremeasures+=pds.Measure(bd=[1,3],# Bass drum on 1 and 3sd=[2,4],# Snare on 2 and 4hh=pds.note_range(1,pds.end(),1/2)# Hi-hat from 1 to measure end,# each lasting half a beat)Afterwards, simply call the exporter with:pydrumscore basic_beatThe song module will be imported, and the contents of themetadataandmeasuresobjects will be converted to an uncompressed MuseScore file under the titleBasicBeat.mscx. That's it! You can now open this file in MuseScore, from which you can review the results and export to a PDF file. Support for the MusicXML format is planned.InstallationUsing pip (recommended)PyDrumScore is distributed as a pure Python package, in the form of a wheel distribution hosted onPyPI.
It can thus be downloaded withpip, by simply executing in your Python environment:pip install pydrumscoreThis will install PyDrumScore and all its dependencies in your active Python environment.
Note that it is good practice to use virtual environments when installing packages; seethis guidefor a good primer on the concept.Manual installIt is possible to download the package content by hand through theproject page. The .whl distribution, which is a zip file, can then be uncompressed and added to the environment. Note, however, that this does not handle the package dependencies likepipwould; you will need to install them individually in your environment as well.MuseScore pluginThe PyDrumScore package also contains a plugin for MuseScore to refresh modified files with a single button. This allows for a proper workflow for using MuseScore as a viewer to PyDrumScore. To set it up, seethe tutorialon MuseScore's page. Make sure the plugin is added to your MuseScore plugins folder, and that it is enabled and has a shortcut.Tutorials and examplesSee the test folder for examples of fully transcribed songs. Stay tuned for upcoming video tutorials as well.
Package: pydrying
Welcome topydryingmodule!pydringis a Python package intended to simulate the drying process. The simulation programs in this module are based on multiphysical and dynamic modeling of the drying phenomena (heat, mass & momentum transfer, and deformation of the drying product). The resolution of drying equations is based on the numerical method of finite volumes. This module calculates the drying kinetics of any solid product. The modeling of drying kinetics is essential in most transformation processes, such as the food industry (sugar industry, biomass refinery, fodder processing, etc.)InstallationWaterOptim runs under Python 3.6+. To install it withpip, run the following:pip install pydryingTo upgrade it withpip, run the following:pip install --upgrade pydryingBasic usageThermophysical properties of drying materialfrom numpy import ones,exp
from pydrying.dry import thin_layer, material
# diffusion coeff in the material
def Diff(T,X):
"""
Parameters
----------
T : Temperature [°C]
X : TYPE
    moisture content [dry basis]
Returns
-------
Diffusion coefficient [m2/s]
"""
    return 1e-9*ones(len(T))
# sorption isotherms
def aw(T,X):
"""
Parameters
----------
T : Temperature [°C]
X : TYPE
    moisture content [dry basis]
Returns
-------
water activity of the drying material [decimal]
"""
    return (1.0-exp(-0.6876*(T+45.5555)*X*X))
# thermal conductivity of the drying material
def Lambda(T,X):
"""
Parameters
----------
T : Temperature [°C]
X : TYPE
    moisture content [dry basis]
Returns
-------
thermal conductivity [W/m/K]
"""
    return .02Geometric propertiesmaterial_shape = 0 # flat material, (1: cylinder, 2: sphere)
caracteristic_length = 1e-2 # mDrying conditionsdrying_time = 3600 # s
heat_transfer_coefficient = 25 # W/m2/KDrying air properties (pressure, temperature and relative humidity) can be set from python calssair.Definition of drying materialdrying_material = material(Diff=Diff,aw=aw,Lambda=Lambda,
                           m=material_shape,
                           L=caracteristic_length,)Solve the problem of thin layer dryingproblem = thin_layer(material=drying_material,air={},
h=heat_transfer_coefficient,
tmax=drying_time)
problem.solve()Water content plotimport matplotlib.pyplot as plt
	plt.plot(tl.res.t, tl.res.Xmoy())
	plt.xlabel("drying time in s")
	plt.ylabel("moisture content in dry basis")Plot of material surface temperatureplt.plot(tl.res.t, tl.res.T[-1,:])
	plt.xlabel("drying time in s")
	plt.ylabel("material temperature in °C")
Package: py-dsa
py-dsaIntroductionThe py-dsa module contains all the data structures and algorithms implementations.InstallationYou can install the module using pip as shown below.pipinstallpy-dsaUsageConsider the following examples :frompy_dsa.data_structuresimport*test_linkedlist=LinkedList()test_linkedlist.add_first(10)test_linkedlist.add_first(20)test_linkedlist.add_first(30)test_linkedlist.remove_last()test_linkedlist.reverse_list()test_linkedlist.print_list()"""Output :2030"""frompy_dsa.data_structuresimport*test_tree=Tree()test_tree.add(10)test_tree.add(5)test_tree.add(30)print(test_tree.height())test_tree.invert_tree()test_tree.print_tree(traversal='postorder')"""Output:230510"""frompy_dsa.algorithmsimport*a=[1,2,3,4.5]s=Searching()print(s.linear_search(a,3))"""Output :2"""TestingTo install py-dsa, along with the tools you need to develop and run tests. Run the following command :$pipinstall-e.[dev]For running the tests, type the following command :py.testBugs/RequestsPlease use theGitHub issue trackerto submit bugs or request features.LicenseCopyright Vaidhyanathan S M, 2021Distributed under the terms of theMITlicense, py-dsa is free and open source software.
Package: pyDSA-core
PyDSA_core: python3 package for drop shape analysis.FeaturesPyDSA_core allow to import videos and images of droplets and to get their properties, includingDrop edges positionsContact anglesContact angle hysteresisRadiusVolumeTriple point positions (for SLIPS surfaces)...A Graphical interface is also availablehere.A tutorial is availablehere.DependenciespyDSA_core relies on matplotlib, numpy, scipy, IMTreatment and OpenCV.Installationpip install pydsa_coreTo update pyDSA_core, use:pip install -U pydsa_coreCiting this softwareIf PyDSA_core have been usefull for you, please consider citing it:Launay G. PyDSA: Drop shape analysis in Python, 2018-, https://framagit.org/gabylaunay/pyDSA_core [Online; accessed <today>].bibtex entry:@Misc{launay_pydsa_2018,author={Gaby Launay},title={{PyDSA}: Drop shape analysis in {Python}},year={2018--},url="https://framagit.org/gabylaunay/pyDSA_core",note={[Online; accessed <today>]}}
Package: pyDSA-gui
Drop shape analysis software.PyDSA is a software for drop shape analysis.
It allows to measure the properties of droplets in contact with solids (contact angle, droplet volume, evaporation rate, displacement velocity, ...) through an intuitive interface.
PyDSA is developed in Python and use Qt5 for it graphical interface.Installationpip install pyDSA_guiTo update PyDSA, use:pip install -U pyDSA_guiUsageJust start PyDSA from the terminal (or anaconda console) with:pyDSAScreenshotsImage scaling and pre-processing:Droplet edge detection:Droplet edge fitting:Droplets properties evolution after full analysis:DocumentationPyDSA is designed to be simple and straightforward to use.
If you don't understand the effect of an option,
please refers to the inline documentation ofpyDSA_core,
where all the features are documented in details.Citing this softwareIf PyDSA have been usefull for you, please consider citing it:Launay G. PyDSA: Drop shape analysis in Python, 2018-, https://framagit.org/gabylaunay/pyDSA_core [Online; accessed <today>].bibtex entry:@Misc{launay_pydsa_2018,author={Gaby Launay},title={{PyDSA}: Drop shape analysis in {Python}},year={2018--},url="https://framagit.org/gabylaunay/pyDSA_core",note={[Online; accessed <today>]}}Issues and bugsPyDSA is hosted onFramagit.
If PyDSA crashes or behaves abnormally, you can reporthereor just send me an email atgaby.launay@protonmail.com.
Any of the followings will greatly help me fix the issue:A description of the problemThe logs from the terminalA test case to reproduce the problem
Package: pydsb
pydsb 2.3.0pydsb provides a Python API for DSBmobile.Heinekingmedia (the creators of DSBmobile) shut down the API pydsb was previously using so I had to use the app-API. That required a complete rewrite so some features are currently not implemented yet. See below for the current featureset.
I strongly recommend that users of version 1.0 upgrade to 2.0, because it doesn't work anymore. Some syntax has changed too, so be aware of that.FeaturesGetting plansGetting news (maybe not always working due to limited sample data)Getting postings (Aushänge)Installationpip install pydsbUsagefrom pydsb import PyDSB

dsb = PyDSB("username", "password")

print(dsb.get_plans())
print(dsb.get_postings())
print(dsb.get_news())
Package: pyds-cli
PyDS CLIHelping you manage your data science projectssanely.RequirementsAnaconda/Miniconda/Miniforge/Mambaforge(Mambaforge recommended!)giton your PATHQuickstartWe're in development! Install directly fromgitinto your base Anaconda environment.pipinstallgit+https://github.com/ericmjl/pyds-cliContributors ✨Thanks goes to these wonderful people (emoji key):Eric Ma💻🚇⚠️✅Logan Thomas🤔andrew giessel🤔Amanda🤔This project follows theall-contributorsspecification. Contributions of any kind welcome!