Saravanan666/pypi-org huggingface dataset:
Package: pidge
pidgepidge helps with the creation of mappings for tabular string data. The primary use cases for
this are data cleaning and data categorization.pidge consists out of two parts:An interactive UI to help with the creation of mappings and assessing their completenessLibrary functionality to apply mappings inside of data pipelines, after they have been exported from the UIUsageinstallpidgepip install pidgeLaunch the UI in a notebookfrompidgeimportpidge_uiimportpanelaspnpn.extensions('tabulator','jsoneditor')pidge_ui(my_input_dataframe)Create and export a mapping namedpidge_mapping.jsonIn your data pipeline importpidgeand apply the mappingfrompidgeimportpidgetransformed_data=pidge(my_input_dataframe,rule_file='pidge_mapping.json')The web-ui outside of JupyterPidge can also run the UI as a standalone web server outside of jupyter, using the command.python -m pidgeThis starts up the UI in a local web server, which is primarily intended for illustration purposes.
Therefore it starts up with example data already loaded. However new data can be loaded and the
predefined rules can easily be reset. The main limitation at this moment, however, is the
constraint on the upload format for data. It only supports.csvand reads it with defaultpandas.read_csvsettings.Mapping LogicPidge mappings map a source string column to a newly created target string column. The logic can
be broken down as follows.One defines a possible value, a category, for the target column.One associates one or more patterns with that category.When a value of the source column matches one of the category's patterns, that category is chosen.Pattern matching checks whether the pattern is part of the source string. It is case insensitive
and allows for regular expressions.This is repeated for as many categories as desired.ContributionPidge is in an early MVP stage. At this stage the following is particularly appreciatedAny feedback regarding, bugs, issues usability feature requests etc. Ideally this can be done directly
as github issues.Any sharing of the project to potentially help with the previous point.Known LimitationsThere are a few known limitations particularly due to the MVP stage of the project. These
will be prioritized according to feedback and general usage of the project.Mapping is not optimized for speed at all and might slow down for large dataframesPatterns do not check for multiple inconsistent matches and simply the first applicable pattern
is chosenthe web-ui does only support small file uploads (around < 10Mb).file uploads can only read in the data withpandas.read_csvdefault settingsThe rule name used for the .json export can currently not be changed in the UI.
Package: pidgen2
PIDGen2IntroductionPIDGen is a tool to resample PID variables in the full MC bases on distributions from calibration samples. PIDGen2 is a successor of the old PIDGen package. PIDGen2 is available vialb-condaand is supposed to replace the old PIDGen, both for Run 3 data, and for Run 1/Run 2.
An analogous solution updating PIDCorr is under development (seehere).DocumentationSeedocumentation pages here.LinksPIDCalib2old version documentation12/10/21, Run 1/2 performance WG meeting,PIDGen211/02/21, RTA WP4-5 meeting,PIDGen in Run3Twiki for the old PIDGen/PIDCorr for Run1/2Details about Run2 PID calibration samples are here:ChargedPID twikiLHCb-INT-2017-007 internal notedescribing the PIDGen/PIDCorr procedure used in Run1/2.
Package: pidgeotto
pidgeottoDescriptionYet another static website generator.Why choose pidgeotto?Free of javascript.Extensible, flexible, forkable.Minimal and fast.Free under MIT License.Installationpip install pidgeotto$ pip install git+https://github.com/niharokz/pidgeottoPrerequisitesBy default, pidgeotto will install the below packages from PyPI pippyyaml, jinja2, markdown2PyYAML:	To consume the config file and header of blog posts.jinja2:	Templating enginemarkdown2:	To convert markdown to HTMLUsage:$pidgeyinitprojectTo initiate pidgeotto with name "project"$pidgeynewpageNameTo create new page/post/note with name "pageName"$pidgeybuildpageNameTo build static pages and keep those in the "public" directory.Extra FunctionalatiesshowInHome tag is present in each note markdown.showInHome: Truewill create page which are blog/note post.``` showInHome: False ``` 
 will create page which are pages.config.yml is extensible.
For example, if you want to add favicon.ico. Keep favicon in the resource folder.favicon: resource/favicon.icoin config.yml
In template, add {{ config.get('favicon') }}.Extra metadata per page.
If you want to add some metadata to your page, it can be done using the below command on the markdown page.meta : '<link rel="stylesheet" type="text/css" href="/extra.css" />Structurepidgeotto_project
â”œâ”€â”€ public
â”œâ”€â”€ config.yml
â”œâ”€â”€ content
â”‚   â”œâ”€â”€ header.md
â”‚   â”œâ”€â”€ footer.md
â”‚   â”œâ”€â”€ home.md
â”‚   â”œâ”€â”€ archive.md
â”‚   â””â”€â”€ note
â”‚       â””â”€â”€ other_pages.md
â”œâ”€â”€ resource
â””â”€â”€ templates
    â”œâ”€â”€ home_template.html
    â”œâ”€â”€ note_template.html
    â””â”€â”€ rss_template.xmlconfig.yml:	To configure the title, name, CSS file, js file, and other configurations.resource:	Location to store all CSS, js, image data and other static content.content:	All markdown files are stored here.template:	Layouts for different HTML pages are kept here.public: All generated static files. It can be changed in config.ymlExampleBelow are examples of sites running via pidgeotto.nih.arTODO(A) 08-05-2021 Clean up some clutter codingUpdate0.0.3Server Functionality addedAutomatic .md extensionError/Exception handled0.0.4Cleanup0.0.5Windows support added
Package: pidgey
pidgeyA python interface for dynamics of galaxies, using existing galactic dynamics libraries in Python (galpy,galaandagama) as backends.This is currently used in thecommensurabilitylibrary.InstallationInstall this package viapip:python -m pip install pidgeyUsageGet the points from an orbit integration stored in anastropy.coordinates.SkyCoordobject by calling thecompute_orbitmethod of a backend. The backend can generally be obtained from the potential used for the orbit integration with theget_backend_fromfunction.importastropy.coordinatesascimportastropy.unitsasufrompidgeyimportget_backend_fromdefcalculate_orbit(ic:c.SkyCoord,potential:Any)->c.SkyCoord:backend=get_backend_from(potential)orbit=backend.compute_orbit(ic,potential,dt=0.01*u.Gyr,steps=1000)returnorbit
Package: pidgin
pidginis a collection of IPython magics for creating computable essays.if__name__=='__main__':%load_extpidginMarkdown Mode%pidginmarkdown---With`pidgin.markdown`,codecellsacceptmarkdown.Anyindentedcodeblocksareexecuted.foo=42print(f"foo is{foo}")>Acceptingthe`pidgin.markdown`convetionmeanstheauthoragreestoindentalltheircodeatleastonce;andsometimesmoreinnestedlists.---Withpidgin.markdown, code cells accept markdown.  Any indented code blocks are executed.foo = 42
print(f"foo is {foo}")Accepting thepidgin.markdownconvetion means the author agrees to indent all their code at least once; and sometimes more in nested lists.foo is 42Template ModeWith templates real data can be inserted into the computational essay. An author should desire their notebook restart and run all during template mode.%pidgintemplateSkippingthefirstlinesuppressesthemarkdownoutput.---Intemplatemode,`jinja2`maybeinvokedtotemplatemarkdownandcode.Wealreadyknowthat`foo`is42,butcantestthatassertionwithassertfoois{{foo}}is42{%foriinrange(3)%}print({{i}}){%endfor%}---In template mode,jinja2may be invoked to template markdown and code.  We already know thatfoois 42, but can test that assertion withassert foo is 42 is 42
print(0)
print(1)
print(2)0
1
2# Turning off magics%pidgin--offtemplatemarkdownTurning off magics%pidgin --off template markdownYamlStart code with---%pidginconventions---a:42asserta==42GraphvizStart code withgraphordigraph!conda install -y graphvizgraph{{IpythonJuliaR}--Jupyter}File "<ipython-input-9-1661b3d05729>", line 1
    graph { {Ipython Julia R}--Jupyter}
          ^
SyntaxError: invalid syntaxNotebooks as sourcepidgin uses notebooks as source; line numbers are retained so that the notebook source produces semi-sane tracebacks.frompidginimportmarkdown,template,conventionsThe pidgin loader allows an author to import notebooks directly as source.  This means all of the pidgin documents are importable.%%pidginmarkdowntemplateconventionsimportreadmeassertall(file.__file__.endswith('.ipynb')forfilein(markdown,template,conventions))Everything Should ComputeConvert a document into other formats; Restart, Run All,nbconvert.%%pidginmarkdowntemplateUsepidginacellmagictotemporarilyemployanyconvetions.if__name__=='__main__':!jupyternbconvert--tomarkdownreadme.ipynb
Package: pidgy
pidgyliterate computing interfacepidgyis a fun, literate and interactive style of programming in markdown & python. together, these languages offer an exciting new experience to rapidly co-develop of code and narrative in Jupyter computational notebooks.writing withpidgypipinstallpidgyinstallpidgywith `pip`%reload_ext pidgy🪐 open a jupyter notebook🔌 activate thepidgyextension✏️ program in markdown💡 trypidgyin jupyterlite without any installation[^lite]programming in markdownmarkdown is inclusive AF![^a11y] it is a plain-text format that never fails [^violate].
further markdown can include any programming language within its contents.
effectively, markdown files are literate programs that really on code and narrative to cooperate. markdown is a global minimum for teams of people with different language literacies.aTabseparates markdown code and narrative,pidgyuses this nearness to create python representations of the markdown. with code and narrative so close, an author can fluidly switch between the writing modes capturing more of their process.learn moretrypidgy, without installing it, injupyterlite.learn more from thepidgydocumentation.learn how CommonMark markdown converts to pythoncontributing and developmentdevelopment[^a11y]: there are techniques forimproving accessibility of markdownand abiding best practices.
[^violate]: markdown WILL violate expectation through implementation inconsistencies. over time we learn to navigate the nuances across products.
[^lite]:jupyterliteis a new in-the-browser jupyter experience that requires zero installation.
Package: pi-dht-webthing
pi_dht_webthingA web connected humidity and temperature sensorThis project provides awebthing APIto aDHT11 or DHT22humidity and temperature sensor
running on a Raspberry Pi. As a webthing, the DHT sensor can be discovered and used byhome automation systemsor custom solutions supporting the webthing API.The pi_dht_webthing exposes an http webthing endpoint which supports reading the humidity and temperature sensor values via http. E.g.# webthing has been started on host 192.168.0.23

curl http://192.168.0.23:8070/properties 

{
   "temperature" : 17.3,
   "humidity" : 79.9
}A RaspberryPi/DHTxx hardware setup and wiring may look likeDHT22 example.To install this software you may useDockerorPIPpackage manager such as shown below** Docker approach**sudo docker run --privileged -p 8070:8070 -e gpio=2 grro/pi_dht_webthing:0.1.0PIP approachsudo pip install pi_dht_webthingAfter this installation you may start the webthing http endpoint inside your python code or via command line usingsudo dht --command listen --h--port 8070 --gpio 2Here, the webthing API will be bind on port 8070 and be connected to the DHTxx signal pin using gpio 2Alternatively to thelistencommand, you can use theregistercommand to register and start the webthing service as systemd unit.
By doing this the webthing service will be started automatically on boot. Starting the server manually using thelistencommand is no longer necessary.sudo dht --command register --port 8070 --gpio 2
Package: pidi
🎵 pidipidiis a plugin-compatible fork ofbum, a daemon that downloads album art for songs playing inmpd/mopidyand displays them in a little window.pidiisn't as lightweight asbum, but supports displaying track information to a variety of output devices including a 240x240 ST7789 LCD.pidiis intended for use with the Raspberry Pi, but can be used on other systems with the appropriate display plugins.pidiusesmusicbrainzto source and download cover art, if an album is missing its cover art you can easily create an account and fill in the data yourself.pidioutputs arelease-idwhich you can use to find the exact entry on musicbrainz.Note:pidiis meant to be used with files that don't have embedded album art (eg:mopidy-spotify).Dependenciespython 3.6+python-mpd2musicbrainzngsOptionalpidisupports multiple display outputs, specified using--display {dummy,tk,mpv}, you must install the dependencies required for your chosen output:python-mpv- for mpv outputpython3-pil,python3-tkandpython3-pil.imagetkplusfontsandfont_connectionfrom pypi - for tk/PIL outputst7789- for ST7789 1.3" 240x240 LCD outputInstallationpip3install--userpidiUsageusage:pidi[-h][--update-interval"i"][--fpsFPS][--size"px"][--cache_dir"/path/to/dir"][--version][--no_display][--display{dummy,mpv,file,tk}][--client{mpd,ssnc}][--portPORT][--serverSERVER]pidi-Downloadanddisplayalbumartformpdtracks.

optionalarguments:-h,--helpshowthishelpmessageandexit--update-interval"i"overlayupdateintervalinseconds.--fpsFPSframespersecond.--size"px"whatsizetodisplaythealbumartin.--cache_dir"/path/to/dir"Wheretostorethedownloadedcoverart.--versionPrint"pidi"version.--no_displayOnlydownloadalbumart,don'tdisplay.--display{dummy,mpv,file,tk}Displayclasstouse.--client{mpd,ssnc}Clientclasstouse.--portPORTUseacustommpdport.--serverSERVERUsearemoteserverinsteadoflocalhost.Changelogv0.1.0Add ability to plug clients into pidiAdd Shairport Sync client - seehttps://github.com/pimoroni/pidi/issues/5Fix compatbility with new versions of mpv and python-mpd2v0.0.1 / 0.0.2Initial release(s)Donatepidiis a fork ofbum-https://github.com/dylanaraps/bum, which was originally written by @dylanaraps.If you'd like to show him some support, you can donate here:https://patreon.com/dyla
Package: pidi-display-st7789
PiDi Display Plugin for the ST7789 240x240 LCDThis plugin allows PiDi and Mopidy-PiDi to display album art and transport on the ST7789 LCD.0.1.2Issue commands to turn off/on display on stop/startSupport kwargs for PiDi0.1.1Handle "stop" and turn off backlight/display0.1.0Only update display if image buffer has changed0.0.2Fix readmeFix minimum Python versionRequire pidi-display-pil==0.0.20.0.1Initial Release
Package: pidi-display-tk
PiDi Display Plugin for output via TkThis plugin allows Mopidy-PiDi and PiDi to display album art via TkInter.0.1.0Only update display if image buffer has changed0.0.2Fix python 2.7 support for Mopidy-PiDiRequire pidi-display-pil==0.0.20.0.1Initial Release
Package: pidiff
pidiffpidiff- the Python interface diff toolDocumentationSourcePyPIpidiffis a tool to detect and report on API changes between multiple versions
of a Python module. It can be used as a testing tool to help a project follow
theSemantic Versioningspec.ExamplesThepidiffcommand can install old and new package versions from PyPI and diff a
module between versions, failing if SemVer is not used appropriately.Here's an example of a diff finding some problems:$ pidiff more-executors==1.15.0 more-executors==1.16.0
more_executors/_wrap.py:6: N220 function added: flat_bind
more_executors/retry.py:46: N450 ExceptionRetryPolicy now accepts unlimited keyword arguments
more_executors/retry.py:46: B330 argument in ExceptionRetryPolicy can no longer be passed positionally: max_attempts (was position 0)
more_executors/retry.py:133: N450 RetryExecutor now accepts unlimited keyword arguments
more_executors/retry.py:133: B130 method removed: new_default

---------------------------------------------------------------------
Major API changes were found; inappropriate for 1.15.0 => 1.16.0
New version should be equal or greater than 2.0.0Public API was removed without a major bump of the package version;
pidiff considers this an error and suggests the new minimum version
number which should be set to accept these changes.Here's an example of a diff reporting a successful result:$ pidiff more-executors==1.11.0 more-executors==1.12.0
more_executors/flat_map.py:0: N210 module added: flat_map
more_executors/_executors.py:84: N230 method added: with_flat_map

---------------------------------------------------------------------
Minor API changes were found; appropriate for 1.11.0 => 1.12.0Public API was added; since there was a minor bump of the package version,
this is OK.LicenseThis program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Package: pidigits
PiDigitsImplements the ‘Unbounded Spigot Algorithm for the Digits of Pi’ by
Jeremy Gibbons. The paper describing this algorithm can be found at thisURL. The same algorithm is used to generate digits ofTau. No matter which
circle constant you prefer, you can now generate the decimal expansion using
this package.Installationpidigitsis avalaible through Python Package Index (PyPI) usingpip.>>> pip install --upgrade pidigitsTo uninstall usingpip.>>> pip uninstall pidigitsUsagePiDigits provides a generator function namedpiGeneratorthat yields the
digits of Pi as needed. The streaming algorithm based on Lambert’s expression
is used for the generator function.>>> from pidigits import piGenerator
>>> mypi = piGenerator()
>>> first20pi = [next(mypi) for i in range(20)]
>>> first20pi
[3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 8, 9, 7, 9, 3, 2, 3, 8, 4]Example: Verify theFeynman point.>>> mypi = piGenerator()
>>> first1001 = [next(mypi) for i in range(1001)]
>>> feynman = first1001[762:768]
>>> print feynman
[9, 9, 9, 9, 9, 9]Alternatively you can also use thegetPi(n)function to get the firstndigits of Pi.>>> from pidigits import getPi
>>> first20pi = getPi(20)
>>> first20pi
[3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 8, 9, 7, 9, 3, 2, 3, 8, 4]Alternate implementations of streaming algorithms based on Leibniz series and
Gosper’s series are also available as generator functionspiGenLeibnizandpiGenGosperand correspondinggetPiLeibnizandgetPiGosperfunctions.
These implementations are slower than the one based on Lambert’s series.Pidigits also provides a generator function nametauGeneratorthat yields the
digits ofTauas needed.>>> from pidigits import tauGenerator
>>> mytau = tauGenerator()
>>> first20tau = [next(mytau) for i in range(20)]
>>> first20tau
[6, 2, 8, 3, 1, 8, 5, 3, 0, 7, 1, 7, 9, 5, 8, 6, 4, 7, 6, 9]Alternatively you can also use thegetTau(n)function to get the firstndigits of Tau.DevelopmentIf you clone the repository (GitHub,BitBucket) and make any changes to
the algorithm you can run the test cases in the _tests package included with
the source to test your changes.To run the tests, in the same directory assetup.py, first run:>>> python setup.py developThis will install the package in the ‘development’ mode. Then run the
test cases:>>> python setup.py testBug reportsor suggestions are most welcome.Licensepidigits is licensed underApache License 2.0.
Package: pi-display-webthing
pi_display_webthingA web connected LCD display moduleThis project provides awebthing APIto an I2C LCD module such as aHD44780 1602 LCD Moduleon the Raspberry Pi.
As a webthing, the LCD can be discovered and controlled byhome automation systemsor custom solutions supporting the webthing API.The pi_display_webthing exposes an http webthing endpoint which supports controlling the display via http. E.g.# webthing has been started on host 192.168.0.23

curl http://192.168.0.23:8070/properties 

{
    "text": "Hello\n\rraspi",
    "upper_layer_text": "Hello\n\rraspi",
    "upper_layer_text_ttl": -1,
    "middle_layer_text": "uploaded: 41",
    "middle_layer_text_ttl": -1,
    "lower_layer_text": "",
    "lower_layer_text_ttl": -1
}Here, the textHello\n\rraspiwill be displayed. The text of the middle layeruploaded: 41will be covered by the upper layer.
If the text of the upper layer will be cleaned, the displayed text isuploaded: 41.
By setting the ttl of the layer, the text of the layer will be disappear after expiration of the ttl. Value -1 means that ttl is deactivated.The text of a dedicated layer can be updated as shown belowcurl -v -X PUT  -d "{\"upper_layer_text\": \"Hello world\"}" http://192.168.1.101:8088/properties/upper_layer_textThe RaspberryPi/LCD hardware setup and wiring may look likeHD44780 1602 LCD module. By default,
Raspberry Pi OS disables I2C. Please referConfigure I2Cto activate I2C and to
detect the address of the LCD module.To install pi_display_webthing you may useDockerorPIPpackage manager such as shown belowDocker approachsudo docker run -p 8070:8070 --device /dev/i2c-1:/dev/i2c-1 -e i2c_expander=PCF8574 -e i2c_address=0x27  grro/pi_display_webthing:0.1.0PIP approachsudo pip install pi_display_webthingAfter this installation you may start the webthing http endpoint inside your python code or via command line usingsudo display --command listen --port 8070 --i2c_expander PCF8574 --i2c_address 0x27Here, the webthing API will be bind on port 8070 using a 2/16 display layout on address 0x27.
Further more the port I2C port expander name has to be set. The expander name should be written on the microchip.
Supported port expanders arePCF8574,MCP23008andMCP23017Alternatively to thelistencommand, you can use theregistercommand to register and start the webthing service as systemd unit.
By doing this the webthing service will be started automatically on boot. Starting the server manually using thelistencommand is no longer necessary.sudo display --command register --port 8070 --i2c_expander PCF8574 --i2c_address 0x27
Package: pidlock
pidlockSimple PID based locking for cronjobs, UNIX scripts or python programs.  Copes with locking between hosts.Requirementrequires python3UsageInstall with pipsudo pip install -U pidlockUse it from inside python scriptimport time
from pidlock import PIDLock

locker = PIDLock()
with locker.lock('sleepy_script'):
    time.sleep(10)Use it as commandline/cron job# To display help menu
pidlock -h    # Or pidlock --help

# Example usage
pidlock -n sleepy_script -c 'sleep 10'

# Same as
pidlock --name sleepy_script --command 'sleep 10'Customization:You can pass PID file location, verbosity, time limit and minimum interval as arguments# Python Usage
locker = PIDLock(lockdir='~/.pidlock', verbose=True)

with locker.lock('sleepy_script', wait=10, mininterval=1):
    time.sleep(10)# Commandline usage
pidlock -n sleepy_script -c 'sleep 10' -l ~/.pidlock -v -w 10 -m 1

# Same as
pidlock --name sleepy_script --command 'sleep 10' --lockdir ~/.pidlock --verbose --wait 10 --mininterval 1ContributionsOriginally written and published byArijit Basu.  Adaptation to cope with race conditions
by Keiran Raine (ongoing owner/support).
Package: pidlockfile
pidlockfile: PID lock file module for use with python-daemonThis module is a replacement for ‘python-daemon’ pidfile module.
TimeoutPIDLockFile class from pidfile implements “advisory” locking.
Essentially, it does not really lock anthing. It simply checks lock file
existence and, as a result, it can’t detect certain situations like
server process crush and release the lock.This module uses python’s fcntl facility to lock the PID file. That
means that is if daemon process is terminated unexpectedly, lock is
automatically released and daemon can be restarted.InstallationpipinstallpidlockfileRunning unit testsFrom the project top level directory execute:python-munittestdiscover-v
Package: pidng
PiDNGCreate Adobe DNG RAW files using Python.Features8,10,12,14,16-bit precisionLossless compressionDNG Tags ( extensible )Works with anyBayer RAWData including native support forRaspberry Pi cameras.OV5467 ( Raspberry Pi Camera Module V1 )IMX219 ( Raspberry Pi Camera Module V2 )IMX477( Raspberry Pi High Quality Camera )InstructionsRequires:Python3NumpyInstallFrom PyPI:python3 -mpip install PiDNGLatest version from GitHub:python3 -mpip install  git+https://github.com/schoolpost/PiDNG.gitCreditsSource referenced from:CanPi ( Jack ) |color-matricesWaveform80 |picameraKrontech |chronos-utilsAndrew Baldwin |MLVRawViewer