Saravanan666/pypi-org huggingface dataset:
Package: piland-http-health-checker
piland-http-health-checkerA CLI application to check the health of a set of HTTP endpoints from a YAML file using the Typer library.Reads a selected file with a list of HTTP endpoints in YAML format.Tests the health of the endpoints every 15 seconds.Keeps track of the availability percentage of the HTTP domain names being monitored by the program.Logs the cumulative availability percentage for each domain to the console after the completion of each 15-second test cycle.PrerequisitesPython: 3.12Installation and QuickstartInstalling via PyPIYou can install this application using PyPI:$pipinstallpiland-http-health-checkerThen to run it, execute the following in the terminal:$piland-http-health-checkerrun-programUsing the ApplicationSelect the YAML file to load in the file dialogThe availablity percentage of the domain(s) will log to the console every 15 secondsTo exit the program, press 'ctrl + C'Usage:$piland-http-health-checker[OPTIONS]COMMAND[ARGS]...Options:--install-completion: Install completion for the current shell.--show-completion: Show completion for the current shell, to copy it or customize the installation.--help: Show this message and exit.Commands:rick: Do not run this commandrun-program: Runs program on a looppiland-http-health-checker rickDo not run this commandUsage:$piland-http-health-checkerrick[OPTIONS]Options:--help: Show this message and exit.piland-http-health-checker run-programRuns program on a loopUsage:$piland-http-health-checkerrun-program[OPTIONS]Options:--help: Show this message and exit.
Package: pilapse
PiLapseA simple time-lapse service for Raspberry Pi. It usesraspistillbinary to capture images. It's currently capable of periodically capturing of still images and serving last captured image to the web browser.Installation and usagerequires Python3Using Pipsudoaptupdate
sudoaptinstallpython3-pip
pip3installpilapse--user# If your ~/.local/bin directory was created only during install# you will likely need to re-login or update your PATH variable to include itexportPATH=$HOME/.local/bin:$PATH# Start the servermkdir~/my-timelapse
pilapse--port8888--path~/my-timelapse--period60Manualgitclonehttps://github.com/yix/pilapsecdpilapse
sudoaptinstallpython3-pip
pip3install-rrequirements.txt--user# Start the servermkdir~/my-timelapse
python3-mpilapse--port8888--path~/my-timelapse--period60
Package: pilapserec
pilapsePython module to capture time lapse videos on Raspberry PiExamplesInstallationIt's recommended to create a virtual environment:python-mvenvpilapsecdpilapsesourcebin/activateYou can simply installpilapsefrom PyPi:pipinstallpilapserecUsageTo capture an image only (can be used to check the camera beforehand):pilapsecaptureTo record a long video:pilapserecordTo make a video out of captured images:pilapsecompileHowever, you are advised against video compiling directory on Raspberry Pi, as the system resource may run low and you are almost certainly to be kicked out of the SSH session. For the same reason, you are advised against using the--auto-compileswitch. After record session, you can plug the microSD card into your main work station and compile them there.For more options, refer to--helpcommand:(pilapse)aki@hakune:~/pilapse$pilapse--help
piLapse-capturetimelapsevideoonRaspberryPi.

Usage:pilapsecapture[-i<image-name>][-s<save-dir>][--no-time][--verbose]pilapserecord[-d<duration>|-c][-f<frequency>][-l<length>][-w<width>][-s<save-dir>][-S<wait-time>][--auto-compile][-o<video-name>][-F<fps>][--no-time][--preserve][--verbose]pilapsecompile[-s<save-dir>][-o<video-name>][-F<fps>][--preserve][--verbose]pilapseclean[-s<save-dir>]pilapse(-h|--help)pilapse--version

Actions:
captureTake1imageonly.
recordRecordatimelapsevideo.
compileCompilelabelledimagesintoavideo.

Options:
-h--helpShowthisscreen.
-c--continuousSettocontinuouslyrunmode.
-d--durationDURATIONSetrecordingduration(byseconds)[default:600].
-f--frequencyFREQUENCYSettimeintervalbetweenshots(byseconds)[default:5].
-F--fpsFPSSetfinalvideofps[default:24].
-l--lengthLENGTHSetimagelengthdimension(bypixel)[default:3280].
-w--widthWIDTHSetimagewidthdimension(bypixel)[default:2464].
-s--save-dirSAVINGDIRSetworkingandsavingdirectory[default:~/Videos/pilapse].
-S--shutter-waitTIMESettimerbeforestartcapturing(byseconds)[default:0].
-i--image-nameNAMESetimagenameincapturemode[default:image.jpg].
-o--output-videoNAMESetoutputvideoname.
-a--auto-compileAutomaticallycompileimages[default:True].
-p--preserveDonotautomaticallycleanupafterrecording.
-n--no-timeDonotaddtimeincapturemode.
--verboseSettoverbosemode.
--versionShowversion.To keep the process running after log out of SSH, you can usescreenortmux:sudoaptinstalltmux
tmux
pilapserecordIf you encounternumpyerror while making videos on Raspberry Pi, run this command and try to compile again:sudoaptinstalllibatlas-base-devffmpegDevelopmentAny contribution is deeply appreciated.
Package: pilar
PILARPython Interface to Land Atmosphere Reservoir modelAlways start the README explaining clearly what your package do.  If
you can include here some beautiful image to call the attention of the
potential user do it!This is an example:Download and installDescribe here how the package can be downloaded and install it in
different arquitectures.If you are usingPyPIinstallation it's as simple as:pip install pilarQuick startIn this section you should provide the most simple instructions to use
your package.For instance:import pilar
print(pilar.version)Code examplesProvide some detailed examples for more advanced users.For instance:import pilar
obj = MyClass()What's newIf your package will be frequently updated with new features include a
section describing the new features added to it:Version 0.0.*:First version of the package.This package has been designed and written by Fulanit@ de Tal (C) 202X
Package: pilclock
PilClockPilClock - LED based Raspberry PI ClockFree software: GNU General Public License v3Documentation:https://pilclock.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2019-04-23)First release on PyPI.
Package: pil-compat
_ _                                       __ __ (_) |       ___ ___  _ __ ___  _ __   __ _| |_| '_ \| | |_____ / __/ _ \| '_ ` _ \| '_ \ / _` | __|| |_) | | |_____| (_| (_) | | | | | | |_) | (_| | |_| .__/|_|_|      \___\___/|_| |_| |_| .__/ \__,_|\__||_|                                 |_|pillow has modules named PIL.Image*. PIL has them as Image.*.This is a package which shims between the two.Run `materialise.py` to generate the Image* modules in source, and `setup.py`can then generate your wheel or sdist.Email me if you have confusion: alistair@alynn.co.uk
Package: pilecap
Pile CapA stable foundation for reproducible buildsValue propositionThis project aims to be both a map and a vehicle to reproducible builds.
It adopts the progressive disclosure pattern to accommodate both novices and veterans.
For the noviceporcelaincommands can be used to set up a simple workflow.
For the veteranplumbingcommands can be combined with other tools such aspipandpip-toolsto create more complicated workflows.It also throws in support for sharing constraints between projects to make it easier installing them into the same environment.AlternativesThe functionality of this package is mostly implemented by many other packages but none implements all of itpiphas virtually no support for locking python versions.pip-toolscannot readbuild-system.requires,has no option to include all extras, andleaves it to the user to correctly use constraints files correctly with pip.pipenvmakes no attempt at supporting multiple, concurrent environments.poetrydoes not allow advanced use cases such as sharing constraints between projects.
(admittedly I have not looked closely).bazel/pantsprobably provide better reproducibility but require a significant departure from the workflows that are familiar from many open source projects.InstallationTheinstallcommand works without any dependencies making it possible to bootstrappilecaplikepipinstall--no-deps'pilecap==x.y'pilecapinstallpilecap
Package: piles
The goal of piles is provide lightweight, turnkey, extensible composite data
structures.piles's framework supports a wide range of coding styles. You can create
complex multiple inheritance structures with mixins galore or simpler,
compositional objects. Even though the data structures are necessarily object-
oriented, all of the tools to modify them are also available as functions, for
those who prefer a more funcitonal approaching to programming.The project is also highly documented so that users and developers and make
piles work with their projects. It is designed for Python coders at all
levels. Beginners should be able to follow the readable code and internal
documentation to understand how it works. More advanced users should find
complex and tricky problems addressed through efficient code.
Package: pilgram
pilgramA python library for instagram filters.The filter implementations are inspired byCSSgram.RequirementsPython >= 3.4Pilloworpillow-simdInstallpipinstallpillow>=4.1.0# or pip install pillow-simdpipinstallpilgramUsageAvailable instagram filters onpilgram:_1977adenbrannanbrooklynclarendonearlybirdginghamhudsoninkwellkelvinlarklofimavenmayfairmoonnashvilleperpetuareyesriseslumberstinsontoastervalenciawaldenwillowxpro2fromPILimportImageimportpilgramim=Image.open('sample.jpg')pilgram.aden(im).save('sample-aden.jpg')Similarly, pilgram provides css filters and blend modes as a by-product.Available css filters onpilgram.css:contrastgrayscalehue_rotatesaturatesepiafromPILimportImageimportpilgram.cssim=Image.open('sample.jpg')pilgram.css.sepia(im).save('sample-sepia.jpg')Available blend modes onpilgram.css.blending:colorcolor_burncolor_dodgedarkendifferenceexclusionhard_lighthuelightenmultiplynormaloverlayscreensoft_lightfromPILimportImageimportpilgram.css.blendingbackdrop=Image.open('backdrop.jpg')source=Image.open('source.jpg')pilgram.css.blending.color(backdrop,source).save('blending.jpg')Demonotebooks/example.ipynbFilter performance comparison withinstagram-filtersnotebooks/filter-performance-comparison.ipynbTestpipenvinstall--dev
maketest# pytestmaketest-tox# pytest with tox
Package: pilgram2
pilgram2A python library for instagram filters.The filter implementations are inspired byCSSgram.
Pilgram2 was forked frompilgram.
Pilgram2 features more filter and supports non-quadratic images.RequirementsPython >= 3.8Pilloworpillow-simdNumPyInstallpipinstallpillow# or pip install pillow-simdpipinstallnumpy
pipinstallpilgram2Usage39 available instagram filters onpilgram2, 14 filters new to pilgram2 compared to pilgram:_1977adenashby(new in pilgram2)amaro(new in pilgram2)brannanbrooklyncharmes(new in pilgram2)clarendoncrema(new in pilgram2)dogpatch(new in pilgram2)earlybirdginghamginza(new in pilgram2)hefe(new in pilgram2)helena(new in pilgram2)hudsoninkwelljuno(new in pilgram2)kelvinlarklofiludwig(new in pilgram2)mavenmayfairmoonnashvilleperpetuapoprocket(new in pilgram2)reyesrisesierra(new in pilgram2)skyline(new in pilgram2)slumberstinsonsutro(new in pilgram2)toastervalenciawaldenwillowxpro2fromPILimportImageimportpilgram2im=Image.open('sample.jpg')pilgram2.aden(im).save('sample-aden.jpg')Similarly, pilgram2 provides css filters and blend modes as a by-product.Available css filters onpilgram2.css:contrastgrayscalehue_rotatesaturatesepiafromPILimportImageimportpilgram2.cssim=Image.open('sample.jpg')pilgram2.css.sepia(im).save('sample-sepia.jpg')Available blend modes onpilgram2.css.blending:colorcolor_burncolor_dodgedarkendifferenceexclusionhard_lighthuelightenmultiplynormaloverlayscreensoft_lightfromPILimportImageimportpilgram2.css.blendingbackdrop=Image.open('backdrop.jpg')source=Image.open('source.jpg')pilgram2.css.blending.color(backdrop,source).save('blending.jpg')Testpipenvinstall--dev
maketest# pytest
Package: pilgrimor
pilgrimorDatabase migration tool with versioning
for python projectsInstallation:with pippip install pilgrimorwith poetrypoetry add pilgrimorUsage:Main commands:initdb- create technical migrations table.apply- apply new migrations.apply —-version <version number>- apply new migrations with version.rollback —-version <version number>- rollback migrations to version inclusive.rollback —-latest- rollback to latest version.Necessary thingsYou need to specify some fields in your pyproject.toml[tool.pilgrimor]
migrations_dir = "./migrations/"
database_engine = "PSQL"
env_file = "./.env"migrations_dir - folder with migrations
database_engine - there is only one database engine PSQL
env_file = path to .env fileMigration file structure:Migration file contains two blocks - apply and rollback with sql commands.
For example:—- apply —-
SQL CODE

—- rollback —-
SQL CODE
Package: pilibre
A small Python script for displaying hardware metrics. Metrics are pulled fromLibreHardwareMonitor, and requires it to be installed on your PC and in server mode. It is designed to be run on a small computer with a small display. I intend to use a Raspberry Pi, but you could likely use something else.InstallationPiLibre relies onrichandhttpxon the display machine, andLibreHardwareMonitoron the machine from which you want to see metrics.rich: For terminal display of the hardware metricshttps: To pull the JSON data served byLibreHardwareMonitorLibreHardwareMonitor: For getting the hardware metrics of your computer.Host Machine SetupThe host machine only needs to haveLibreHardwareMonitorinstalled. The project can be found here:https://github.com/LibreHardwareMonitor/LibreHardwareMonitorand downloaded from here:https://github.com/LibreHardwareMonitor/LibreHardwareMonitor/releases.Once installed:Open the HTTP server viaOptions -> HTTP Server.Take note of the IP address. This is the IP address of the local machine.If you'd like to change the default port, do so here.Display Machine SetupThe machine you want to display metrics on needs to have thePiLibreapplication installed. The easiest way is to usepipx, but manual instructions are also included.pipxpipxis recommended for the simplest installation. This will installPiLibreinto its own virtual environment, along with any dependencies.Installpipxfrom here:https://github.com/pypa/pipx#install-pipx.pipxinstallgit+https://github.com/acbuie/pilibre.gitManuallyIf you know what you're doing, you can install the package viaGitand run it manually, withpython -m src/pilibre. As always, a virtual environment is recommended, so the requirements don't get installed into the system python. Runtime dependencies can be installed withpython -m pip install requirements.txt.First, clone the project into a new directory.mkdirpilibrecdpilibre
gitclonehttps://github.com/acbuie/pilibre.gitOnce installed, create and activate a python virtual environment. Read about python virtual environments here:https://docs.python.org/3/tutorial/venv.html.Then, install the dependencies.python-mpipinstallrequirements.txtUsageUsage is very simple. Once the HTTP server is running on the host machine, simply specify the IP address and port in the config file and run the project.
Package: pilight
# A pure python client to connect to a pilight daemon[![Build Status](https://travis-ci.org/DavidLP/pilight.svg?branch=master)](https://travis-ci.org/DavidLP/pilight)[![Coverage Status](https://coveralls.io/repos/github/DavidLP/pilight/badge.svg?branch=master)](https://coveralls.io/github/DavidLP/pilight?branch=master)This client interfaces with the `pilight-daemon` to send and receive RF codes (https://www.pilight.org/).Sending and receiving is implemented in an asychronous way. A callback function can be definedthat reacts on received data. Automatic acknowledge if the send data was transmitted by the pilight-daemonis implemented.All `pilight-send` commands can be used by this client (https://wiki.pilight.org/doku.php/psend).The API is mentioned here: https://manual.pilight.org/en/api.# InstallationThe latest release is hosted on PyPi. Thus for installation type:```pip install pilight```Otherwise download the code and```python setup.py install```You can run the unit tests to check the installation```nosetests pilight```# Usage```from pilight import pilightpilight_connection = pilight.Client()  # Connect to the pilight-daemon at localhost:5000pilight_connection.send_code(data={"protocol": [ "kaku_switch" ],  #  https://manual.pilight.org/en/api"id": 1,"unit": 0,"off": 1})```Also check the examples folder.
Package: pilight2mqtt
Proxy messages between pilight and mqttTips & TricksQ: Autodiscovery fails, what is the port to use?A: You can specify the port pilight listens on in the pilight configuration
under settings, port.https://manual.pilight.org/en/configuration-settings#pf2Remember to first stop pilgith and only modify the settings afterwards. At least
for me pilight will overwrite the configuration with its current values when shutting
down.Build StatusRequirementsPython 3.4+
Package: pi-lightsensor-webthing
pi_lightsensor_webthingA web connected digital light sensor measuring the intensity of ambient light on Raspberry PiThis project provides awebthing APIto a digital light sensor such asBH1750.
Please consider toactivate I2Con raspberry pi.The pi_lightsensor_webthing package exposes an http webthing endpoint which supports measuring the intensity of ambient light via http. E.g.# webthing has been started on host 192.168.0.23

curl http://192.168.0.23:9122/properties 

{
   "brightness": 100
}Regarding the RaspberryPi/digital light sensor hardware setup and wiring please refer tutorials mentioned aboveTo install this software you may useDockerorPIPpackage manager such as shown belowDocker approachsudo docker run --privileged -p 9122:9122 grro/pi_lightsensor_webthingPIP approachsudo pip install pi_lightsensor_webthingAfter this installation you may start the webthing http endpoint inside your python code or via command line usingsudo lightsensor --command listen --port 9122Here, the webthing API will be bind to the local port 9122Alternatively 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 lightsensor --command register --port 9122
Package: pilk-clicker
pilk-clickerLibrary for working api pilk-clicker.ruInstallationpipinstallpilk-clickerUsageGet token (login)frompilk_clicker.apiimportAuthfrompilk_clicker.interfaces.authimportILoginRequestcredentials=ILoginRequest(username="",password="")response=Auth.login(credentials)response.auth_tokenLogoutfrompilk_clicker.apiimportAuthfrompilk_clicker.interfaces.authimportITokenRequestcredentials=ITokenRequest(authorization="token")Auth.logout(credentials)Logupfrompilk_clicker.apiimportAuthfrompilk_clicker.interfaces.authimportILogupRequestcredentials=ILogupRequest(username="",password="",email="")response=Auth.logup(credentials)clicker detailfrompilk_clicker.apiimportClickerfrompilk_clicker.interfaces.authimportITokenRequestcredentials=ITokenRequest(authorization="token")response=Clicker.clicker_detail(credentials)top listfrompilk_clicker.apiimportClickerfrompilk_clicker.interfaces.authimportITokenRequestcredentials=ITokenRequest(authorization="token")response=Clicker.top_list(credentials)save clickerfrompilk_clicker.apiimportClickerfrompilk_clicker.interfaces.authimportITokenRequestfrompilk_clicker.interfaces.clickerimportIClickerSaveRequestcredentials=ITokenRequest(authorization="token")data=IClickerSaveRequest(arcoin_amount=1,arcoins_per_click=1,arcoins_per_seconds=1)response=Clicker.save_clicker(data,credentials)shop userfrompilk_clicker.apiimportShopfrompilk_clicker.interfaces.authimportITokenRequestcredentials=ITokenRequest(authorization="token")response=Shop.shop_user(credentials)save itemfrompilk_clicker.apiimportShopfrompilk_clicker.interfaces.authimportITokenRequestfrompilk_clicker.interfaces.shopimportISaveItemRequestcredentials=ITokenRequest(authorization="token")items=Shop.shop_user(credentials)foriteminitems:Shop.save_item(ISaveItemRequest(id=item.id,amount=item.amount+1),credentials)
Package: pilkit
PILKit is a collection of utilities for working with PIL (the Python Imaging
Library).One of its main features is a set ofprocessorswhich expose a simple
interface for performing manipulations on PIL images.Looking for more advanced processors? Check outInstakit!For the complete documentation on the latest stable version of PILKit, seePILKit on RTD.InstallationInstallPILorPillow.Runpip install pilkit(or clone the source and put the pilkit module on
your path)NoteIf you’ve never seen Pillow before, it considers itself a
more-frequently updated “friendly” fork of PIL that’s compatible with
setuptools. As such, it shares the same namespace as PIL does and is a
drop-in replacement.Usage OverviewProcessorsThe “pilkit.processors” module contains several classes for processing PIL
images, which provide an easy to understand API:frompilkit.processorsimportResizeToFitimg=Image.open('/path/to/my/image.png')processor=ResizeToFit(100,100)new_img=processor.process(img)A few of the included processors are:ResizeToFitResizeToFillSmartResizeAdjustTrimBorderColorTransposeThere’s also aProcessorPipelineclass for executing processors
sequentially:frompilkit.processorsimportProcessorPipeline,ResizeToFit,Adjustimg=Image.open('/path/to/my/image.png')processor=ProcessorPipeline([Adjust(color=0),ResizeToFit(100,100)])new_image=processor.process(img)UtilitiesIn addition to the processors, PILKit contains a few utilities to ease the pain
of working with PIL. Some examples:prepare_imagePrepares the image for saving to the provided format by doing some
common-sense conversions, including preserving transparency and quantizing.save_imageWraps PIL’sImage.save()method in order to gracefully handle PIL’s
“Suspension not allowed here” errors, and (optionally) prepares the image
usingprepare_imageUtilities are also included for converting between formats, extensions, and
mimetypes.CommunityPlease usethe GitHub issue trackerto report bugs.A mailing listalso exists to discuss the project and ask questions, as well as the official#imagekitchannel on Freenode. (Both of
these are shared with thedjango-imagekitproject—from which PILKit spun
off.)
Package: pilkommedia
Modul PyPI PilkommediaModul ini berisikan data serta fungsi-fungsi yang digunakan untuk keperluan perkuliahan di Program Studi Pendidikan Komputer FKIP ULM Banjarmasin.Untuk saat ini teradpat satu sub modul, yakni data statistik iwak papuyu dengan beberapa fungsi yang dapat digunakan, yakni sebagai berikut.get_data(header=False)get_header()get_data_by_column(column_name)average(column_name)median(column_name)modes(column_name)
Package: pillar
Pillar: Building Blocks for Python ApplicationsPillar provides resusable components for building command-line applications. No more copy-pasting boilerplate forloggingorargparsejust to get bare-bone features.In particular Pillar focusses on providing components for applications that are run as services, background tasks, or scheduled jobs (e.g. cron jobs).DocumentationDocumentationQuickstart GuideChange LogLicenceThis project is licenced under the MIT Licence - seeLICENCE.This project may include other open source licenced software - seeNOTICE.AuthorsA project by Nicholas Hairs -www.nicholashairs.com.