Saravanan666/pypi-org huggingface dataset:
Package: pydpd
pydpdA DPD API wrapper (UK only)Create DPD shipments and generate parcel labels from within your application or webapp.You will need a valid DPD account and have API access enabled (which can be done by calling 0121 275 7336)FeaturesCheck available services for a shipmentCreate a shipmentGenerate labels in HTML, PDF, PNG or the raw printer dataWhat's not possibleCollectionsSwapsExtended LiabilityInternation ShipmentsInstallationDownload and install can be done through PyPipip install pydpdorgitclonehttps://github.com/lewis-morris/pydpdcdpydpdpipinstall-e.IMPORTANT NOTEIf you want to generate PDF or PNG versions of your labels you will have to install some additional softwareLinux / Ubuntusudo apt-get install wkhtmltopdfsudo apt-get install wkhtmltoimageWindowsWindows installer downloadWhen installing wkhtmltopdf and wkhtmltoimage on windows you need to set an environment variable to point to the wkhtmltopdf or wkhtmltoimage executable.
You should be able to find extensive documentation to this online, but I won't provide a link to this to avoid dead links etc.Pending FeaturesParcel TrackingHow to useMinimal working examplefrompydpdimportDPD,Parcel,Address#create sender objectsender=Address(**{"name":"Mr Ship","organisation":"SuperShipCo","address1":"Ship Street","address2":"Shipton","postcode":"BR5 3DX"})#create dpd objectdpd=DPD("[your dpd username]","[your dpd password]","[your dpd acc no]",sender)#create a parcel definitionmy_parcel=Parcel(**{"weight":10,"pcs":2,"name":"Boris","address1":"10 Downing Street","address2":"London","postcode":"SW1A 2AB"})#book the delivery with "1^12" service - (Next day)  returns a delivery objectmy_delivery=dpd.create_delivery(my_parcel,"1^12")#get dpd PIL image labelmy_delivery.get_png_labels(2)[0]Full ExampleI always find it best to learn by example so follow this jupyter notebook to see the flow.Jupyter notebook examplesAll classes have doc strings, so you can always check there if you get stuck.ContactIf you have any issues or just want to chat you can always email me atlewis.morris@gmail.comor open an issue.
Package: pydplace
pydplaceA Python library to curateD-PLACEdata.To installpydplacerunpip install pydplaceUsageBootstrapping apydplace-curated datasetpydplaceprovides acldfbenchdataset template to create the skeleton of files and directories for a
D-PLACE dataset, to be run withcldfbench new.Runningcldfbenchnew--templatedplace_datasetwill create a dataset skeleton looking as follows$treetesttree/Implementing CLDF creationImplementing CLDF creation means - as for any othercldfbench-curated dataset - filling in thecmd_makecldfmethod of theDatasetsubclass incldfbench_<id>.py.Running CLDF creationWithcmd_makecldfimplemented, CLDF creation can be triggered runningcldfbenchmakecldfcldfbench_<id>.pyThe resulting CLDF dataset can be validated runningpytestRelease workflowcldfbenchmakecldf--glottolog-versionv4.8--with-cldfreadmecldfbench_<id>.py
pytest
cldfbenchzenodo--communitiesdplacecldfbench_<id>.py
cldfbenchcldfviz.mapcldf--pacific-centered--formatpng--width20--outputmap.png--with-ocean--no-legend
cldfbenchreadmecldfbench_<id>.py
dplacecheckcldfbench_<id>.py
gitcommit-a-m"release vX.Y"gitpushoriginThen create a release on GitHub, thereby pushing the repos to Zenodo.Using the datasets$csvgrep-cVar_ID-mAnnualMeanTemperaturecldf/data.csv|csvstat-cValue4."Value"Typeofdata:NumberContainsnullvalues:FalseUniquevalues:1649Smallestvalue:-19,45Largestvalue:29,153Sum:32.700,717Mean:16,449Median:19,721StDev:9,684Mostcommonvalues:14,392(9x)21,66(6x)6,96(6x)23,335(5x)21,619(5x)Rowcount:1988
Package: pydpmtest
PydpmA python package focuses on constructing deep probabilistic models on GPU.
Pydpm provides efficient distribution sampling functions and has included lots of probabilistic models.InstallTemporarily support Linux system only and the Windows version will be launched soon.pip install pydpmRequirementspycuda
scipy
numpyCreate Probabilistic ModelModel listModel list is as following:Whole nameModelPaperLatent Dirichlet AllocationLDALinkPoisson Factor AnalysisPFALinkPoisson Gamma Belief NetworkPGBNLinkConvolutional Poisson Factor AnalysisCPFALinkConvolutional Poisson Gamma Belief NetworkCPGBNLinkPoisson Gamma Dynamical SystemsPGDSLinkDeep Poisson Gamma Dynamical SystemsDPGDSLinkMore probabilistic models will be included further...DemoCreate a PGBN model:from pydpm.model import PGBN
test_model = PGBN([128, 64, 32], device='gpu')
test_model.initial(train_data)
test_model.train(100)More complete demos can be found in pydpm/examples/...Layer constructionConstruct your own probabilistic model as you wish.from pydpm.layer import data_base,prob_layer,model
data = data_base('./mnist_gray')
layer1 = prob_layer(128)
layer2 = prob_layer(64)
layer3 = prob_layer(32)
pgbn = model([data, layer1, layer2, layer3],'gpu')
pgbn.train(iter=100)This module is under construction and will be launched soon...Sample on GPUFunction listThe parameters of partial distribution functions are as following:FunctionParameters ListNormalmean,std,timesMultinomialcount,prob,timesPoissonlambda,timesGammashape,scale,timesBetaalpha,beta,timesFn1,n2,timesStudentTn,timesDirichletalpha,timesCrtpoint,p,timesWeibullshape,scale,timesChisquaren,timesGeometricp,times......Exampleimport pydpm.distribution as dsg
a=dsg.gamma(1.5,1,100000)
b=dsg.gamma([1.5,2.5],[1,2],100000)More complete demos can be found in pydpm/distribution/...CompareCompare the sampling speed of distribution functions with numpy:The compared code can be found in pydpm/example/Sample_Demo.pyCompare the sampling speed of distribution functions with tensorflow and torch:The compared code can be found in pydpm/example/Sample_Demo2.pyContactLicense: Apache License Version 2.0Contact:  Chaojie Wangxd_silly@163.com, Wei Zhao13279389260@163.com, Jiawen Wuwjw19960807@163.comCopyright (c), 2020, Chaojie Wang, Wei Zhao, Jiawen Wu, Bo Chen and Mingyuan Zhou
Package: pydpn
pydpnPython package for configuring a deeperNetwork deviceInstallpipinstallpydpnUsagePythonfrompydpnimportDeeperNetworkdpn=DeeperNetwork()activeMode=dpn.mode.dpnModeifactiveMode!="smart":dpn.mode.set_dpnMode("smart")CommandlineC:\Users>dpnset-modesmart

C:\Users>dpnset-modefullEUWConfig FileFor convineanc a json file can be saved underC:\Users\%USERPROFILE%\.dpn\config.jsonThe contents must follow this style:{"username":"example","password":"example","hostIp":"http://34.34.34.34","proxy":"192.168.133.99:3128"}If no arguments are passed to the DeeperNetwork class in python script the class will look for the config file at this default placeFor commandline the config file is mandetroyDeeperNetworkMore information on the DeeperNetwork product can be foundhereIf you like the project consider buying your DeeperNetwork hardware with my affiliatlinkchears!
Package: pydpp
=====pyDPP=====A python package for sampling from determinantal point processes. Below are instances of sampling from a bicluster and from a random set of points using pyDPP. Refer to examples and references for more information... raw:: html<img src="https://raw.githubusercontent.com/satwik77/pyDPP/master/example/dpp_selection_k12.png?token=AKhAbS05A3CBgKfXR9P7i4adhlM7Q-whks5b0bhYwA%3D%3D" height="220px">Usage-----Usage example:::>>> from pydpp.dpp import DPP>>> import numpy as np>>> X = np.random.random((10,10))>>> dpp = DPP(X)>>> dpp.compute_kernel(kernel_type = 'rbf', sigma= 0.4)		# use 'cos-sim' for cosine similarity>>> samples = dpp.samples()			# samples := [1,7,2,5]>>> ksamlpes = dpp.sample_k(3)		# ksamples := [5,8,0]Installation------------To get the project's source code, clone the github repository:::$ git clone https://github.com/satwik77/pyDPP.git$ cd pyDPPCreate a virtual environment and activate it. [optional]::$ [sudo] pip install virtualenv$ virtualenv -p python3 venv$ source venv/bin/activate(venv)$Next, install all the dependencies in the environment.::(venv)$ pip install -r requirements.txtInstall the package into the virtual environment.::(venv)$ python setup.py installRequirements^^^^^^^^^^^^- Numpy- ScipyTo run the example jupyter notebook you need install jupyter notebook, sklearn and matplotlib.Compatibility^^^^^^^^^^^^^The package has been test with python 2.7 and python 3.5.2Reference^^^^^^^^^^- Kulesza, A. and Taskar, B., 2011. k-DPPs: Fixed-size determinantal point processes. In Proceedings of the 28th International Conference on Machine Learning (ICML-11) (pp. 1193-1200). [`paper <https://homes.cs.washington.edu/~taskar/pubs/kdpps_icml11.pdf>`__]- Kulesza, A. and Taskar, B., 2012. Determinantal point processes for machine learning. Foundations and Trends® in Machine Learning, 5(2–3), pp.123-286. [`paper <http://www.alexkulesza.com/pubs/dpps_fnt12.pdf>`__]
Package: pydprint
python-dprintAn easy-to-use debug print tool for deep learning studies in python.DEMOWhy we need it?The built-in debugger is great, however, for some reason, we may still want toprint them out for debugging purpose. For such scenarios, we would like it to have the following feats. (especially when running deep learning projects - where our monitoring/debugging variables are being updated within loops).Context Info. We may like to display theinvoking positionsfor these variables (to help us identify back each of them), including their file name, func name, and line number.Different Color. We may like it to beclearly distinguishablefrom tons of normal printings within loops, such asdisplaying training loss. The default color is YELLOW now, which could be custmozed in future releases soon (full color-code can be foundhere).Pass-Through Print. We may like to monitor things without breaking current code structure, i.e.,print-and-return. Note: you can still simplydprint()them (just like print() in python) - it's compatible to both usecases.#loss = loss1 + loss2
loss = loss1 + dprint(loss2)(Optional) Multiple Variables. We may not like to leave too much dprint() statement in our code - they look redundent - instead, we may like to display multiple variable within lines as less as possible (by passing them all as a dict).How we use it?Very easy :)Installationpip install pydprintImportfrom pydprint import dprintDemo Usecases:demo.py(see some examples).
Package: pydproc
pydprocpydproc is python3 package that provides a simple to use command line interface for periodic data retrieval from APIs. Using inputs from a YAML, pydproc builds a new Docker image specific to that process. The user can then run, stop, and restart these processes for pydproc to start collecting data. When the user wants this data, they can easily retrieve it along with the run logs. This can help generate new datasets for Machine Learning projects as it simplifies and automates the process of data collection from APIs.InstallationPydproc can be installed using pip:pip install pydprocGetting StartedTalk about basic commands here.ContributingPlease readCONTRIBUTING.mdfor details on our code of conduct, and the process for submitting pull requests to us.AuthorsVladimir Ovechkin-Project setup, Initial work, Managing TODOs, Packaging- University of WashingtonRobert Burris-YAML processing, Data field validation, API data parsing- University of WashingtonAndrew Wu-Initial work- University of WashingtonSee also the list ofcontributorswho participated in this project.LicenseThis project is licensed under the MIT License - see theLICENSE.mdfile for detailsAcknowledgmentsHat tip to anyone whose code was usedInspirationetc
Package: pydps
Python Design PatternsThis small package contains Python implementations of design pattern which are frequently used in software engineering.InstallationThis package can be installed via pip command:$pipinstallpydpsOr installed from source:$gitclonehttps://github.com/hieupth/pydps.git
$cdpydps
$pythonsetup.pyinstallMaintainersHieu Pham(author)Please feel free to contact me if you have any question or interested in contributing to my open source projects or
researchLicenseMIT LicenseCopyright (c) 2021,Hieu Pham. All rights reserved
Package: pydpu
pydpuPython library and cli to communicate with DPUs and IPUsI Want To ContributeThis project welcomes contributions and suggestions.  We are happy to have the Community involved via submission ofIssues and Pull Requests(with substantive content or even just fixes). We are hoping for the documents, test framework, etc. to become a community process with active engagement.  PRs can be reviewed by by any number of people, and a maintainer may accept.SeeCONTRIBUTINGandGitHub Basic Processfor more details.InstallationThere are several ways of running this CLI.Dockerdockerpullopiproject/pydpu:<version>You can specify a version like0.1.1or uselatestto get the most up-to-date version.Run latest version of the CLI in a container:dockerrun--rmopiproject/pydpu:latest--helpReplace--helpwith anypydpucommand, withoutpydpuitself.PyPIpipinstallpydpuUsageInventoryTo get inventory, run:pydpu--address=localhost:50151inventorygetIpsecTo create a tunnel, run:pydpu--address=localhost:50151ipseccreate-tunnelTo get statistics, run:pydpu--address=localhost:50151ipsecstatsPackagingThis project usespoetryto manage dependencies, build, etc.Releasing new versions# Make sure you have dev dependencies installed$poetryinstall--groupdev# Use bump2version to update version strings and create a new tag$bump2version<patch|minor|major># Push new tag$gitpush--tags# Create GitHub release$ghreleasecreatev$(poetryversion-s)--generate-notes
Package: pydq
pydqA python library for managing and persisting named Python QueuesInstallationpipinstallpydqSome backends may require extra packages:pipinstallpydq[aws]Basic Usagewithdq_provider('name')asdq:# Query the last 10 entries with qid='item_id'dq(qid='item_id',start_time=datetime(1,1,1),end_time=datetime.utcnow(),limit=10)item=dq.get()# queue items should be dictionaries with 3 keys: qid, ts, and valdq.put({'qid':'item_id','ts':'2019-09-11T03:23:54Z','val':'foo'})note: specifyingqidin the query is optional, if omitted all items between the start and end time are returnedSupported Backends:Local StorageSQLite:frompydq.localimportSQLiteasdq_providerCloud StorageDynamoDBfrompydq.cloudimportDynamoDBasdq_providernote: cloud storage is created lazily; the first call to one of these providers will create the resources in the cloud.Additional APISome queue methods accept aforgetargument that will tell the queue object whether the operation should be persisted. This always defaults toFalse.dq.get(forget=True)# the returned item will be deleted from persistencedq.put(item,forget=True)# item will not be persisteddq.get_all(forget=True)# Easy way to delete all items in a queuedq.put_all(items,forget=False)dq.get_to_dataframe()# install with pandas extra. Returned items are not deleteddq.put_from_dataframe(df)# items will be persisteddq.clear()# another way to delete all items in a queueConfiguration queuesdq is great for managing simple JSON configuration too. And we get change tracking for free!frompydq.helpersimportDqConfigfrompydq.localimportSQLitewithDqConfig(name='ApplicationConfig',dq_provider=SQLite)asconfig:app_id=config['app_id']last_start=config['last_start']config['app_status']='#1best'
Package: pyDR
# pyDR beta 0.1 - August 2016
Authors: Maximilian Balandat, Clay Campaigne, Lillian RatliffPython package for simulating behavior and quantifying welfare effects of electricity consumers facing various dynamic pricing schemes.
This package is the basis for the results reported in:C. Campaigne, M. Balandat and L. Ratliff: Welfare Effects of Dynamic Electricity Pricing. In preparation.### Requirements / Dependencies:
* gurobipy (+ GUROBI with valid license)
* numpy
* scipy
* pandas
* pytz
* patsy
* logutils (for examples if using python 2)### Modules:
* dynamic_models.py: Definition of basic dynamic consumption models
* blopt.py: Main module defining model and formulating optimization problem
* utils.py: Specify tariff data and provide utility functions for other modules
* simulation.py: Functions for simulating a large number of different scenarios### Installation (using setuptools):
* from source:python setup.py install* from pypi:pip install pyDR### Usage:
See scripts in examples folder### Data:
To run the scripts in the examples folder you will need to download and extract the following [zip file](https://www.ocf.berkeley.edu/~balandat/pyDR_data.zip) (~25MB)
Package: pydra
Pydra: Dataflow EngineA simple dataflow engine with scalable semantics.Pydra is a rewrite of the Nipype engine with mapping and joining as
first-class operations. It forms the core of the Nipype 2.0 ecosystem.The goal of pydra is to provide a lightweight Python dataflow engine for DAG
construction, manipulation, and distributed execution.Feature list:Python 3.7+ using type annotation andattrsComposable dataflows with simple node semantics. A dataflow can be a node of another dataflow.splitterandcombinerprovides many ways of compressing complex loop semanticsCached execution with support for a global cache across dataflows and usersDistributed execution, presently via ConcurrentFutures, SLURM, and Dask (this is an experimental implementation with limited testing)API DocumentationLearn more about PydraSciPy 2020 ProceedingsPyCon 2020 PosterExplore Pydra interactively(the tutorial can be also run using Binder service)Please note that mybinder times out after an hour.Installationpip install pydraNote that installation fails with older versions of pip on Windows. Upgrade pip before installing:pip install –upgrade pip
pip install pydraDeveloper installationPydra requires Python 3.7+. To install in developer mode:git clone git@github.com:nipype/pydra.git
cd pydra
pip install -e ".[dev]"In order to run pydra’s test locally:pytest -vs pydraIf you want to test execution with Dask:git clone git@github.com:nipype/pydra.git
cd pydra
pip install -e ".[dask]"It is also useful to install pre-commit:pip install pre-commit
pre-commit
Package: pydra-ants
pydra-antsPydra tasks for ANTsPydrais a dataflow engine which provides
a set of lightweight abstractions for DAG
construction, manipulation, and distributed execution.ANTsis a toolbox for multi-variate image registration,
segmentation and statistical analysis.Table of ContentsAvailable TasksInstallationDevelopmentLicenseAvailable TasksApplyTransformsCreateJacobianDeterminantImageN4BiasFieldCorrectionRegistration, registration_syn, registration_syn_quickInstallationpip install pydra-antsA separate installation of ANTs is required to use this package.An official conda package is available through conda-forge:conda install -c conda-forge antsDevelopmentThis project is managed withHatch:pipx install hatchTo run the test suite:hatch run testTo fix linting issues:hatch run lint:fixLicenseThis project is distributed under the terms of theApache License, Version 2.0.
Package: pydra-bids
pydra-bidsPydra tasks for BIDS I/O.Pydrais a dataflow engine
which provides a set of lightweight abstractions
for DAG construction, manipulation, and distributed execution.BIDSdefines standards for organizing neuroimaging files and metadata.This project provides tasks for reading from and writing to BIDS datasets.Table of contentsInstallationDevelopmentLicensingInstallationpip install pydra-bidsDevelopmentThis project is managed withHatch:pipx install hatchTo run the test suite:hatch run test:no-covTo fix linting issues:hatch run lint:fixTo check the documentation:hatch run docs:serve --open-browserLicensingThis project is released under the terms of theApache License, Version 2.0.
Package: pydracs
PyDracsDistributed control and communications system mainly targeted at single board
computers such as the raspberry pi.Free software: MIT licenseDocumentation:https://pydracs.readthedocs.io.NOTE: This package is currently under development so any current
package/modules may change drastically from any final designs.FeaturesInputWatcher - Wraps RPi.GPIO library to enable blocking various operationsButtons - Creates a button on specified pin BCM numberCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2018-10-14)First release on PyPI.
Package: pydra-dcm2bids
pydra-dcm2bidsPydra tasks for dcm2bids.Pydrais a dataflow engine which provides
a set of lightweight abstractions for DAG
construction, manipulation, and distributed execution.dcm2bidsis a tool which facilitates
conversion from DICOM datasets to NIfTI files
organized asBIDS.Installationpip install pydra-dcm2bidsA separate installation ofdcm2bidsanddcm2niixis required to use this package.
Please review the followinginstructions.dcm2bidscan be installed alongsidepydra-dcm2bidswith:pip install 'pydra-dcm2bids[all]'Usagefrompydra.tasksimportdcm2bidstask=dcm2bids.Dcm2Bids(dicom_dir="/path/to/dicom/dir",output_dir="/path/to/bids/dir",config_file="/path/to/config/file.json",participant_id="sub-01",)result=task()You may check the following example of aconfiguration file.DevelopmentThis project is managed withHatch:pipx install hatchTo run the test suite:hatch run test:no-covTo fix linting issues:hatch run lint:fixTo check the documentation:hatch run docs:serve --open-browserLicensepydra-dcm2bidsis distributed under the terms of theApache License, Version 2.0.
Package: pydra-dcm2niix
Pydra Dcm2Niix TaskThis repository contains Pydra task interface for thedcm2niixDICOM to NIfTI converter tool (https://github.com/rordenlab/dcm2niix).Part of this effort is to establish a (mostly) declarative language for describing tasks that
potentially have intricate rules for determining the availability and names from the choice of
inputs.Installationpip install /path/to/pydra-dcm2niix/Installation for developerspip install -e /path/to/pydra-dcm2niix/[dev]Basic UseTo run thedcm2niixtaskfrom pydra.tasks.dcm2niix import Dcm2Niix

task = Dcm2Niix(in_dir='/path/to/dicom/dir', out_dir='/path/to/create/nifti/output')
result = task()However, the converter task interface will typically be used as the first step within larger Pydra workflowsfrom pydra import Workflow
from pydra.tasks.dcm2niix import Dcm2Niix

my_workflow = Workflow(name='my_workflow', input_spec=['in_dicom'])

my_workflow.add(
    Dcm2Niix(name='converter', in_dir=my_workflow.lzin.in_dicom, out_dir='.'))
my_workflow.add(...)

my_workflow()
Package: pydra-freesurfer
pydra-freesurferPydra tasks for FreeSurfer.Pydrais a dataflow engine
which provides a set of lightweight abstractions
for DAG construction, manipulation, and distributed execution.FreeSurferis a neuroimaging toolkit
for processing, analyzing, and visualizing human brain MR images.This project exposes some of FreeSurfer's utilities as Pydra tasks
to facilitate their integration into more advanced processing workflows.Table of contentsInstallationAvailable interfacesDevelopmentLicensingInstallationpip install pydra-freesurferAvailable interfacesgtmsegmri_aparc2asegmri_binarizemri_convertmri_label2volmri_surf2surfmri_vol2volmris_anatomical_statsmris_ca_labelmris_ca_trainmris_expandmris_preprocrecon-alltkregister2DevelopmentThis project is managed withHatch:pipx install hatchTo run the test suite:hatch run test:no-covTo fix linting issues:hatch run lint:fixTo check the documentation:hatch run docs:serve --open-browserLicensingThis project is released under the terms of theApache License, Version 2.0.