Saravanan666/pypi-org huggingface dataset:
Package: peamt
PEAMTThis package contains code to run PEAMT, a Perceptual Evaluation metric for Automatic Music Transcription.
If you use any of this, please cite:Adrien Ycart, Lele Liu, Emmanouil Benetos and Marcus Pearce, 2020."Investigating the Perceptual Validity of Evaluation Metrics for Automatic Piano Music Transcription",Transactions of the International Society for Music Information Retrieval (TISMIR), 3(1), pp.68–81.@article{ycart2019PEAMT,
       Author = {Ycart, Adrien and Liu, Lele and Benetos, Emmanouil and Pearce, Marcus},
       Booktitle = {Transactions of the International Society for Music Information Retrieval (TISMIR)},
       Title = {Investigating the Perceptual Validity of Evaluation Metrics for Automatic Piano Music Transcription},
       Year = {2020},
       Volume = {3},
       Issue = {1},
       Pages = {68--81},
       DOI = {http://doi.org/10.5334/tismir.57},
    }For more info, please visit:https://github.com/adrienycart/PEAMT
Package: pe-analyzer
PEAnalyzerA Python module to analyze Portable Executable (PE) files on Windows systems. It parses and extracts various details about the file header, optional header, sections, imports, and exports. The module provides an easy-to-use class,PEAnalyzer, which returns analysis data in JSON format and supports pretty-printing of the information when used with theprint()function.InfoPackageCI/CDSupportInstallationTo use PEAnalyzer, first, install thepefilelibrary by running:pip install pefileThen, download or clone this repository to your project directory.UsageTo use thePEAnalyzerclass, import it from the module and create an instance with the path to the PE file you want to analyze:frompe_analyzerimportPEAnalyzerfile_path="path/to/your/file.exe"analyzer=PEAnalyzer(file_path)To print the analysis data in a human-readable format, use theprint()function:print(analyzer)To get the analysis data as a JSON object, call theanalyze()method:analysis_data=analyzer.analyze()print(analysis_data)SupportYou can create a new issue here:Or join my Discord server here:LicenseThis project is licensed under the MIT License. See theLICENSEfile for more information.
Package: pear-cli
pearA utility for generating variations source code for docmentation.In documentation you might want to show the growth of a file over time. However, if you want to keep only one copy of the source code. Consider the following file:classFoo:def__init__(self,name):self.name=namedefreverse_name(self):returnself.name.reverse()If we can to incrementally build the file, we might write the constructor first andreverse_namesecond. That means we would want two versions of the file:classFoo:def__init__(self,name):self.name=nameclassFoo:# constructordefreverse_name(self):returnself.name.reverse()Usingpearyou can accomplush this.UsageInclude apear.jsonfile in your root directory with the necessary configurations. For our above example, we would have:{"out":"out","files":[{"path":"foo.py","tag":"without_reverse_name","layers":[{"type":"remove","start":4,"end":6}]},{"path":"foo.py","tag":"constructor_comment","layers":[{"type":"replace","start":2,"end":3,"replacement":["    # constructor"]}]}]}Then callpearfrom the same directory. This will generatefoo.py_without_reverse_nameandfoo.py_constructor_commentfiles inout/.
Package: pearldiver
.. figure:: https://i.imgur.com/6SdlHMw.jpg:alt: Photo by GEORGE DESIPRIS from Pexelshttps://www.pexels.com/photo/man-in-santa-claus-costume-with-diving-gear-inside-aquarium-731141/Photo by GEORGE DESIPRIS from Pexelshttps://www.pexels.com/photo/man-in-santa-claus-costume-with-diving-gear-inside-aquarium-731141/IOTA-PearlDiver===============IOTA transaction nonce searcher python implementHow to use==========Clone this repository and use ``pipenv install``, ``pipenv shell``.TODO====Why the hell pypy is slower than CPython? And why the hell you depend onnumpy?
Package: pearlib
PearAnd neural networks appearPear is a library that aims at offering a visual representation of neural networks. It can read networks built using Google's TensorFlow in and, for each requested layer, draw the associated decision boundaries.Pear is still in the development process.Installing Pear will also install the following packages (if they are not already installed on your system): numpy, Pillow, matplotlib, tensorflow, webcolors.To use, do::>>> import pearlibPear is not yet able to work will all types of network: only networks with 2 inputs and 1 output are accepted so far. Moreover, to simplify the parameters extraction, the input networks must follow the following naming convention:- All weight matrices should be named "W" followed by the number of the layer they belong to. Example: the weight matrix of the first layer will be called "W1".- All bias vectors should be named "b" followed by the number of the layer they belong to. Example: the bias vector of the first layer will be called "b1".Example networks for Lena, with different numbers of parameters are available in the "example" folder, as well as an example running file "example.py" showing how to use Pear to visualize your network.Ap'Pear, a graphical user interface for Pear is available for download here: https://lc.cx/gPgPTo start it, unzip the file and do in your command terminal::>>> python3 main.pyExample networks for Lena, with different numbers of parameters, as well as an example file example.py are available in example.zip, downloadable at: https://lc.cx/gPgP
Package: pearpy
PearpyThe Python package for (pear)allelizing your tasks across multiple CPU threads.InstallationThe latest version of Pearpy can be installed with:pip install pearpyTo stay up to date with Pearpy's releases, visit theofficial pageon PyPi!UsageCreate aPear()object. This will be a wrapper for all of your multithreaded processes.Identify the functions on which you would like to paralleilze computation.Add your tasks to the Pear object. If a potential race condition is detected, an error will be thrown.Run the paraellelized processes.Examplefrom pearpy.pear import Pear

# First function to be parallelized
def t1(num1, num2):
    print('t1: ', num1 + num2)

# Second function to be paralellized
def t2(num):
    print('t2: ', num)

# Create pear object, add threads, and run
pear = Pear()
pear.add_thread(t1, [4, 5])
pear.add_thread(t2, 4)
pear.run()Race Condition HandlingWhen multiple threads utilize the same function, Pear will automatically generate locks for each resource. This allows developers to utilize Pear's multithreading without having to worry about inaccurate data caused by race conditions. The following example shows how race conditions are handled:from pearpy.pear import Pear

global_var = 10

# This function reads from and writes to a global variable
def t_duplicated(num):
    global global_var
    print('t_duplicated: ', num + global_var)
    global_var += 1

# Pear object created with two threads accessing a shared resource
# A race condition is detected and locks are generated
pear = Pear()
pear.add_thread(t_duplicated, 1) # This should return 11 because 1 + 10 = 11
pear.add_thread(t_duplicated, 1) # This should return 12 because global_var is incremented
pear.run()

##########
# OUTPUT #
##########
t_duplicated: 11
t_duplicated: 12Benchmarks and TestsBenchmarks can be examined via themake benchmarkcommand. This will display the threaded vs unthreaded runtimes on a set script, along with the percent improvement between the two. Here is an example of what the benchmarks should look like:----------------------------------------------------------------------
THREADED BENCHMARK
3.8507602214813232 s
----------------------------------------------------------------------
UNTHREADED BENCHMARK
13.90523624420166 s
----------------------------------------------------------------------
Improvement:  361.1036638072611 %
.
----------------------------------------------------------------------
Ran 1 test in 17.757s

OKTo run tests, utilize themake testcommand. This will output the results of the functions called in the/tests/test_pear.pyscript, along with the status of the tests themselves. The console will display 'OK' if the tests are passing.ContributingPear is open source and contributions from anyone are welcome. To contribute to this project, please submit issues and pull requests via GitHub. In order to successfully merge a pull request, all unit tests must be passed when run viamake test. Thank you!
Package: pearsend
PearSendA simple CLI client for peer-to-peer file or message sending. Written in
Python.FeaturesIt supports file or message of size upto about 8.85 PeB (1 PiB ~ 10^6
GiB)!.Protection against transmission error usingCRC32checksum.Comes with CLI (command-line argument) and Interactive mode, both!InstallationInstall it usingpippip install pearsendUsage ExamplesCommand-line ModeHelp Textsumit@HAL9000:~/Documents/PearSend$python3pearsend.py-husage: pearsend.py [-h] [-i] [-f FILEPATH] [--host HOST] [-p PORT]
                   [-m MESSAGE]
                   {send,receive}

positional arguments:
  {send,receive}        Whether to send or receive

optional arguments:
  -h, --help            show this help message and exit
  -i, --interactive     If the program is to be run in interactive mode
  -f FILEPATH, --filepath FILEPATH
                        Path of the file to be sent or to save incoming data
                        to
  --host HOST           Address of the source or target machine
  -p PORT, --port PORT  Port for listening on or sending to
  -m MESSAGE, --message MESSAGE
                        Message to sendSending text messageReceiversumit@HAL9000:~/Documents/PearSend$python3pearsend.pyreceive-p5000[*] Listening for connections on: 10.194.52.135:5000

[*] Connection from : 10.194.52.135:47804
[*] The incoming data is >
b'Hello HAL!'Sendersumit@HAL9000:~/Documents/PearSend$python3pearsend.pysend--host10.194.52.135-m"Hello HAL!"[*] Sent message succesfully!Sending binary fileReceiversumit@HAL9000:~/Documents/PearSend$python3pearsend.pyreceive-p5000-frecd.png[*] Listening for connections on: 10.194.52.135:5000

[*] Connection from : 10.194.52.135:47808
[*] Incoming data saved to recd.pngSendersumit@HAL9000:~/Documents/PearSend$python3pearsend.pysend--host10.194.52.135-fimage.png[*] Sent message succesfully!Interactive ModeSending text messageReceiversumit@HAL9000:~/Documents/PearSend$python3pearsend.pyreceive-i[?] Port to listen on:
[?] File to save the incoming data to. Leave blank to output to terminal:
[*] Listening for connections on: 10.194.52.135:5000

[*] Connection from : 10.194.52.135:36240
[*] The incoming data is >
b'Hello HAL!'Sendersumit@HAL9000:~/Documents/PearSend$python3pearsend.pysend-i[?] The address of the target machine: 10.194.52.135
[?] Enter the port to connect to:
[?] The file to send. Leave blank for text message:
[?] Enter the message: Hello HAL!

[*] Sent message succesfully!Sending binary fileReceiversumit@HAL9000:~/Documents/PearSend$python3pearsend.pyreceive-i[?] Port to listen on:
[?] File to save the incoming data to. Leave blank to output to terminal: recd.jpg
[*] Listening for connections on: 10.194.52.135:5000

[*] Connection from : 10.194.52.135:36242
[*] Incoming data saved to recd.jpgSendersumit@HAL9000:~/Documents/PearSend$python3pearsend.pysend-i[?] The address of the target machine: 10.194.52.135
[?] Enter the port to connect to:
[?] The file to send. Leave blank for text message: image.jpg

[*] Sent message succesfully!
Package: pearson-pdf
pearson-pdfTool to download Pearson books as PDFs.InstallationInstallpearson-pdfusing pip.pipinstallpearson-pdfUsageTo download a PDF, you'll need to get the book's ID:Open up DevTools in your browser.Navigate to Console.Type in:window.foxitAssetURL;Copy that URL.Download your URL as a PDF tooutput.pdfusing pearson-pdf:pearson-pdfhttps://example.com/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/foxit-assetsoutput.pdfMore information on usage is in the help page:pearson-pdf-hLicenseSeeLICENSEfor details.
Package: pearsonr
Pearsonr Pure PythonOverviewThis library provides a pure python implementation ofscipy.stats.pearsonr. Only consider using if you require
this function in an environment that doesn't include prebuilt wheel files on pypi such as alpine linux.WarningUse with caution as it may not be an exact match the function. For example in small sample sizes under 3 data points,
the original and ported functions differ in the result significance value.Linksscipyblog
Package: pears-orchard
Orchard PeARSWhat and whyPeARS (version Orchard) is a search engine that you can install and run locally from your browser. It allows you to 'index' pages (i.e. to produce a computer-readable representation of the pages' content, essential to the search process), and to search pages that you or your friends have indexed. Search happens entirely on your machine, meaning that no one knows what you are searching and when.One feature of PeARS Orchard is the ability to convert a small index into a greyish, unassuming picture, called a 'snow pod'. Snow pods are the mini-weapons of the indexing revolution. They can easily be shared with others by email, on social media, or through any other means, so you can be your very own search engine, for yourself and for your friends.How does this fit with peer-to-peer PeARS?The fully-fledged PeARS system (Peer-to-peer Agent for Reciprocated Search) is supposed to be completely distributed. You can imagine it as an 'automated' version of Phase 1, where you don't have to go and hunt for pods yourself. Your PeARS install will automatically find them on other users' systems and connect to them. We are still working on this phase of the project.UsageNB: we have some instructions for Windows userson the wiki.1. Clone this repo on your machine:git clone https://github.com/PeARSearch/PeARS-orchard.git2.Optional stepSetup a virtualenv in your directory.If you haven't yet set up virtualenv on your machine, please install it via pip:sudo apt-get update

sudo apt-get install python3-setuptools

sudo apt-get install python3-pip

sudo pip3 install virtualenvThen run:virtualenv -p python3 env && source env/bin/activateThen change into the PeARS-orchard directory:cd PeARS-orchard3. Install the build dependencies:pip3 install -r requirements.txt4. Unpack the semantic spaceHead over to the app/static/spaces directory and unzip english.dm.zip.cd app/static/spaces

unzip english.dm.zip5. Run it!In the root of the repo, run:python3 run.pyNow, go to your browser at localhost:8080. You should see the search page for PeARS. You don't have any pages indexed yet, so go to the F.A.Q. page (link at the top of the page) and follow the short instructions to get you going!
Package: peartree
peartree is a library for convertingGTFSfeed schedules into a representative directed network graph. The tool usesPartridgeto convert the target operator schedule data intoPandasdataframes and thenNetworkXto hold the manipulated schedule data as a directed multigraph.Above, an example of multiple Bay Area transit operators being incrementally loaded into peartree.Installationpip install peartreeUsageSee a full notebook atthis gistto see a simple, step-by-step iPython Notebook pulling in an AC Transit GTFS feed and converting it to a NetworkX graph.importpeartreeasptpath='path/to/actransit_gtfs.zip'# Automatically identify the busiest day and# read that in as a Partidge feedfeed=pt.get_representative_feed(path)# Set a target time period to# use to summarize impedancestart=7*60*60# 7:00 AMend=10*60*60# 10:00 AM# Converts feed subset into a directed# network multigraphG=pt.load_feed_as_graph(feed,start,end)ExamplesI’ve yet to produce a full how-to guide for this library, but will begin to populate this section with any blog posts or notebooks that I or others produce, that include workflows using peartree.Calculating betweeness centrality with Brooklyn bus networkCombining a peartree transit network and an OpenStreetMap walk networkGenerating comparative acyclic route graphsCoalescing transit network graphs and spectral clustering methodsExploratory graph analysis with betweenness and load centrality
Package: pearun
PearunA simple utility to run user defined commands.Inspired by scripts in package.json of npm based projects.Install packagepip install pearunUsageUser commands are parsed from Pearunfile which contains simple json dictionary.It is possible to run inline shell commands or execute whole script files.With your Pearunfile ready, you can list your commands by:pearun -lorpearun --listOr with-f/--fileargument when your Pearunfile is not in your CWD:pearun -f <path_to_Pearunfile>orpearun --file <path_to_Pearunfile>To execute your command, simply type its name as an argument:pearun hello_worldYou can also append custom command line arguments after the command name:pearun script:default my_custom_argsPearunfile example{
    "hello_world": "echo \"Hello World!\"",
    "script:default": "./script.sh",
    "script:with_arg": "./script.sh some_arg",
    "boolean": "echo \"TRUE/FALSE\"",
    "pyth": "python -c \"print(1 + 1)\""
}Seeexamples/folder to try this Pearunfile.
Package: pear-xai
:pear: PEAR: Post-hoc Explainer Agreement RegularizationA repo for training neural networks for post hoc explainer agreement. More details about the results can be found in our paper titledReckoning with the Disagreement Problem: Explanation Consensus as a Training Objective.Getting StartedIf you are intersted in using the :pear: PEAR package to train your own models, you can install the package through pip.$ pip install pear-xaiYou should then be able to run an example in a python interpreter:$ python
>>> import pear
>>> pear.run_example()If you are interested in cloning this repository and reproducing or building on our experiments, you can install the requirements manually as follows. (This code was developed and tested with Python 3.9.5)After downloading the repository (or cloning it), install the requirements:$ pip install -r requirements.txtYou can then open and run the Jupyter Notebooktutorialson reproducing our results.ContributingWe believe in open-source community driven software development. Please open issues and pull requests with any questions or improvements you have.Citing Our WorkTo cite our work, please reference the paper linked above with the following citation.@article{schwarzschild2023reckoning,
  title={Reckoning with the Disagreement Problem: Explanation Consensus as a Training Objective},
  author={Schwarzschild, Avi and Cembalest, Max and Rao, Karthik and Hines, Keegan and Dickerson, John},
  journal={arXiv preprint arXiv:2303.13299},
  year={2023}
}
Package: peasant
Candango PeasantPeasant is a protocol abstraction of how to control agents that need to
communicate with a central entity or entities.We define agents as peasants and central entities(bases) as bastions.This project won't define the implementation, security level neither levels of
redundancies but instead a minimal contract of what should be implemented.A bastion/peasant relationship could be defined as stateful or not. If stateful
it is necessary to implement a session control in the bastion where peasants
need to perform knocks(as knock at the door) in order to get permission or a
valid session. In a stateless case we just ignore any knock implementation.What must be implemented in the protocol are nonce generation, consumption and
validation on both sides and a directory list of available resources offered by
a bastion for peasants to consume.SupportAutomatoes is one ofCandango Open Source Groupinitiatives. Available under theApache License, Version 2.0.This web site and all documentation is licensed underCreative Commons 3.0.Copyright © 2020 Flavio Goncalves Garcia
Package: peasy
Parsing is easy!With Peasy, you write the parser by hand, just like to write any other kind of program.
You need not play many balls like that any more <https://raw.github.com/chaosim/peasy/master/doc/ballacrobatics.jpg>
You just play one ball like so <https://raw.github.com/chaosim/peasy/master/doc/dolphinball.jpg>.To use Peasy, just copy the module to your project, read it, modify it, write the grammar rules,, and remove any unnecessary
stuffs in Peasy, and parse with the grammar.
See here <http://chaosim.github.io/peasy/doc/pypeasy.html#peasysample>. for a sample grammar in Peasy.DocumentationThe annotated peasy.py<http://chaosim.github.io/peasy/doc/pypeasy.html>. is best document for Peasy at the moment.
See the tests in /test, and you’ll see some samples of left recursive grammars and how to parse them.Web sitesthe project’s repository is on github <https://github.com/chaosim/peasy>.TestingPeasy uses the nose test framework, see the folder “test”Bug reportsTo report or search for bugs, please goto <https://github.com/chaosim/peasy/issues>, or email tosimeon.chaos@gmail.comPlatform notespeasy is developed and tested on Windows 7, python 2.7.3LicenseMIT: see LICENSE
Package: peasywidgets
PeasyWidgetsTable of ContentsInstallationLicenseStylingInstallationpip install peasywidgetsAddpeasywidgetsto DjangoINSTALLED_APPSImport the desired widgetsfrompeasywidgets.datalist_widgetsimportDatalistMultiple,DatalistSinglefrompeasywidgets.filter_widgetsimportChoiceFilterMultiple,ChoiceFilterSingleRuncollectstaticand include the JavaScript in templates `{%  static 'peasywidgets.js' %}``StylingThe following default CSS is available to use with Django'sstatictemplate tag, otherwise use these selectors to write custom CSS/Tailwind directives.Licensepeasywidgetsis distributed under the terms of theMITlicense.
Package: peatio_client
a client library for the bitcoin exchange Peatio
—
[![Build Status](https://travis-ci.org/czheo/peatio-client-python.svg?branch=master)](https://travis-ci.org/czheo/peatio-client-python)This library is inspired by [peatio-client-ruby](https://github.com/peatio/peatio-client-ruby)# Install` pip install peatio_client `# Usage
- Rest API Client:https://github.com/czheo/peatio-client-python/blob/master/client_sample.py- Streaming API Client:https://github.com/czheo/peatio-client-python/blob/master/streaming_client_sample.py# Licence
LGPL
Package: pebba
Over-representation analysis (ORA) is a critical technique to determine if a set of differentially expressed genes (DEGs) is enriched with genes from specific gene sets or pathways. However, the cut-off used to define the number of DEGs that are utilised significantly impacts ORA results. To overcome the arbitrary choice of a cut-off and identify cut-off-independent enriched pathways, we developed PEBBA. This user-friendly tool ranks genes based on their statistical and biological significance and then systematically performs ORA for different cut-offs. There is no need to shortlist genes or waste time fine-tuning parameters. By simplifying ORA, PEBBA can be employed to lighten users’ burdens concerning parameter choice and decrease false positives. By visually exploring the parameter space, users can draw more precise conclusions about their dataset.InstallPEBBA may be installed through pip:pip install pebba.
Alternatively, PEBBA is also available as an online tool atpebba.sysbio.toolsUsing pebbaOnce installed, pebba can be used as a standalone module:python -m pebba <deg_file> <gmt_file>For more options use the --help flag:python -m pebba --help