Saravanan666/pypi-org huggingface dataset:
Package: pba
PBAPBA is a probability bound analysis library for Python that allows one to create and calculate with probability distributions, intervals, and probability boxes (p-boxes) within Python.Probability distributions can be specified usingpba.distname(**args)wheredistnameis any of the named distributions that scipy.stats supports.  For instance,   pba.N(0,1) specifies a Normal distribution with mean 0 and variance 1. P-boxes can be created by using interval arguments for these distributions.  Intervals can be created usingpba.I(left, right)whereleftandrightare expressions for the lower and upper limits of the interval.FeaturesInterval arithmetic (seehttps://en.wikipedia.org/wiki/Interval_arithmetic)P-box arithmetic (seehttps://en.wikipedia.org/wiki/Probability_bounds_analysis)InstallationInstall pba by runningpip install pbaContribute & SupportIf you are having issues or would like to help with development or have intersting use cases, please let us know.
You can emailngg@liv.ac.uk.LicenseThe project is licensed under the MIT License.
Package: pbaa
pbaa : Prompt-Based Automatic AnnotationEasy inference implementation ofGrounded-SAMforPrompt-based automatic annotationTable of ContentsInstallationUsageGradioDemoLicenseAcknowledgementsInstallationDocker (Recommend)git clone https://github.com/dh031200/pbaa.gitdocker build docker -t pbaa:latestdocker run --gpus all -it --ipc=host -v `pwd`:/workspace -p 7860:7860 pbaa:latestWithout dockerThe code requirespython>=3.8,CUDA==11.7.pip install pbaaUsageOptionsUsage: pbaa [OPTIONS]Options:--version                    Show the version and exit.-s, --src TEXT               Source image or directory path-p, --prompt <TEXT TEXT>...  Space-separated a pair of prompt and targetclasse. (Multi)-b, --box_threshold FLOAT    Threshold for Object Detection (default: 0.25)-n, --nms_threshold FLOAT    Threshold for NMS (default: 0.8)-o, --output_dir TEXT        Path to result data (default: 'outputs')-g, --gradio                 Launch gradio app-h, --help                   Show this message and exit.CLI#pbaa-s<Source>-p<prompt><class>-p<prompt><class>...pbaa -s source_image.jpg -p "black dog" dogpbaa -s source_image.jpg -p "black dog" dog -p "white cat" catPythonfrompbaaimportPBAAannotator=PBAA()# inference(<Source path>, <prompt:class dict>, box_threshold=0.25, nms_threshold=0.8, save=None, output_dir="outputs")annotator("path/to/source_image.jpg",{"black dog":"dog","white cat":"cat"})GradioRun thegradiodemo with a simple commandpbaa -gOutputLaunch gradio app
Running on local URL:  http://0.0.0.0:7860You can now access Gradio demos using your browser.localhost:7860Demo#Source:assets/demo9.jpg#prompts:{"plant":"plant","picture":"picture","dog":"dog","lamp":"lamp","carpet":"carpet","sofa":"sofa"}pbaa -s assets/demo9.jpg -p plant plant -p picture picture -p dog dog -p lamp lamp -p carpet carpet -p sofa sofaOriginDetectionSegmentationResult datademo9.jsonjson structurefilenamepromptindex├ cls : class name├ conf : confidence score├ box : bounding box coordinates└ poly : polygon coordinatesLicensepbaais distributed under the terms of theApache-2.0license.AcknowledgementsGrounded-Segment-Anything :https://github.com/IDEA-Research/Grounded-Segment-AnythingGrounding DINO :https://github.com/IDEA-Research/GroundingDINOSegment-anything :https://github.com/facebookresearch/segment-anything
Package: pba-client
tg-parking-api-clientpip install pba-clienttelegram_users.basic_operation:def create_telegram_user(self, user: dict):
        url = self.prepare_url()
        return requests.post(url, json=user).json()
        
    def create_telegram_user(self, user: dict):
        url = self.prepare_url()
        return requests.post(url, json=user).json()

    def get_telegram_user(self, user: dict):
        url = self.prepare_url(f"{user.get('id')}")
        return requests.get(url).json()

    def update_telegram_user(self, user: dict):
        url = self.prepare_url(f"{user.get('id')}")
        return requests.put(url, json=user).json()
Package: pbar-parallel
pbar-parallelPBar parallel is a simple wrapper around joblib, that shows you how many jobs
have been processed in a simple progress by.Installpip install pbar-parallelUsagefrompbar_parallelimportPBarParallel,delayeddeffunc(x):returnx**2prl=PBarParallel(n_jobs=48)result=prl(total=1000)(delayed(func)(i)foriinrange(1000))
Package: pbar-pool
pbar-poolA straightforward, dependency free way to update multiple progress bars with python's multiprocessing library.Specifically designed to work with multiprocessing.Pool - for which I found all other available solutions to be either overcomplicated, or completely broken.Installation:pipinstallpbar-poolUsage:frommultiprocessingimportPool,cpu_countfrompbar_poolimportPbarPool,Pbarimporttime,randomdeffn(x):for_inPbar(x,manager=pbars,name=f'Process{pbars.id()}',color=(255,0,0)):time.sleep(random.randint(0,3))to_process=[list(range(10))for_inrange(100)]pbars=PbarPool(width=100)withPool(processes=cpu_count(),initializer=pbars.initializer())asp:global_pbar=Pbar(p.imap_unordered(fn,to_process),manager=pbars,name='global',total=len(to_process))for_inglobal_pbar:pass-->global: 56/100 ████████████████████████████████████████████████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 56% 3.9156s/it 02:52 remaining
 Process 4: 5/10 ██████████████████████████████████████████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 50% 1.4075s/it 00:07 remaining
 Process 2: 2/10 ████████████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 20% 1.5064s/it 00:12 remaining
 Process 3: 0/10 ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0% 
 Process 1: 1/10 ██████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 10% 0.0003s/it 00:00 remainingit's as simple as adding theinitializer=pbars.initializer()option to your Pool object to give each Pool process access to the global progress bars pool.Then, in each process, wrap your iterator in aPbar()object, passing in the global PbarPool object as themanagerargument.You can also add a global progress bar to track the progress of the outer function, as seen in the example above.
Package: pbat
AboutPbat is batch file preprocessor developed to enchance functions syntax, add macro definitions and refine control flow of batch scripts.Pbat file (script.pbat) compiles to bat script (script.bat) and consists of function definitions (code blocks) and order of execution. Pbat must at least have one function namedmain.Functions introduced bydefkeyword (seeexamples/hello1.pbat).By default flow of execution is static which means there are no stack and each function either always jumps to specific function or always exits (conditional statement can change this flow like shortcut, yet it is still static). Next function can be defined bythenclause in function definition (seeexamples/hello2.pbat), or byorderstatement somewhere in the file (seeexamples/hello3.pbat).Most important feature is macros likedownload,unziporgit_clone(seeexamples/hello4.pbatandexamples/hello5.pbat).You can add function to execution flow usingdepends onkeyword (seeexamples/hello4.pbat). Notice that order is defined likemain fetchbut actulal order ismain tool_curl fetchsincefetchdepens ontool_curl.You can jump to begin of the functionfuncnameusinggoto funcname_beginor to the end of the function usinggoto funcname_end(seeexamples/hello6.pbat).%~dp0is handy - it's directory of current script. Usepushdandpopdinstead ofcd.Comments starts with#Installpython -m pip install pbatCompile scriptspython -m pbat.compile examplesorpbat examplesWatch and compileYou can useeventloopto triggerpbaton filechangeonchange path\to\dir -i *.pbat -- pbat FILEonchange path\to\file -- pbat FILE
Package: pb-bss-eval
Blind Source Separation (BSS) algorithmsFork note: The original repo has been modified to allow a partial
release of the evaluation utilities on PyPI under the namepb_bss_eval. All the credits goes to the original authors
(seehere).As can be seen in theManifest.in, only the
evaluation sub-package can be installed and is released on PyPI.
To install it, just run :pip install numpy Cython  # required for pesq install
pip install pb_bss_evalThis repository covers EM algorithms to separate speech sources in
multi-channel recordings.In particular, the repository contains methods to integrate
Deep Clustering (a neural network-based source separation algorithm)
with a probabilistic spatial mixture model as proposed in the Interspeech paper "Tight integration of spatial and spectral features for BSS with Deep Clustering embeddings" presented at Interspeech 2017 in Stockholm.@InProceedings{Drude2017DeepClusteringIntegration,Title={Tight integration of spatial and spectral features for {BSS} with Deep Clustering embeddings},Author={Drude, Lukas and and Haeb-Umbach, Reinhold},Booktitle={INTERSPEECH 2017, Stockholm, Sweden},Year={2017},Month={Aug}}InstallationInstall it directly from sourcegitclonehttps://github.com/fgnt/pb_bss.gitcdpb_bss
pipinstall--editable.We expect thatnumpy,scipyandcythonare installed (e.g.conda install numpy scipy cythonorpip install numpy scipy cython).The default option is to install only the necessary dependencies.
When you want to run the tests or execute the notebooks, use the one of the following commands for the installation:pipinstall--editable.[all]# Without a whitespace between `.` and `[all]`pipinstallgit+https://github.com/fgnt/pb_bss.git#egg=pb_bss[all]
Package: pbc
ProtonBeamComposerOverviewdocstestspackageTODOInstallationStable versionpip install pbcLatest unstable version, directly GIT repository, using:pip install setuptools versioneer
pip install git+https://github.com/DataMedSci/ProtonBeamComposer.gitTo unistall, simply use:pip uninstall beprofDocumentationhttps://ProtonBeamComposer.readthedocs.io/FeaturesTODOCreditsThis package was created withCookiecutterand thegrzanka/cookiecutter-pip-docker-versioneerproject template.
Package: pbcluster
PBClusterFree software: MIT licenseDocumentation:https://pbcluster.readthedocs.io.This packages makes it easier to analyze particle clusters in boxes with
periodic boundaries.
For example, take a look at this simulation box:All these particles belong to a single cluster, but because particles jump to
the other side of the box when the cross one of the box faces (like in the
classicAsteroids game),
the cluster appears split into 2 clusters plus a lone particle.
This jumping/wrapping behavior is often called a Periodic Boundary Condition
(PBC).
Typical clustering packages make it difficult or impossible to account for PBCs,
and might classify these particles as belonging to 3 separate clusters.
PBCluster handles periodic boundary conditions, and allows you to calculate
several particle and cluster properties.
Here are some available properties:Cluster Propertiesn_particles: number of particles in a clusterminimum_node_cuts: the number of particles you’d need to remove to
break all paths through connected particles from any face to its opposing face.rg: the radius of gyration of a clusterasphericity: a measure of the elongation of the clusterParticle Propertiescoordination_number: the number of neighboring particles connected to
a given particleBond Propertiesbonds_df: a dataframe of particle-particle “bonds” (neighbors within the
cutoff distance of each otherbond_durations_df: a dataframe with data about how long particle pairs
were in contactYou can install this withpip install pbcluster.
For more details check out theInstallationpage of the docs.For an example showing how to use PBCluster, check out theExamplepage of
the docs.CreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2019-04-28)First release on PyPI.
Package: pbfaw
PBFAW: The Python BotForum API Wrapper forked from PRAWPBFAW, an acronym for “Python BotForum API Wrapper”, is a Python package that allows forsimple access to Botforum’s API. PRAW aims to be easy to use and internally follows all ofBotforum’s API rules. With PBFAW there’s noneed to introducesleepcalls in your code. Give your client an appropriate useragent and you’re set.
Package: pbga
PBGAPacBio Genome Analysis Python toolkit.InstallThe code is available at PyPi, therefore you can install it with pip.pipinstallpbgaConnect to PBGA databaseThe PBGA database is a H2 database, therefore primarily meant to be used with Java.
We can connect to the database from Python, if:Java is installed on the local machinethe local machine runs UNIX-like OS (sorry, Windows users)Then:frompbgaimportH2DbManagerwithH2DbManager("path/to/sv_database.mv.db",user="sa",password="sa")ash2:withh2.get_connection()asconn:withconn.cursor()ascur:# do whatever you wantcur.execute('SELECT * FROM PBGA.CLINGEN_TRIPLOSENSITIVITY;')fori,xinzip(range(5),cur.fetchall()):# print first 5 linesprint(x)Use JannovarVariantEffectsWe can access values of JannovarVariantEffectenum:importpbga.effectsaspeve=pe.VARIANT_EFFECTS#  get tuple with all variant effectsp=pe.get_priority('MISSENSE_VARIANT')# returns 21Quick setup of PythonloggingframeworkSetting up of Pythonloggingframework might be tedious. Here's a small helper function:frompbga.utilsimportsetup_logging# set level to INFO, create a `main.log` file use nice log message formatsetup_logging()Limitationstested withpython>=3.6.8
Package: pbgca
PBGCA -  Physically based galaxy clustering algorithmAgglomenative clustering algorithm for galaxy clusters considering physical form of galaxy's structuresClustering algoritm's initial purpose of which was to solve galaxy clustering task. But it can be scaled to solve simillar problem of finding clusters elongated to center of coordinates grid in N-dimentional gridInstallationpip install pbgcaGet startedHow to multiply one number by another with this lib:frompbgcaimportClustererasPBGCA#Get your datadata=pd.read_csv('some_data.csv')# Instantiate a PBGCA objectclusterer=PBGCA()# Call fit methodclusterer.fit(data)# Get result of clusteringresult=clusterer.labels_Input Example:
3d coordinates of galaxies in form of np matrix or pandas dataframe (here units: Mpc)
Example:xyz1340.45-194-0.322........
Package: pbi-load-test
pbi-load-testPython package and CLI application to measure Power BI reports loading capacity, using different filters and parameters.It simulates a realistic set of user actions such as changing slicers, filters (soon), bookmarks (soon)[Prerequisites](#prerequisites) | [Installation](#installation) |  [Configuration](#configuration) | [Example](#example)PrerequisitesIt requires and Azure AD login method. Ensure you haveAzure CLIinstalled locally and authentificate (az login) in order to generate a token easily. Soon:[!NOTE]Soon: the package will open a Window to authentificate if the Azure login has not be installedSoon: the package will be able to load Service Principal to to the test (Tenant ID, Client ID and Client Secret)This package is based onSeleniumpython package. It will open a Chromium window to launch the test. In any case, it may require the Chromium driver locally. The latest versions for each OS can be foundhere.InstallationWithpip$ pip install pbi-load-testAnd to test the installation$ pbi-load-test --version
0.1.1a1withpoetry$ poetry add pbi-load-testAnd to test the installation$ poetry run pbi-load-test --version
0.1.1a1ConfigurationThe load test is configurated through aconfig.yamlfile which should be located in the current working directory.# authentification: oauthworkspace:...# PBI Workspace Namereport:...# Report namepage:...# Page nameslicers:-table:...# Table name from dataset which contains the column to filter oncolumn:...# The column name containing the values to filter onvalues:-...# The value to filter on-...[!NOTE]
For the moment, onlyslicersare usable to filter on. Later,filterswill be available.
Also, one slicer can be used in this first version. In the future, the tool will be able to iterate between slicers list and create combinations between slicer and filter values.ExampleIt ensures that aconfig.yamlfile exists in the current working directory[!NOTE]The package will in the future be able to parseconfig.yamlfile from different project through the CLI application.❯ poetry run pbi-load-test run

CORE - MARKETING [DEV]
SFE Country Dashboard TMDL
Activity Field Days
Workspace ID: 310d9fbb-1474-4939-bcb8-669a536ec959
Report ID: c89485c6-e0c3-4715-a710-ddd450491a9a
groups/310d9fbb-1474-4939-bcb8-669a536ec959/reports/c89485c6-e0c3-4715-a710-ddd450491a9a/pages
Page ID: ReportSectioncbd8077dfb6a167ccb5e
Duration: 30.085
Press Enter to continue...After the test, all created files will be removed.
Package: pbio
Module for writing/reading binary files being continuously written to disk.
Designed for supporting scihi.Usage:scio.append(arr,filename,[overwrite=False])
write the array arr to the end of file filename.  If overwrite is
True, then erase what's there and start fresh.Routine doesnotcheck that dtype/size of succeeding arrays matches
what's already in the file.arr=scio.read(filename)
return as a numpy array of the same dtype the set of arrays written.Currently supported dtypes are int32, int64, uint32, uint64, float32, and float64.
Package: pbiotools
pbiotoolsThepbiotoolspackage provides miscellaneous bioinformatics and other utilities for Python 3. It is required for the installation ofRp-Bp.InstallationIf required, set up the conda channels as describedhere, and install withconda install pbiotoolsThe package is also available onPyPI.You can also get a container withpbiotoolspre-installed# docker or...
docker pull quay.io/biocontainers/pbiotools:<tag>
# ... singularity
singularity pull pbiotools.sif docker://quay.io/biocontainers/pbiotools:<tag>There is nolatesttag, you need to specify the version tag. Seepbiotools/tagsfor valid values for<tag>.DocumentationThere is currently limiteddocumentation.How to report issuesBugs and issues should be reported in thebug tracker. Follow the instructions and guidelines given in the template.
Package: pbite
PBitelsfor project metadata.Usepbto display project metadata contents from your file system.pb on  master is 📦 v0.1.0 via 🐍 v3.11.3 
❯ pb .
Content
  Name: pb
  Version: 0.1.0
  Description: `ls` for project metadata
  Source: /Users/chrispryer/github/pb/pyproject.tomlInstallationpip install pbiteYou can addpbto anyvenvwithpython -m venv .venv
./.venv/bin/pip install pbiteIt's recommended to installpbusing a package manager likerye.rye install pbite
pb --version
Package: pbi-tools
PBI Tools is an object-orientated Python library that makes working with Power BI files easier.Alpha WarningThis library is currently inalpha.
Use with caution and feel free to raise any issues on the [GitHub page](https://github.com/thomas-daughters/pbi-tools/issues).DocumentationFull documentation can be found on [Read the Docs](https://pbi-tools.readthedocs.io).LicenseIt is made available under the [MIT license](https://raw.github.com/thomas-daughters/pbi-tools/main/LICENSE).
Package: pbj
Python Build JellyNewjust added zsh completion! found in the filezsh.sugarAnyway, PBJ is a simple, extensible pythonic build framework, whose purpose is to be dead simple for the basic cases.Here’s an example:from pbj import Builder, cmd
import os

build = Builder("PJs")

build.cmd("jstest", ("js", "test/runtests.js"))
build.clean("build", "test/py/*.js")

@build.file("build/pjslib.js", depends="jslib/*.js")
def jslib(name):
    text = cmd("cat", "jslib/*.js")
    if not os.path.exists("build"):
        os.mkdir("build")
    open("build/pjslib.js").write(text)

if __name__ == "__main__":
    build.run()Cool things: targets are classes, and decorate functions.And…this project is just starting out, so I’ll fill the rest in later.Included:disttest - a drop-in plugin to add a “setup.py test” for distutilsCheers.
Package: pbjam
Peakbagging made easyPBjam is toolbox for modeling the oscillation spectra of solar-like oscillators. This involves two main parts: identifying a set of modes of interest, and accurately modeling those modes to measure their frequencies.Currently, the mode identification is based on fitting the asymptotic relation to the l=2,0 pairs, relying on the cumulative sum of prior knowledge gained from NASA’s Kepler mission to inform the fitting process.Modeling the modes, or ‘peakbagging’, is done using the HMC sampler frompymc3, which fits a Lorentzian to each of the identified modes, with much fewer priors than during he mode ID process. This allows for a more accurate model of the spectrum of frequencies, than the heavily parameterized models like the asymptotic relation.Read the docs atpbjam.readthedocs.io.ContributingIf you want to raise and issue or contribute code to PBjam, see theguidelines on contributing.AuthorsThere are different ways to contribute to PBjam, the Scientific Influencers help guide the scientific aspects of PBjam, the Chaos Engineers try to break the code or simply report bugs, while the Main Contributors submit Pull Requests with somewhat bigger additions to the code or documentation.Main ContributorsChaos EngineersScientific InfluencersLindsey CarboneauWarrick BallOthman BenomarGuy DaviesRafa GarciaBill ChaplinOliver HallTanda LiEnrico CorsaroAlex LyttleJoel OngPatrick GaulmeMartin NielsenMikkel LundBenoit MosserAndy MoyaIan RoxburghAcknowledgementsIf you use PBjam in your work please cite the PBjam paper (forthcoming), and if possible provide links to the GitHub repository.We encourage PBjam users to also cite the packages and publications that PBjam makes use of. PBjam will automatically keep track of the publications that were used during a run, and can list them for you in bibtex format (see theReferencing Notebook).
Package: pb_job_manager
Fire and forget Multiple Commandsimport plumbum as pb
from pb_job_manager import PBJobManager
pbjm = PBJobManager(max_procs=4)
pbjm.add_job(pb.cmd.grep["foo", "input.txt"] | pb.cmd.sort > "foo.txt")
pbjm.add_job(pb.cmd.grep["bar", "input.txt"] | pb.cmd.sort > "bar.txt")
pbjm.add_job(pb.cmd.grep["baz", "input.txt"] | pb.cmd.sort > "baz.txt")
pbjb.run()   # run until all jobs are finishedCreating Jobs with Callbacks::TODO: ExampleJobs with dependencies::TODO: ExampleResult Iteration::TODO: Example
Package: pbkdf2-ctypes
A pbkdf2 implementation for python using ctypes.This module implements pbkdf2 for Python using C libraries available on the system (OpenSSL-1+ or CommonCrypto).Note: This module is intended as a plugin replacement of pbkdf2.py (https://github.com/mitsuhiko/python-pbkdf2)
by Armin Ronacher.  There is no need to compile it so it should be usable on any system where OpenSSL 1.0.0+ or CommonCrypto (OS X)
is installed.Why?The above stlib based implementation, although excellent, was worsening web2py (http://web2py.com) performance much more than needed
for doing just password hashing. After pondering different options, it was considered that there
would have been a good chance that a system with python shipping hashlib module, could also have OpenSSL installed
for dependency reasons.
The result is that using this module PKCS5 PBKDF2 hashing can be more than 20x times faster than using Armin’s stdlib
implementation.Copyright :copyright: 2013: Michele Comitini
License LGPLv3CHANGELOG[2018-06-15]v0.99.5: Fix PyPi missing release files.[2013-09-24]v0.99.4: better support for python2.5.  Comply to PATH on Windows.
Better OS detection on OS X.[2013-08-17]v0.99.3: fixed main().  Prepended “_” to internal functions.v0.99.2: added support for python3[2013-08-16]preparing 0.99.1 to fix problems with pypi[2013-08-14]added tests.py and prepared for distutils.[2013-08-08]Update README.md[2013-08-05][2013-07-31]fixed OS X compatibility, should work also on iOS.  Added arg type checks and conversions.[2013-07-29]added support for common crypto hence hopefully OS X[2013-07-28]missing () around exceptionspep8now uses ctypes magic to find libraryadded moduleadded moduleUpdate README.mdInitial commit