Saravanan666/pypi-org huggingface dataset:
Package: pydeltasnow
pydeltasnowPython implementation of the deltaSNOW model by Winkler et al. 2021:Winkler, M., Schellander, H., and Gruber, S.: Snow water equivalents
exclusively from snow depths and their temporal changes: the DeltaSNOW model,
Hydrol. Earth Syst. Sci., 25, 1165-1187,10.5194/hess-25-1165-2021, 2021.The original implementation is included within thenixmassR package
of Winkler et al 2021. Differences of this version to the original R
version are the following:The model accepts breaks in the date series if a break is sourrounded
by zeros. Additionally, breaks in the date series can be accepted if
surrounded by NaNs. See below for more information. This behaviour
can be useful for measurement series that are not continued in summer.The user can specify how to deal with missing values in a measurement
series. There are three parameters that control NaN handling:ignore_zeropadded_gapsignore_zerofollowed_gapsinterpolate_small_gapsNote that the runtime efficiency of the model will decrease when one
or several of these options are turnded on.Accepts as input data only a pd.Series with pd.DatetimeIndex and no
dataframe.The time resolution (timestep in R implementation) will be automatically
sniffed from the DatetimeIndex of the input series.The user can specify the input and output units of the HS and SWE
measurement series, respectively.A pd.Series with the dates as pd.DatetimeIndex is returned.The core of this code is mainly basedon the work of Manuel Theurl, this version makes use of thenumbajust-in-time compiler for performance optimization.DependenciesThe package is tested on python versions 3.7, 3.8 and 3.9. Higher python versions
might work too but are not tested.pydeltasnowdepends on the following packages:pandas: >=1.3numpy: <1.21, >=1.17numba: >=0.53.1InstallationInstallpydeltasnowand its dependencies by runnig:pip install pydeltasnowUsageFor examples on how to use the package, please have a look at thedocumentationof this project.
Package: pydemand
=====Pydemand=====Pydemand is a energy demand estimation Python library.Right now, it is in an infant state, only retrieving country-scale electricitydemand data estimated for 2020 inLong term load projection in high resolution for all countries globally_... _Long term load projection in high resolution for all countries globally:https://www.sciencedirect.com/science/article/abs/pii/S0142061518336196/!! While these methods are scalable, they do not guarantee accurate results !!We refer to the linked paper for a discussion of what to consider before using the data.=====Installation=====The library can be install viapipfrompypi.. code:: shellpip install pydemand=====What is next?=====This package is a work in progress. We plan toRetrieve an electricity demand estimation for any passed geospatial polygonbased on statistical models, trained on the existing data.Add estimations of heat demand profiles to the package, which are alsoretrievable by polygon.
Package: pydemic
Thepydemicpackage comprises a set of tools for modeling the population dynamics of an epidemic and calibrating models to data.pydemicprovides implementations of various types ofcompartmental models,
including not only SIR/SEIR models but also the more general Kermack and McKendrickage-of-infection models,
which allow transitions between disease states to be described by arbitrary time-delay distributions.
More generally,pydemicprovides a framework for users to specify custom epidemic models by extending the base classes for reaction-based and non-Markovian simulations.To evaluate a model’s applicability to an actual epidemic, its predictions
(e.g., for the rate of new cases or deaths) can be compared to real world data.
Parameter inference—the task of calibrating a model’s input parameters via likelihood estimation—is supported bypydemic’s interfaces to the Markov chain Monte Carlo packageemceeand SciPy’s global optimization routines.pydemicprovides simple parsers for COVID-19 case data sourced from
theCOVID Tracking Projectand
theNew York Times.
Pull requests that contribute new, robust parsers are welcome!As an example, we consider ourSEIR++model, which treats the dynamics of infection and subsequent hospitalization.
The model includes a large set of parameters that specify
the distribution of various time delays (e.g., for the spread of infection, symptom onset, and hospitalization), the severity of infection (i.e., the likelihood of progressing from one stage of the disease to the next), and the time-dependent degree to which interventions mitigate the spread of the disease.
We calibrate these parameters by comparing the model’s predictions
to COVID-19–related hospitalizations and deaths in Illinois.
We describe the model and calibration procedure in detail in arecent preprinton the arXiv.pydemicis in beta.
While effort will be made to preserve backwards compatibility with staged
deprecation, we cannot guarantee that features will be preserved or that interfaces will not change.
However, we will attempt to ensure that backwards-incompatible changes are demarcated by incrementing the major version.pydemicisfully documentedand is licensed under the liberalMIT license. See the docs forcitation info.Getting startedpydemicis available on PyPI and can be installed with pip:pip install pydemicSeveral examples exhibit how to usepydemic:TheSEIR++ tutorial notebookdemonstrates how to set up a simulation object, specify parameters, run the simulation, and visualize the results.An example ofcalibrationillustrates how to set up likelihood estimation, run Markov chain Monte Carlo, and plot the posterior probability distribution of model parameters, using the SEIR++ model and public Illinois data from the COVID Tracking Project as an example.
Package: pydemic-ui
A set of streamlit apps and utilities used in creating the UI for Pydemic apps.UsageInstall it usingpip installpydemic-uior your method of choice. Now, you can just import
it and load the desired functions. You can use pydemic-ui as a drop-in replacement for streamlit
by using>>> from pydemic_ui import st
>>> st.pydemic(locale="pt-BR")AppsPydemic-ui comes with a few Streamlit apps ready to deploy. Just execute the app module
specifying the desired app:$ python -m pydemic_ui.apps calcCurrently, only the calc app is available, but other apps should arrive soon. For more
options, execute it with the “–help” flag.
Package: py-demo
A minimal python project. Features:Create a binary usingPyinstallerGitHub Actions adds binaries toreleasesCorrectly handle data filesInstallation Options1. Build from source (requires Python 3.8+)Clone this project locally and then run:pip install .Or, create a binary, which creates an executable file at./dist/py-demo:make binary2. Download binary from a releaseHead over to thereleasespage and
grab a binary. Or, to programmatically fetch the latest release (say, for
MacOS):repoUrl=https://api.github.com/repos/cfclrk/py-demo
assetId=$(curl -s $repoUrl/releases/latest \
    | jq '.assets[] | select(.name | contains("Darwin")).id')
curl -sSL -H "Accept: application/octet-stream" \
    $repoUrl/releases/assets/$assetId -o py-demo
chmod +x py-demoExampleAfter installing, run eitherpy-demo(if installed from source) or./py-demo(if installed as a binary).py-demo --foo bar

The version of this package is: 0.0.9
The data file says: This is some text
The value of foo is: barAnd it has a--versionflag:py-demo --version

0.0.9
Package: pydemonstrativos
PydemonstrativosDemonstrativos Financeiros - Dados CVMDependenciesYou need Python 3.7 or later to usepacotepypi. You can find it atpython.org.You also need setuptools, wheel and twine packages, which is available fromPyPI. If you have pip, just run:pip install pandasInstallationClone this repo to your local machine using:git clone https://github.com/andremsilveira/pydemonstrativosFeaturesFile structure for PyPI packagesSetup with package informationsLicense exampleExamplepip install pydemonstrativo
from pydemonstrativo import CVM

CVM.about()
links = CVM.create_links_api(2012, 2021)
print(links)
Package: py_dempster_shafer
A Python library for performing calculations in the Dempster-Shafer theory of evidence.Features:
Support for normalized as well as unnormalized belief functions
Different Monte-Carlo algorithms for combining belief functions
Various methods related to the generalized Bayesian theorem
Measures of uncertainty
Methods for constructing belief functions from dataBoth Python 2.7 and Python 3.x are supported.See examples.py for how to use it.
Package: pydemult
# Streamed and parallel demultiplexing of fastq files## Quickstart` pydemult--fastqinput.fastq.gz--barcodesbarcodes.txt--threads4--writer-threads16 `## Requirements and usagepydemultallows you to demultiplex fastq files in a streamed and parallel way. It expects that asample barcodecan be matched by a regular expression from the first line of each fastq entry and that sample barcodes are known in advance.Suppose we have a file containingsample barcodeslike this:` Sample  Barcode sample1 CTTCAA sample2 CAACAA sample3 GTACGG `and a typical entry in the fastq file looks like this:`@HWI-ST808:140:H0L10ADXX:1:1101:8463:2:NNNNNN:CTTCCATTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTATGATGCTGTGAGTTCC +@CCDDDDFHHHHHJIJFDDDDDDDDDBDDDDDBB0@B#####################`Since the sample barcode is six bases long, we have to set the corresponding–barcode-regexoption to(.*):(?P<CB>[ATGCN]{6}in the call` pydemult--fastqinput.fastq.gz--barcodesbarcodes.txt--barcode-regex"(.*):(?P<CB>[ATGCN]{6}"`### Barcode and UMI regular expressionsBy default,pydemultparses the read name for the cell barcode with regular expressions. Cell barcodes are indicated by a capturing group calledCB, while (optional) UMIs are indicated by a capturing group calledUMI. Some examples include:(.*):(?P<CB>[ATGCN]{11}), for a cell barcode of length 11 that is present after the last colon of the read name.(.*):CELL_(?P<CB>[ATGCN]{10}):UMI_(?P<UMI>[ATGCN]{8}), for a cell barcode of length 10, followed by a UMI sequence of length 8. For DropSeq data preprocessed by the [umis](https://github.com/vals/umis) tool, a regex like this is advisable.### Outputpydemultwill create a compressed fastq file for eachsample barcode, with the filename taken from the correspondingSamplecolumn entry ofbarcodes.txt.### A note on multithreadingpydemultdivides its work into a demultiplexing and output part. The main thread streams the input and lazily distributes data blobs (of size–buffer-size) acrossndifferent demultiplexing threads (set with–threads), where the actual work happens. Demultiplexed input is then sent over tomthreads for writing into individual output files (set with–writer-threads). Reading and demultiplexing are fast and CPU-bound operations, while output speed is determined by how fast data can be written to the underlying file system. In our experience, output is much slower than demultiplexing itself and requires proportionally more cores to speed up the runtime. We obtained best results when distributing output to three threads for each demultiplexing thread (1:3ratio of–threadsto–writer-threads).## LicenseThe project is licensed under the MIT license. See theLICENSEfile for details.
Package: pydemux
pydemuxAn easy to use python tool for fast demultiplexing of SAM/BAM formated raw sequence dataInstallationpip install pydemuxor clone the repositorygit clone git@github.com:dmalzl/pydemux.gitand runcd pydemux
pip install .verify the installation by typingpydemux -hBasic usagepydemux can be used to demultiplex sequence data in SAM/BAM format for either single or paired-end reads (in case of paired-end the reads have to be interleaved). Basic command for this are listed below (you can test these using the files in the data directory)pydemux single -b single_barcodes.tsv -o demux/ -s demux_stats.tsv single.bampydemux paired -b paired_barcodes.tsv -o demux/ -s demux_stats.tsv paired.bamNote that for writing the files to a specific output directory the/needs to be included for the-o/--output_prefixcommandline argument or they will be written to the current work directory. In order to compress the output one can also add the-gz/--gzipcommandline argument to the command.Changing looked up SAMfile tags from which the barcodes are readBy default the algorithm looks for the barcode in theBCtag of each read in case ofpydemux singleand in theBCandB2tag of the paired-end reads in case ofpydemux paired. This can be changed using either the-t/--bctagor-t1/--bc1tagand/or-t2/--bc2tagforpydemux singleorpydemux pairedrespectively.Speeding up processingIn order to speed up demultiplexing the algorithm can be run concurrently using the-p/--processesargument.Optimizing yieldAs with every sequencing-based data type, the barcodes are also prone to include sequencing errors. In order to optimize the read yield for each sample the algorithm allows for a given number of mismatches between the true and the sequenced barcodes which can be set with-m/--mismatches. By default only exact matches will be assigned. If you want to allow for one or more mismatches please make sure that the number of allowed mismatches does not exceed half of the minimum pairwise Hamming distance of all true barcodes minus 1 (i.e.min(pairwise_hamming_distance(true_barcodes)) // 2 - 1) since otherwise reads might be wrongly assignedBarcode file formatThe barcode file is a simple tab-separated file containing one sample and its associated barcodes per line. In case ofpydemux singleeach line consists of one barcode and one sample name. e.g.barcodesample_nameACGTCGTAsample_1In case ofpydemux pairedthe file contains two barcodes and one sample name per line. e.g.barcode1barcode2sample_nameACGTCGTACGTAGGATsample_1
Package: pyden
📡 pyden: A simple Python API for Denver, CO Datapydenis a simple library to get data from the city and county of Denver, CO.PLEASE READ: Version 1.0.0 and BeyondVersion 1.0.0 ofpydenmakes several breaking, but necessary changes:Moves the underlying library fromRequeststoaiohttpChanges the entire library to useasyncioMakes 3.6 the minimum version of Python requiredIf you wish to continue using the previous, synchronous version ofpyden, make sure to pin version 0.4.1.Python Versionspydenis currently supported on:Python 3.5Python 3.6Python 3.7However, running the test suite currently requires Python 3.6 or higher; tests
run on Python 3.5 will fail.InstallationpipinstallpydenUsagepydenstarts within anaiohttpClientSession:importasynciofromaiohttpimportClientSessionfrompydenimportClientasyncdefmain()->None:"""Create the aiohttp session and run the example."""asyncwithClientSession()aswebsession:# YOUR CODE HEREasyncio.get_event_loop().run_until_complete(main())To create a client, simply:importasynciofromaiohttpimportClientSessionfrompydenimportClientasyncdefmain()->None:"""Create the aiohttp session and run the example."""asyncwithClientSession()aswebsession:client=Client(websession)asyncio.get_event_loop().run_until_complete(main())Trash ScheduleimportasynciofromaiohttpimportClientSessionfrompydenimportClientasyncdefmain()->None:"""Create the aiohttp session and run the example."""asyncwithClientSession()aswebsession:client=Client(websession)# Initialize the trash module:awaitclient.trash.init_from_coords(<LAT>,<LON>,"<GOOGLE_API_KEY>")# Get the full schedule:awaitclient.trash.schedule()# ...or get the date of next pickup:awaitclient.trash.next_pickup(client.trash.PickupTypes.recycling)asyncio.get_event_loop().run_until_complete(main())ContributingCheck for open features/bugsorinitiate a discussion on one.Fork the repository.Install the dev environment:make init.Enter the virtual environment:pipenv shellCode your new feature or bug fix.Write a test that covers your new functionality.Run tests and ensure 100% code coverage:make coverageAdd yourself toAUTHORS.md.Submit a pull request!
Package: pydena
pydenaUnofficial Python API foridena-go RPCHelp Support Me by Donating iDNA to My AddressHereRequirementsPython 3.6+Installation# From pypi
pip install pydena

# From source
git clone github.com/M4cs/pydena
cd pydena
python3 setup.py installRoadmapRPC APIs:IPFS API ✔Accounts API ✔Blockchain API ✔DNA API ✔Net API ❌Flip API ❌Contracts API ❌Idena API:This will be worked on after RPC. Version 2 will migrate API -> pydena.RPC. pydena.API will become the http API for the explorer.UsageInitialize your API:frompydenaimportAPI# Local Node with No API Key on http://localhost:9009api=API()# Local Node with API Keyapi=API(apikey='YOUR-API-KEY')# Remote node with API Keyapi=API('http://localhost:9999','YOUR-API-KEY')# Get Coinbase Address:api.getCoinbaseAddress()# Get Last Block:api.getLastBlock()# To get JSON responses, just pass `raw=True` to any API/RPC Callapi.getLastBlock(raw=True)# See all in documentation below!View the official documentationhere
Package: pydendroheatmap
# pydendroheatmap - a plotting tool for making heatmaps with hierarchically clustered data in python.pydendroheatmap is registered as a package on PyPI, so to install, simply type```bashpip install pydendroheatmap```To install the package from source, download the repository, unpack and open a command line prompt in the unpackaged directory. Then simply type:```bashpython setup.py install```To make a plot, simply import the package, and create a DendroHeatMap object. Data for the heatmap anddendrogram do not need to be specified at the time of creation, however, if no data is supplied thenthe plot for these objects will not be rendered. See example uses below.The data for the heat map should be either a numpy.ndarray or numpy.matrix object, and the top and left dendrogramdata should be in the form of a (n-1) x 4 linkage matrix used in the scipy hierarchical clustering package.```pythonimport pydendroheatmap as pdhtry: import cPickle as pickleexcept: import pickleheatmap_array = pickle.load(open('some_data_file.pickle'))#a numpy.ndarray or numpy.matrix, for this example, let's say mxn arraytop_dendrogram = pickle.load(open('another_data_file.pickle'))#a (n-1) x 4 arrayside_dendrogram = pickle.load(open('a_third_data_file.pickle'))#a (m-1) x 4 arrayheatmap = pdh.DendroHeatMap(heat_map_data=heatmap_array, left_dendrogram=side_dendrogram, top_dendrogram=top_dendrogram)heatmap.title = 'This is an example'heatmap.show()heatmap.colormap = heatmap.yellowBlackBlueheatmap.show()heatmap.row_labels = ['some', 'row','labels'] #must have the same number of rows in heat_map_dataheatmap.reset_plot()heatmap.show()#excellent, let's export itheatmap.export('awesome_heatmap_plot.png')```To see a built-in example, run these commands in the python interpreter:```pythonfrom pydendroheatmap import exampleexample.run()```The example should make a plot that will look similar to this:![Example Image](https://github.com/themantalope/pydendroheatmap/blob/master/pydendroheatmap/exampledata/example.png)The DendroHeatMap object's `render_plot()` function will generate a heat plot, similar in fashion to the one found here:http://code.activestate.com/recipes/578175-hierarchical-clustering-heatmap-python/Each time the DendroHeatMap object's `show()`, `export()`, and `render_plot()` functions are called,the plot will be reset and any changes that have been made to the plot's instance variables should be taken into accountin the new plot.A special thanks to [Nathan Salomonis](http://www.cincinnatichildrens.org/bio/s/nathan-salomonis/) for posting theoriginal example and figuring out much of the parameters for getting the plots in the correct position!
Package: pydenji
Pydenji Dependency Injection Toolkit===================================:Author: Alan Franzoni:Copyright: This document has been placed in the public domain.Enables easy dependency injection and declarative configuration forPython projects. While inspired by projects such as Spring Frameworkor Ruby's DIM, it is designed to be unobtrusive. It doesn't requiremodification in your business code to be employed; it can just be used inthe outer layer, where configuration is actually needed.Small additional tools to help with configuration management are providedand can be used when and where are really fit.__.. _homepage:http://pydenji.franzoni.eu
Package: pydensity
✨ pydensity ✨The python binding fordensity安装pipinstallpydensity使用encodeimportpydensityorigin=b"121212121212121"size=pydensity.decompress_safe_size(len(origin))data=pydensity.compress(origin,pydensity.Algorithm.lion)print(pydensity.decompress(data,size))公开函数fromtypingimportAnyimportenumclassAlgorithm(enum.Enum):chameleon:Anycheetah:Anylion:Anydefformat_state(state)->str:...defmajor_version():...defminor_version():...defrevision_version():...defget_dictionary_size(algorithm:Algorithm):...defcompress_safe_size(input_size:int):...defdecompress_safe_size(input_size:int):...classCompressor:c_state:Anycontext:Anydef__init__(self,algorithm:Algorithm,custom_dictionary:bool)->None:...@propertydefstate(self):...defcompress(self,data:bytes)->bytes:...def__del__(self)->None:...classDeCompressor:c_state:Anycontext:Anydef__init__(self,data:bytes,custom_dictionary:bool)->None:...@propertydefstate(self):...defdecompress(self,data:bytes,decompress_safe_size:int)->bytes:...def__del__(self)->None:...defcompress(data:bytes,algorithm:Algorithm)->bytes:...defcompress_into(data:bytes,out:bytearray,algorithm:Algorithm)->int:...defdecompress(data:bytes,decompress_safe_size:int)->bytes:...defdecompress_into(data:bytes,out:bytearray)->int:...本机编译python -m pip install setuptools wheel cython cffi
git clone https://github.com/synodriver/pydensity
cd pydensity
git submodule update --init --recursive
python setup.py bdist_wheel --use-cython --use-cffi后端选择默认由py实现决定，在cpython上自动选择cython后端，在pypy上自动选择cffi后端，使用DENSITY_USE_CFFI环境变量可以强制选择cffi
Package: pydent
Pydent: Aquarium API ScriptingPydent is the python API for Aquarium.DocumentationAPI documentation can be found here at http://aquariumbio.github.io/pydentRequirementsPython > 3.4An Aquarium loginQuick installationPydent can be installed usingpip3.pip3 install pydentor upgraded usingpip3 install pydent --upgradeBasic UsageLogging infrompydentimportAqSession# open a sessionmysession=AqSession("username","password","www.aquarium_nursery.url")# find a useru=mysession.User.find(1)# print the user dataprint(u)Modelsprint(mysession.models)Finding modelsBy name:nursery.SampleType.find_by_name("Primer")By ID:nursery.SampleType.find(1)By property:nursery.SampleType.where({'name': 'Primer'})All models:nursery.SampleType.all()Getting nested data# samples are linked to sample_typeprimer_type=mysession.SampleType.find_by_name("Primer")primers=primer_type.samples# and sample type is linked to samplep=primers[0]print(p.sample_type)Listing Available nested relationshipsprimer_type=mysession.SampleType.find(1)print(primer_type.get_relationships())making a releaseUpdate dependenciespoetryupdatepoetrybuild
poetrypublishTo use a pypi token, the user name should be__token__and the password should be the token including thepypi-prefix.Update documents withmake docs