Saravanan666/pypi-org huggingface dataset:
Package: pigstep
pigstepA beet plugin for importing songs into Minecraft.IntroductionThisbeetplugin lets you include songs created withOpen Note Block Studioin your project. It takes care of converting.nbsfiles to data packs.FeaturesKeep.nbsfiles alongside the rest of your projectEmbed note block studio songs into your output data packAutomatically bundle extra notes when needed to support 6 octavesEfficient function tree generation and chord deduplicationFlexible, can be used for making custom visualizersWhy not just export from Note Block Studio directly?It's a bit more convenient to set up the plugin once and then have it automatically convert the latest version of the songLess clutter, you can forget about having to navigate around the generated filesThe plugin bundles the sound files required by your songs, no need to remember to activate the extra notes resource pack or to copy the sounds you need when you start using themInstallationThe package can be installed withpip.$pipinstallpigstepUsageThe plugin generates scoreboard objectives that must be included in the output data pack. If you're not using it already, running thebeet.contrib.scoreboardplugin at the end of the pipeline will create a function that adds all the generated objectives for you.{"pipeline":["pigstep","beet.contrib.scoreboard"],"meta":{"pigstep":{"load":["*.nbs"],"source":"ambient","templates":{"play":"custom_play.mcfunction"}}}}You can require the plugin programmatically by using thepigstepplugin factory.frombeetimportContextfrompigstepimportpigstepdefmy_plugin(ctx:Context):ctx.require(pigstep(load=["*.nbs"],source="ambient",templates={"play":"custom_play.mcfunction"},))All the configuration is optional. The plugin is a no-op if theloadoption is not specified or empty. Thesourceoption defaults torecord. Thetemplatesoption lets you override the templates used by the plugin.Here are the functions generated for each song:{namespace}:song/{song_name}/play- Play the song{namespace}:song/{song_name}/pause- Pause the song, to resume run the play function again{namespace}:song/{song_name}/stop- Stop the song, playing the song again will start from the beginningContributingContributions are welcome. Make sure to first open an issue discussing the problem or the new feature before creating a pull request. The project usespoetry.$poetryinstallYou can run the tests withpoetry run pytest.$poetryrunpytestThe project must type-check withpyright. If you're using VSCode thepylanceextension should report diagnostics automatically. You can also install the type-checker locally withnpm installand run it from the command-line.$npmrunwatch
$npmruncheckThe code follows theblackcode style. Import statements are sorted withisort.$poetryrunisortpigsteptests
$poetryrunblackpigsteptests
$poetryrunblack--checkpigsteptestsLicense -MIT
Package: pigweed
PigweedPigweed is an open source collection of embedded-targeted libraries–or as we
like to call them, modules. These modules are building blocks and infrastructure
that enable faster and more reliable development on small-footprint MMU-less
32-bit microcontrollers like the STMicroelectronics STM32L452 or the Nordic
nRF52832.For more information please see our website:https://pigweed.dev/.LinksDocumentationSource CodeCode ReviewsMailing ListChat RoomIssue Tracker
Package: pigz-python
pigz-pythonThe goal of this project is to create a pure Python implementation of the pigz project for parallelizing gzipping.Usage examplespigz-python can be utilized by creating aPigzFileobject and calling theprocess_compression_target()method.frompigz_pythonimportPigzFilepigz_file=PigzFile('foo.txt')pigz_file.process_compression_target()Alternatively, the pigz_python module also provides a convenient helper method to do all of this work for you.importpigz_pythonpigz_python.compress_file('foo.txt')
Package: pi-hcsr501
pi_hcsr501Library for playing around with hcsr501 PIR motion sensor with Raspberry Pi.Usagefrompi_hcsr501importHcSr501HCSR501=HcSr501()whileTrue:print(str(HCSR501.active)+" ",end="\r")sleep(0.5)TestingRun unit tests with command:cdpi_hcsr501

python3-munittestdiscover-stst/Get test coverage with commands:cdpi_hcsr501

coveragerun-munittestdiscover-stst/
coveragereport-m
Package: pihdf
pihdf: Python Hardware Design Framework based on MyHDL======================================================.. image:: https://travis-ci.org/hnikolov/pihdf.svg?branch=master:target: https://travis-ci.org/hnikolov/pihdfA very preliminary documentation (work-in-progress) is available at: http://hnikolov.github.io/pihdf_doc/Install ``pihdf`` using pip---------------------------You can install the latest release of ``pihdf`` from pypi: ::$ sudo pip install pihdf**Note:** If you do not have ``pip`` installed: ::$ sudo apt-get install python-pip python-dev build-essential$ sudo pip install --upgrade pipInstall ``pihdf`` from source---------------------------If you plan to contribute to ``pihdf``, then install it from source: ::$ git clone https://github.com/hnikolov/pihdf$ cd pihdf$ sudo python setup.py developOption *develop* installs ``pyhdf`` in *editable* mode.This is very convenient because your changes are immediately reflected into the installed ``pihdf`` package.This means that you do not need to re-install ``pihdf`` in order your changes to take effect.Dependences on Python packages------------------------------``pihdf`` requires the following python packages: **myhdl, myhdl_lib, simplejson, coverage, nose**.These packages will be installed during the installation of ``pihdf`` if not present on your system.**Note:** These packages will **not** be un-installed if you un-install ``pyhdf``.Co-simulation, waveform and dotty viewers-----------------------------------------For co-simulations, ``pihdf`` uses the **Icarus iverilog** simulator. **GTKWave** is the waveform viewer used in ``pihdf``. For structured designs, ``pihdf`` generates also the design topology (i.e., HW modules interconnections) as a ``.dot`` file. To viasualize it, you can use the ``xdot`` program. Install all programs by executing: ::$ sudo apt-get install iverilog gtkwave xdotCreate ``myhdl.vpi``------------------For co-simuations, myhdl uses a ``.vpi`` interface. To create the ``myhdl.vpi`` file used with **Icarus**, you need the source of ``myhdl``: ::$ git clone https://github.com/jandecaluwe/myhdl$ make -C myhdl/cosimulation/icarus$ sudo mkdir /.pihdf$ sudo cp myhdl/cosimulation/icarus/myhdl.vpi /.pihdf**Note:** ``pihdf`` expects file ``myhdl.vpi`` to be in folder ``/.pihdf``Un-install----------Un-installing ``pihdf`` (should you decide to do so) is easy. Depending on how you installed it, you can:Un-install ``pihdf`` using ``pip``: ::$ sudo pip uninstall pihdfOr, un-install ``pihdf`` if installed from source: ::$ cd pihdf$ sudo python setup.py develop --uninstallTo remove the command-line tool ``module`` from its location: ::$ which module | xargs sudo rmNote----The command-line tool ``module`` makes use of the very convenient package ``docopt`` (https://github.com/docopt/docopt), which is copied in the ``pihdf`` repository.
Package: pi-heif
pi-heifThis is a light version ofPillow-Heifwith more permissive license for binary wheels.It includes onlyHEIFdecoder and does not supportsaveoperations.All codebase are the same, refer topillow-heif docs.The only difference is the name of the imported project.Installpython3 -m pip install -U pippython3 -m pip install pi-heifExample of use as a Pillow pluginfromPILimportImagefrompi_heifimportregister_heif_openerregister_heif_opener()im=Image.open("images/input.heic")# do whatever need with a Pillow imageim.show()8/10/12 bit HEIF to 8/16 bit PNG using OpenCVimportnumpyasnpimportcv2importpi_heifheif_file=pi_heif.open_heif("image.heic",convert_hdr_to_8bit=False,bgr_mode=True)np_array=np.asarray(heif_file)cv2.imwrite("image.png",np_array)Get decoded image data as a Numpy arrayimportnumpyasnpimportpi_heififpi_heif.is_supported("input.heic"):heif_file=pi_heif.open_heif("input.heic")np_array=np.asarray(heif_file)WheelsWheels tablemacOSIntelmacOSSiliconWindows64bitmusllinux*manylinux*CPython 3.8✅✅✅✅✅CPython 3.9✅✅✅✅✅CPython 3.10✅✅✅✅✅CPython 3.11✅✅✅✅✅CPython 3.12✅✅✅✅✅PyPy 3.8 v7.3✅✅✅N/A✅PyPy 3.9 v7.3✅✅✅N/A✅PyPy 3.10 v7.3✅✅✅N/A✅*i686,x86_64,aarch64wheels.ARMv7l: wheels are present for Debian 11+(Ubuntu 20.04+) and Alpine 3.16/3.17/3.18
Package: pihole
Python API for interacting with aPi-Holeinstance.This module is not official, developed, supported or endorsed by Pi-hole LLC.InstallationThe module is available from thePython Package Index.$pip3installpiholeUsageThe fileexample.pycontains an example about how to use this module.DevelopmentFor development is recommended to use avenv.$python3.6-mvenv.$sourcebin/activate$python3setup.pydevelopLicensepython-piholeis licensed under MIT, for more details check LICENSE.
Package: pihole5-list-tool
pihole5-list-toolThis tool provides bulk operations to manage yourPi-hole 5Allow listsandBlock/Ad lists.Features:Allow listscan beaddedfromanudeepND's allowlist, files, or manual entryBlock/Ad listscan beaddedfromfirebog.net, files, or manual entryRemoveslists it adds (or all of them)Resetlists to Pi-hole defaultsStatsprovides some quick sums and groupingsDockerif you're running thepihole docker image(or one namedpihole), it should be detected
and offered as a default optionrequirementsworkingpi-hole 5+installationpython 3.7+(available by default on Raspbian 10, probably available on your system)installation$sudopip3installpihole5-list-tool--upgradeNote:If thepip3command doesn't work, try usingpipinstead. Here are additionaloptions /workarounds(and glimpses into Python peculiarities)Youmustusesudousage / runningSimply run:$sudopihole5-list-toolThis is what installing and running it basically looks like (many features have been added since this):supported sourcesTL; DR- some maintained online lists, anything you can paste, or a fileallowlistsCurrently the only source for maintained whitelists isanudeepND's allowlist. They are presented as:Allowlist Only- Domains that are safe to allow i.e does not contain any tracking oradvertising sites. This fixes many problems like YouTube watch history,
  videos on news sites and so on.Allowlist+Optional- These are needed depending on the service you use. They may contain sometracking sites but sometimes it's necessary to add bad domains to make a
  few services to work.Allowlist+Referral- People who use services like Slickdeals and Fatwallet need a few sites(most of them are either trackers or ads) to be whitelisted to work
  properly. This contains some analytics and ad serving sites like
  doubleclick.net and others. If you don't know what these services are,
  stay away from this list. Domains that are safe to whitelist i.e does
  not contain any tracking or advertising sites. This fixes many problems
  like YouTube watch history, videos on news sites and so on.ad/blocklistsCurrently the only source for maintained blocklists isfirebog.netNon-crossed lists: For when someone is usually around to whitelist falsely blocked sitesTicked lists: For when installing Pi-hole where no one will be whitelisting falsely blocked sitesAll lists: For those who will always be around to whitelist falsely blocked sitesfile/pasteBoth list types allow providing either apasted in listor afileas your source of lists.Finishing upAfter adding lists, they must be loaded by running:$pihole-gThis tool will offer to do that for you.When that finishes, you'll see each of listed in theWeb Admininterface along with a comment to help identify them.NOTE:If you need/want the blocklists added fromfirebog.net(and more) continually updated, check outpihole-updatelistswhich will also run great on a Pi.
Package: pi-hole-api
pi_hole_apiPython api module for pi-hole server (https://pi-hole.net/).
Execute api calls to py-hole server from python code.Installation# prod version:pipinstallpi-hole-api# dev version:pipinstall-ihttps://test.pypi.org/simple/pi-hole-apiExamplesCreate classimportpihole_apiaspipihole=pi.Pihole("PI_URL","PI_PSW")where:PI_URL: url of pi-hole pagePI_PSW: password of pi-holeor using environment variables "PI_URL" and "PI_PSW" set to pi-hole url and pi-hole password respectively:importosfromdotenvimportload_dotenvimportpihole_apiaspipihole=pi.Pihole(os.environ["PI_URL"],os.environ["PI_PSW"])Core modulePermit:enable/disable protectionpihole.enable()pihole.disable()pihole.disable(30)# disable per 30 secondsDns modulePermit:list dns recordsadd/remove A recordadd/remove CNAME recordpihole.dns("get")# print dns listpihole.cname("get")# print cname list# add domain to dnspihole.dns("add",ip_address="1.1.1.1",domain="pippo.com"))# remove domain to dnspihole.dns("delete",ip_address="1.1.1.1",domain="pippo.com"))# add cname from pippo.com to pluto.compihole.cname("add","pippo.com","pluto.com"))# remove cnamepihole.cname("delete","pippo.com","pluto.com"))List modulePermit:list/add/change/remove domains to white listslist/add/change/remove domains to black lists# get white listpihole.get_domains("white")# add to white listpihole.add_domain("white","pippo.it","add pippo")# replace in white listpihole.replace_domain("white","pippo.it","replace pippo")# delete from white listpihole.delete_domain("white","pippo.it","delete pippo")# get black listpihole.get_domains("black")# add to black listpihole.add_domain("black","pippo.it","add pippo")# add change in black listpihole.replace_domain("black","pippo.it","replace pippo")# delete from black listpihole.delete_domain("black","pippo.it","delete pippo")
Package: piianalyzer
PII Analyzer===========Analyzing PII in datasetsClassifying datasets and resources into ‘PII’ and ‘Not PII’.===========The task requires creation of a tool that will detect whether new datasets uploaded to HDX contain any personallyidentifiable information - data that can be used on its own or with other information to identify, contact, orlocate a single person, or to identify an individual in context.The tool should then alert the HDX data manager whether any such data sets have been uploadedand also alert the data owner about this.My Solution----I decided to use the following tools for the above task:1. `Pandas <https://github.com/pydata/pandas>`_: for reading the data files into python and manipulating the datasets.2. `Common Regular expressions <https://github.com/madisonmay/CommonRegex>`_: for extracting some types of 'PII' such as email addresses, phone numbers, street addresses,credit card numbers,3. `Stanford Named Entity Tagger <http://nlp.stanford.edu/software/CRF-NER.shtml>`_: for extracting the locations, organizations and peoples names.The analyzer opens the provided file, analyses it and returns a summary of the types of data that are in the provided dataset.With this information the data manager can easily classify the data.Usage----->>> from piianalyzer.analyzer import PiiAnalyzer>>> filepath = '/path/or/url/to/your/file.csv'>>> piianalyzer = PiiAnalyzer(filepath)>>> analysis = piianalyzer.analysis()Installation------------Requirements^^^^^^^^^^^^Requires the Stanford Named Entity Recognizer. It can be downloaded here: http://nlp.stanford.edu/software/CRF-NER.shtmlCompatibility-------------Licence-------TODO----* Reading other file types such as excel, text, html etc*Authors-------`piianalyzer` was written by `Savio Abuga <savioabuga@gmail.com>`_.
Package: piickle
The one true Pickler, it takes the pickle and encodes the bits and a space
and a pickle emoji.InstallationFrom PyPi:$ pip install piickleBasic UsageUse the library directly:importpiicklepiickle.dump(object,file)# Same as the python pickle.dump()piickle.dumps(object)# Same as the python pickle.dumps()piickle.load(file)# Same as the python pickle.load()piickle.loads(string)# Same as the python pickle.loads()or use the monkey patch feature:importpickleimportpiicklepickle.dump(object,file)pickle.dumps(object)pickle.load(file)pickle.loads(string)FeaturesA truly horrible pun
Package: piicodev
Core Electronics Unified PiicoDev LibraryUnified device libraries for the PiicoDev ecosystem of sensors and modules.
Built for MicroPython and Python.InstallationOn Raspberry Pi, run the following to install:sudopip3installpiicodevChanges- v1.10.0
	- Add support for PiicoDev Ultrasonic Rangefinder
	- Remove debug messages from PiicoDev_Servo.py
	- Add ESP32 warnings in PiicoDev_Unified.py
- v1.9.0 - Add support for PiicoDev Transceiver
- v1.8.0 - Add support for PiicoDev Servo Driver (PCA9685)
- v1.7.1 - Improve RFID robustness (allow incomplete text reads)
- v1.7.0 - Add support for PiicoDev Button (PiicoDev_Switch.py)
- v1.6.1 - Add support for Air-Quality Sensor ENS160
- v1.6.0 - Bad release, use v1.6.1
- v1.5.4 - Fix device ID address for PiicoDev potentiometers
- v1.5.3 - Force warning for unconfigured i2c on Raspberry Pi SBC for Potentiometer
- v1.5.2 - Add warning for unconfigured i2c on Raspberry Pi SBC
- v1.5.1 - Change device ID for Slide Potentiometer
- v1.5.0 - Add support for PiicoDev Potentiometers
- v1.4.0 - Add support for 3-Axis Accelerometer LIS3DH
- v1.3.1
	- VL53L1X: Rename change_id() to change_addr()
	- SSD1306: Add ASW argument to initialisation function
- v1.3.0
	- Add support for PiicoDev Real Time Clock RV-3028
	- Bugfix QMC6310: logging function
	- Bugfix RGB module: ensure brightness is an integer
- v1.2.2 - QMC6310: Change default sign to match silk screen
- v1.2.1 - Add support for PiicoDev RFID Module
- v1.2.0 - Bad release, use v1.2.1
- v1.1.3 - Add support for QMC6310
- v1.1.2 - No change - deployment test
- v1.1.1 - SSD1306: Add support for circles & arcs
- v1.0.1 
	- BME280: Add initialisation error handling
	- SSD1306: Remove PIL dependency (RPi SBC) and improve pbm file handling
- v1.0.0 - Initial releaseDevelopingTo install this package, along with the tools you need to develop and run tests, run the following (in your virtualenv:)sudopip3install-e.[dev]
Package: pii-crypt
Secures Personally Identifiable Information using AES (128/256 bit) key encryption.OverviewThepii_cryptwas written to help secure sensitive information.InstallationTo downloadpii_crypt, either fork this github repo
or simply use Pypi via pip.$pipinstallpii-cryptUsagefrompii_cryptimportPIICryptsecret_128bit_key='1234567812345678'pc=PIICrypt(secret_128bit_key)# Encrypt/Decryptencrypted=pc.encrypt('John Doe')print(encrypted)# VQd0JvSY8PTsszHEURT8xw==decrypted=pc.decrypt(encrypted)print(decrypted)# John DoeUnit Tests✘jay@ThinkPad~/pii_cryptmaster±coveragerun--source=.-munittest....----------------------------------------------------------------------Ran4testsin0.002sOKCode Coverage✘jay@ThinkPad~/pii_cryptmaster±coveragereport--omit=setup.pyNameStmtsMissCover--------------------------------------------pii_crypt/__init__.py10100%pii_crypt/pii_crypt.py190100%--------------------------------------------TOTAL200100%LicenseMIT LicenseCopyright (c) 2021Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the
“Software”), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Package: pii-data
pii-dataThis package provides base data structures for the management of PII i.e.
Personally Identifiable Information (it doesnotcontain code for processing
documents, or extracting PII from documents).For the full specification embodied by these base data structures, check the
PIISA Data Specification.Data structuresTwo main data types are defined to hold PII information: PII Entities and PII
Collections. There is also a Source Document data type.PII Source DocumentA PII Source Document defines the raw data from which PII is detected. This
document is modeled as a number of chunks, each one having an identifier and a
data contents (a raw text excerpt, or other types of content). This is managed
in this package by the SrcDocument class and subclasses.The package contains the capability to dump a Source Document to a local file,
following a standardized schema, and to read it back from the file. This schema
uses YAML as support file format, and is theonlydocument read capability
natively provided by the package (to read other formats into Source Document
objects there is an auxiliary pii-preprocess package, or you can implement
yout own).The package can also export documents as raw text files.PII CollectionA PII Collection contains a list of detected/extracted PII Entities. Each
entity contains all the information needed to correctly identify one PII
instance and locate it in the document it belongs to.These are the PII data classes defined:PiiEntity: a PII instance (which in turn contains aPiiEntityInfoobject)PiiCollection: the full collection of PII (the additionalPiiCollectionLoadersubclass can load a collection from a JSON file)PiiDetector: an object to describe the module used to generate a givenPiiEntityobjectOnline behaviourThere is partial support to use these data classes in an streaming fashion,
providing a way to feed data incrementally.
Package: pii-decide
Pii DecideThis repository builds a Python package providing evaluation & decision on
detected PII instances, by means of implemented "deciders", modules that
decide where a PII Instance is to be kept or it is to be ignored.Right now it is a (mostly) dummy package, and it incorporates only one simple
decider that takes care of removing overlapping PII Instances by following a
simple rule (if two instances overlap, it just retains the longest one)RequirementsThe package needsat least Python 3.8the pii-data base packageUsageThe package can be used:As an API, using the PiiDecider classAs a command-line toolBuildingThe provided Makefile can be used to process the package:make pkgwill build the Python package, creating a file that can be
installed withpipmake unitwill launch all unit tests (using pytest, so pytest must be
available)make installwill install the package in a Python virtualenv. The
virtualenv will be chosen as, in this order:the one defined in theVENVenvironment variable, if it is definedif there is a virtualenv activated in the shell, it will be usedotherwise, a default is chosen as/opt/venv/pii(it will be
created if it does not exist)