Saravanan666/pypi-org huggingface dataset:
Package: pickle-warehouse
Pickle Warehouse makes it easy to save Python
objects to files with meaningful identifiers.How to usePickle Warehouse provides a dictionary-like object
that is associated with a particular directory on
your computer.from pickle_warehouse import Warehouse
warehouse = Warehouse('/tmp/a-directory')The keys correspond to files, and the values get
pickled to the files.warehouse['filename'] = range(100)

import pickle
range(100) == pickle.load(open('/tmp/a-directory/filename', 'rb'))You can also read and delete things.# Read
range(100) == warehouse['filename']

# Delete
del(warehouse['filename'])The coolest part is that the key gets interpreted
in a fancy way. Aside from strings and string-like objects,
you can use iterables of strings; all of these indices refer
to the file/tmp/a-directory/foo/bar/baz:warehouse[('foo','bar','baz')]
warehouse[['foo','bar','baz']]If you pass a relative path to a file, it will be broken up as you’d expect;
that is, strings get split on slashes and backslashes.warehouse['foo/bar/baz']
warehouse['foo\\bar\\baz']Note well: Specifying an absolute path won’t save things outside the warehouse directory.warehouse['/foo/bar/baz'] # -> foo, bar, baz
warehouse['C:\\foo\\bar\\baz'] # -> c, foo, bar, baz
                               # (lowercase "c")If you pass a URL, it will also get broken up in a reasonable way.# /tmp/a-directory/http/thomaslevine.com/!/?foo=bar#baz
warehouse['http://thomaslevine.com/!/?foo=bar#baz']

# /tmp/a-directory/thomaslevine.com/!?foo=bar#baz
warehouse['thomaslevine.com/!?foo=bar#baz']Dates and datetimes get converted toYYYY-MM-DDformat.import datetime

# /tmp/a-directory/2014-02-26
warehouse[datetime.date(2014,2,26)]
warehouse[datetime.datetime(2014,2,26,13,6,42)]And you can mix these formats!# /tmp/a-directory/http/thomaslevine.com/open-data/2014-02-26
warehouse[('http://thomaslevine.com/open-data', datetime.date(2014,2,26))]It also has typical dictionary methods likekeys,values,items,
andupdate.When to usepickle-warehouse is for when you want a persistant store of Python objects.
If you want an in-memory pickle store, look at
_pickleDB:https://pythonhosted.org/pickleDB/.Pickle Warehouse is strictly better than Mongo, so you should use it anywhere
where you were previously using Mongo. Pickle Warehouse is designed for
write-heavy workloads that need scalability (easy sharding), traditional
database reliability (ACID), flexible schemas, and highly configurable indexing.Pickle Warehouse is acidicHere’s how it accomplishes that.AtomicityWrites are made to a temporary file that gets renamed.ConsistencyI don’t get this one, but I’m pretty sure I have it.IsolationSimultaneous writes are handled quite cleanly. If reads occur during writes, an error gets thrown, and you can try again.DurabilityAll data are saved to disk right away.Mongo replacement feature checklistCall fsync twice, just to make sure.Schema validation on read and write (configurable), because who knows what you did yesterday or whether you change your mind later?PID + random number (+ hash?) for random number generationInode exhaustion
Package: pickley
Automate installation of standalone python CLIsOverviewpickleyallows to install and keep up-to-date standalone pip-installable python CLIs
such astox,hatch, etc.It issimilar to pipx, main difference being installed CLIs automatically self-upgrade
as you use them.It can work out of the box,without any configuration:pickleyis portable, it will run and install other CLIs in the same folder it’s running from
(drop it in~/.local/binor/usr/local/binfor example)All pypi packages withconsole_scriptsentry point(s) can be immediately installedLatest non-prerelease pypi version will be installed by default
(can be pinned via explicit pinpickley installfoo==1.0, or via configuration)Withsome configuration, the following becomes possible:You can pin what version to install, what python to use etc, per pypi packageYou can definebundle-s: names that install several pypi packages at once,
for example: you could define abundle:devto installtox pipenvpre-commitYou can use a custom pypi server index (pip’s default is respected by default)You can use thesymlinkdelivery method, which will use symlinks instead of self-upgrading wrapperExampleOnce you havepickley, you can get other python CLIs and use them as standalone programs, for example:# One-liner to grab pickley, and drop it in ~/.local/bin
$ curl -fsSL https://raw.githubusercontent.com/codrsquad/pickley/main/src/pickley/bstrap.py | /usr/bin/python3 -

# Double-check you do have ~/.local/bin in your PATH
$ which -a pickley
~/.local/bin/pickley

$ pickley base
~/.local/bin

$ pickley install tox hatch
Installed tox v4.5.2 in 6 seconds 501 ms
Installed hatch v1.7.0 in 15 seconds

$ which tox
~/.local/bin/tox

$ tox --version
tox version 3.21.4

$ pickley list
| Package    | Version |
-------------|----------
| tox        | 4.5.2   |
| hatch      | 1.7.0   |ConfigurationSeeconfigFeaturesAnypypipackage that hasconsole_scriptsentry point can be installed and kept up-to-dateAims to work with zero configuration (but configuration is possible):entirely portable, installations are performed in the same folder wherepickleyresides,
drop it in~/.local/binand all the stuff you install with it will also be therelatest non pre-release version from pypi is usedCommands:check: exit with code 0 if specified package(s) are up-to-dateinstall: install specified package(s)list: list installed packages viapickley, in folder where it resides (not globally)package: can be used to simplify packaging of python projects for internal useInstallationInstall latest version in~/.local/binHandy one-line usingbash:$ /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/codrsquad/pickley/main/get-pickley)"Handy one-liner using python (see--help, the script accepts a few options):$ curl -fsSL https://raw.githubusercontent.com/codrsquad/pickley/main/src/pickley/bstrap.py | /usr/bin/python3 - --helpInstall from sourceRun (you will needtox):git clone https://github.com/codrsquad/pickley.git
cd pickley
python3 -mvenv .venv
.venv/bin/pip install -r requirements.txt -r tests/requirements.txt -e .
.venv/bin/pickley --help
Package: pickling-decorator
pickling_decoratorpickle inputs and outputs of a function.Usagefrompickling_decoratorimportpicklingclassTestClass:@pickling_decorator.pickling()deffoo(self):print("something")deftest_func():t=TestClass()t.foo()InstallationRequirementsCompatibilityLicenceAuthorspickling_decorator was written byfx-kirin.
Package: picknmix
Pick n MixA simple tool to help building stacking models.Free software: MIT licenseDocumentation:https://picknmix.readthedocs.io.FeaturesPick n Mix is a simple stacking tool for stacking Sci-Kit learn models of your picks.
It provided 2 classes: Layer and Stack. Layer is a parallel combination of models,
while Stack combine Layers to create a stacking model.CreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2019-05-26)First release on PyPI.0.1.1 (2019-06-04)Refactor import structure.Adding checks on using ‘proba’ and fallback to ‘predict’ if needed.0.1.2 (2019-06-19)Added option to use different folds in training different layers in Stack.0.1.3 (2019-07-01)Bug fix on split.
Package: picknpull
PurposeThe main purpose of this API is to automate a search for vehicles sitting in Pick N Pull lots around the world. It makes it far easier to setup a program to check every so often for new additions to these lots so you don't miss any parts or let it get ruined by rain.Using this APITo use the API in your own python file:Import the class:from picknpull import PickNPullCreate an instance of the class with your vehicle's make and modelpnp = PickNPull(model, startYear = None, endYear = None, zipcode = "95648", searchRadius = "50", verbose = False)-- model - current options include and are limited to:-- "IS300"-- "WRX"-- "IMPREZA"-- "ACCORD"-- startYear - the first year to include in your search. Must also include an endYear-- endYear - the last year to include in your search. Must also include a startYear-- zipcode - the zip code to search around-- searchRadius - the radius around the zip code to search-- verbose - boolean to determine if print statements will print3. Call the desired function:-- search() - returns count of vehicles found in radius as a string
Package: pickpeak
Pick Peak is aPyQtGraph-based tool. It aims
to provide a graphical user interface to allow the user easily selecting peaks of a
spectrum ploat.READMEIntroductionTo do.InstallationFor standard Python installations, install pickpeak using pip:pipinstall-UpipsetuptoolspipinstallpickpeakUsagefrompickpeak.pickpeakimportpickpeakasppimportnumpyasnpspectrum=np.random.rand(20)#sample of spectrumpeaks=pp(spectrum)#spectrum shoud be type numpy.ndarray 1Dprintpeaks# list of peaksRequirementsPython 2.7.Setuptools.PyQtGraph.PyQt5.NumPy.StatusWe choose to move to PyQtGraph to have more GUI resources without losing simplicity.
Package: pickpock
pickpockThis is a slightly cleaned up re-implementation of Deen Freelon's pyktok library for scraping TikTok metadataI've removed heavy dependencies (numpy, pandas), modernized cookie handling (with request sessions) and modularized the code.To scrape TikTok metadata, first provide a firefox or chrome cookie database and use the generic dispatch functions:importpickpock# the library always returns generatorsresults=pickpock.fetch("<some_url>")# there are two convenience functions for writing either raw metadata as jsonlinesforvideoinpickpock.fetch("<some_url>"):pickpock.write_json(video)# or to write a csv similar to the original pyktokforvideoinpickpock.fetch("<some_url>"):pickpock.write_csv(video)
Package: pickrr
Pickrr Python APIPickrr order placing, order Cancellation and order tracking apiInstallation:Open the terminal and write:$ pip install pickrrHow to use:First setup the auth-token:$ from pickrr.session import Session
$ Session.setup("auth-token")EXAMPLE:$ from pickrr.session import Session
$ Session.setup("94539823sd342d5453224")For placing order:$ from pickrr.placeorder import PlaceOrder
$ PlaceOrder.placeorder(item_name,from_name,from_phone_number,from_pincode,
  from_address,to_name,to_phone_number,to_pincode,to_address,cod_amount,
  client_order_id,client_other_id)for prepaid pass cod_amount=0.0, and order_id and client_other_id are optionalEXAMPLE:$ from pickrr.placeorder import PlaceOrder
$ PlaceOrder.placeorder(item_name = "ITEM NAME",from_name = "NAME",
  from_phone_number="9999999999",from_pincode = "110023",
  from_address= "FULL ADDRESS",to_name = "TO NAME",to_phone_number ="9898989898",
  to_pincode = "110045",to_address = "TO ADDRESS",cod_amount = "123",client_order_id = "345345",
  client_other_id = "32")RETURN:{"pickrr_phone_number": "+91-9818197991", "err": null, "order_id": "109124", "to_notify": false,
"order_from_city": "NEW DELHI", "item_name": "test", "user_email": "h@pickrr.com",
"tracking_id": "90410810064184", "pickrr_name": "Sahil Goyal", "order_pk": 108100,
 "order_service_used": "Standard", "order_to_city": "NEW DELHI"}For Cancel the order:$ from pickrr.cancelorder import CancelOrder
$ CancelOrder.cancelorder(order_id)EXAMPLE:$ from pickrr.cancelorder import CancelOrder
$ CancelOrder.cancelorder(order_id="109124")RETURN:$ {"err": null}For order tracking:$ from pickrr.trackorder import TrackOrder
$ TrackOrder.trackorder(tracking_id)EXAMPLE:$ from pickrr.trackorder import TrackOrder
$ TrackOrder.trackorder(tracking_id="45323232342")
Package: picks
Despite there are lot’s and lot’s of file viewers out therenoneof them
satisfied a couple of (simple) requirements which are important for me:Support for ‘interesting file separation’ (bycopying/linking a fileto a special folder while viewing) (Gwenview has this, but it’s broken)File taggingwithout a proprietary database (best would be using the
filename to store tags because this is intuitive and platform/tool
independent)Sexyslide showmode (e.g. with Ken Burns effect (pan/zoom))Support at least forLinuxThis is whypicks(play on the wordspictureandpick) emerged. Among
the features already mentioned the project goals are:Easy deployment/usageon at least Linux/MacOS/WindowsEasy interaction(e.g. without the need to use a mouse)Support for reading from attachedsmart phones(MTP support)Tools for deciding whether tokeep or deletea file (focus peaking, etc.)Installation / UsageRecommended way to install picks is viapip:pip3 install picksIf you want to have the latest bugs:git clone https://github.com/frans-fuerst/picks
cd picks
./setup.py installRunpickslike this:picks [<DIR>]Noteyou have to run picks inside the directory containing the pictures
you want to view or provide it on command line - there’s no
navigation inside the application yet.There is also a command line mode but very few commands right now. E.g. you
caninitializethe filenames of all pictures inside a directory:picks --initialize <DIR>
Package: pickuppath
pickup file path.detailThe stragegy of finding file path, following below.$pwd$HOME/vboxshare/venvs/work$pickuppath--debug.config.iniDEBUG:pickuppath:check:$HOME/vboxshare/venvs/work/.config.iniDEBUG:pickuppath:check:$HOME/vboxshare/venvs/.config.iniDEBUG:pickuppath:check:$HOME/vboxshare/.config.iniDEBUG:pickuppath:check:$HOME/.config.ini$HOME/.config.iniif file path is not found, then, lookup~/.config.ini.as python functionfrompickuppathimportpickup_pathprint(pickup_path("config.ini",current="~/venv/py/work/"))
Package: pickups
Python pickups contains everything to setup extreme feedback devices with Atlassian Bamboo,
a RasberryPi and an USB power-plug.DocumentationThe full documentation is athttp://pickups.rtfd.org.FeaturesPredefined structure to integrate extreme feedback devices into buildsEasy to extend with more devices and serversHelpers to handle signals in a custom wayWell tested, and easy to rebuild with toxHistory0.8.0 (2015-09-02)various cleanups of project structure0.7.0 (2015-02-10)documentation for testshttps://github.com/maiksensi/pickups/issues/50.6.0 (2015-01-23)integrated a preconfigured logger modulehttps://github.com/maiksensi/pickups/issues/6read package contents from _package.py0.5.2 (2015-01-23)hotfix issuehttps://github.com/maiksensi/pickups/issues/3again0.5.1 (2015-01-14)hotfix issuehttps://github.com/maiksensi/pickups/issues/30.5.0 (2015-01-08)added proper badges0.3.0 (2015-01-07)First release on PyPi0.2.0 (2014-12-30)Added tests0.1.0 (2014-12-17)Added core functionalityAdded helpers
Package: picky-pip
Picky is a tool for making sure that the packages you have installed
withpiporcondamatch those you have specified.It also will let you easily maintain those specifications, even in the
situation where some packages are installed by pip while others are
installed using conda.This package provides a version of picky targeted at virtualenvs and other
environments where pip is used to manage packages.
If you require the version that targets conda environments, seepicky-conda
Package: pi-clap
pi-clapA python package for clap detectionVisit Official documentation @pi-clap.nikz.inPlatforms SupportedRaspberry PiLinuxMacOSHardware RequirementsRaspberry Pi (optional)Bread Board (optional)MicrophoneAudio Card (Needed for analog microphones with a jack)DependenciesPython 3.6+gpiozeroRPi.GPIOPyAudioPortAudio(Need to be installed manually)Audio Driver (Automatically loaded by OS after a restart)MunchUpcoming featuresAdding advanced clap detection algorithmsAdding support for automation platforms like Amazon Alexa, Google Home, IFTTT etc.Adding auto calibration for microphoneDevelopmentgit clone https://github.com/nikhiljohn10/pi-clap
cd pi-clap
make help # Display the possible options availableVersion number is fetched frompiclap/__init__.pyPackage -/piclapExamples -/exampleDocumentation -/docs/sourceTest Cases -/testGithub Actions -/.github/workflowsLicenseMIT License
Package: picles.plumber
A simple data transformation pipeline based on python’s iteration protocol that
runs on python versions 2.7, 3.3 and 3.4.+----------+      +-------------+      +-------------+      +--------+      +----------+
| Producer | ---> | Transformer | ---> | Transformer | ---> | Tester | ---> | Consumer |
+----------+      +-------------+      +-------------+      +--------+      +----------+A pipeline model expects 4 types of filters:Producer: starting point, outbound only;Transformer: input, processing, output;Tester: input, discard or pass-thru;Consumer: ending point, inbound only.importplumber@plumber.filterdefupper(data):returndata.upper()ppl=plumber.Pipeline(upper)output=ppl.run("Hey Jude, don't make it bad")print(''.join(output))"HEY JUDE, DON'T MAKE IT BAD"Since the design is based on python’s iteration protocol, both producers and
consumers are ordinary iterable objects. Transformers are implemented as
callables that accept a single argument, perform the processing and return the
result.Input data may also be checked against some preconditions in order to decide
if the transformation should happen or be by-passed. For example:importplumberdefis_vowel(data):ifdatanotin'aeiou':raiseplumber.UnmetPrecondition()@plumber.filter@plumber.precondition(is_vowel)defupper(data):returndata.upper()ppl=plumber.Pipeline(upper)output=ppl.run("Hey Jude, don't make it bad")print(''.join(output))"hEy jUdE, dOn't mAkE It bAd"PrefetchingIf you think the pipes are taking too long to move data forward,
you can use a prefetching feature. To use it, just define the upper
limit of items to be pre fetched.Using the same example as above:ppl=plumber.Pipeline(stripper,upper)transformed_data=ppl.run([" I am the Great Cornholio!","Hey Jude, don't make it bad "],prefetch=2)fortdintransformed_data:print(td)IAMTHEGREATCORNHOLIO!"HEY JUDE, DON'T MAKE IT BAD"By default the prefetching mechanism is thread-based, so be careful with cpu-bound
pipelines.InstallationPypi (recommended):$pipinstallpicles.plumberSource code (development version):$gitclonehttps://github.com/picleslivre/plumber.git&&cdplumber&&pythonsetup.pyinstallUse licenseThis project is licensed under FreeBSD 2-clause. SeeLICENSEfor more details.
Package: pi-clock
pi-clockSet alarms, create timers or stopwatches right from your terminal.Installationpip3installpi-clockUsageSetting an alarmpiclock-aCreating a timerpiclock-tCreating a new stopwatchpiclock-sInteractive modepiclock-iCommand Line Argumentsusage: piclock [-h] [-i] [-t] [-a] [-s]

optional arguments:
-h, --help          shows this help message and exit
-i, --interactive   Interactive mode
-t, --timer         Set a new timer
-a, --alarm         Set a new alarm
-s. --stopwatch     Start a new stopwatchTodo:Allow alarms to run in the background while in intercative mode.
Package: piClusterManager
piClusterManagerOpen source Manager for PI clustersinstallpip3installpiClusterManagerfisrt runyou can setup cluster manager only when you havenew instalation of raspberian,not change passwordsandenabled SSHthen you can writepicluster--setupfor everything to work properly, you must have runned commandpiclusterdeamonat all nodesusageusage:picluster[-h][--setup][--update][--dockerSwarmSetup][--passwd][--executeEXECUTE]PIClustermanager

optionalarguments:-h,--helpshowthishelpmessageandexit--setupsetuppicluster--updatemakeupdate&&upgradeinallnodes--dockerSwarmSetupsetupdockerswarmincluster--passwdchangepasswordofcluster(samepasswordinallnodes)--executeEXECUTEexecutecommandinallnodes(--execute="rm -rf/home/pi/example")
Package: picnic-python
A Python library for Picnic’s API. Python 2.7.9 and 3.4.3 (and above) are supported.SetupYou can install this package—and its one dependency,requests—by doing:pip install picnic-pythonor:easy_install picnic-pythonObtaining a Picnic API KeySign up for an API key athttps://picnic.sh/api.Using the Picnic APIDocumentation for the API can be found athttps://picnic.sh/api.Using this client libraryFor a quick demonstration of the available methods, please seeexample.py.list_websites()Returns a list ofWebsites that you own.get_website(domain_name)Returns aWebsitereferred to by the givendomain_name.get_price(domain_name)Returns aDomainStatusfor the givendomain_name.create_website(domain_name,html)Creates a website with the givenhtmlcontent at the givendomain_name, if available. If successful, returns aWebsite.Website.update_content(html)Overwrites theWebsite’s content with the givenhtml.
Package: pico8-mkdocs-plugin
Pico-8 (MkDocs Plugin)Thismkdocs pluginlook in each MkDocs article for the presence of a tag like this:{{ pico-8: 12345 }}Then, it will replace it with a web player that will allow
the reader of a page to enjoy pico-8 games through the page.To install it, edit yourmkdocs.ymlfile
and add these few lines of code:plugins:-hello-dollyAn exampleFor example, you could edit thedocs/index.mdfile and insert the tag in any place, like this:# Welcome to MkDocsFor full documentation visit [mkdocs.org](http://mkdocs.org).

{{ pico-8: 46052 }}## Commands
Package: pico-acme
pico acmeThe tiniest python package to get ACMEv2 certs fromLet's Encrypt.Supports only single domains and DNS challenge. Currently implements AWS Route 53 but you can trivially implement your own provider.Licensed under Apache 2.0 as this reuses some code from certbot.quick startInstall from PyPI:pipinstallpico-acme(Note that you need to installboto3separately to useroute53.)new.py:ROUTE53_HOSTED_ZONE_ID="..."ACCOUNT_EMAIL="domains@example.com"DOMAIN="example.com"# create account, get cert, and save detailsimportpico_acmefrompico_acmeimportroute53# register an acme accountacme_client=pico_acme.register_account(ACCOUNT_EMAIL,agree_tos=True)# create a private key and certificate signing requestkey_pem=pico_acme.make_key()csr_pem=pico_acme.make_csr(key_pem,[DOMAIN])# get functions for upserting and cleaning up DNS records in AWS Route 53upsert,clean=route53.route53_upsert_cleanup(ROUTE53_HOSTED_ZONE_ID)# perform DNS-01 challenge to get the full chain as PEMfullchain_pem=pico_acme.perform_dns01(acme_client,DOMAIN,csr_pem,upsert,clean)# save account for laterwithopen("pico_acme_account.json","w")asf:f.write(pico_acme.serialize_account(acme_client))# save private key for laterwithopen("key.pem","wb")asf:f.write(key_pem)# save the cert for laterwithopen("fullchain.pem","w")asf:f.write(fullchain_pem)renew.py:ROUTE53_HOSTED_ZONE_ID="..."DOMAIN="example.com"# later, load account, private key, and renew certimportpico_acmefrompico_acmeimportroute53# load accountwithopen("pico_acme_account.json")asf:acme_client=pico_acme.deserialize_account(f.read())# load private keywithopen("key.pem","rb")asf:key_pem=f.read()# make a new certificate signing requestcsr_pem=pico_acme.make_csr(key_pem,[DOMAIN])# get functions for upserting and cleaning up DNS records in AWS Route 53upsert,clean=route53.route53_upsert_cleanup(ROUTE53_HOSTED_ZONE_ID)# perform DNS-01 challenge to get the full chain as PEMfullchain_pem=pico_acme.perform_dns01(acme_client,DOMAIN,csr_pem,upsert,clean)# save the cert for laterwithopen("fullchain.pem","w")asf:f.write(fullchain_pem)architecture & featuresTheperform_dns01takes two callables,upsert(record, value)which should set the valuevalue(the verification string) in recordrecord(e.g._acme-challenge.example.com), andclean(record, value)which should clean these up. See theroute53.pyimplementation for details.