Saravanan666/pypi-org huggingface dataset:
Package: py4web-debug-tools
py4web debug toolsTooling to improve the developer experience when working with py4web.There are two main tools and some helpers that this package provides.A better error 500 screen, that shows the error + traceback of what happenedA debug bar containing the requests's data, queries including duplicate and custom caught data.In this package:tools:enable(db: DAL, enabled?: bool, errorpage_enabled?: bool, errorpage_renderer?: Callable, debugbar_enabled?: bool, debugbar_fancy_rendering?: bool, debugbar_style?: "bootstrap", debugbar_slow_threshold_ms?: int, set_env_var?: bool):activate or disable the debug tools (add the custom error screen and create the Debug Bar Fixture).The first argument (DAL) is required for the debug bar to collect queries.enabledcan be used to dynamically turn on/off the debug features.errorpage_enabledanddebugbar_enabledcan be used to turn on/off the error page and debug bar respectively.errorpage_renderercan be used to override the default error page renderer.debugbar_fancy_rendering: This will render thedatasection of the debug bar usingjson-browse, which
includesjQuery. If this clashes with the other JS on a page, this can be set to False to simply show a<pre>block with data.debugbar_style: only bootstrap is supported at this moment.debugbar_slow_threshold_ms: amount of milliseconds an SQL query has to take before it is considered a 'slow query' in the
debug bar.set_env_var: set thePY4WEB_DEBUGenvironment variable toTruewhen enabling the debug tools.debug_bar: this Fixture can be used on py4web actions to enable the bar for that page.catch(*): Data and a stacktrace of wherecatch()is called can be found in the catch tab of the debug bar.dump(*): convert objects to JSON, with a more capable converter than the default json.dumps (e.g. it works better
with NamedTuples, pyDAL Rows, objects with some variation ofas_dictand more. Seedumping.py:DDJsonEncoderfor
specifics)dd(*): Show a page with the data passed to this method and halt execution directly.wsgi: a patched version of py4web'swsgimodule, that will enable the modified error page.Example:# controllers.pyfrompy4web_debugimporttools,catch,dump,ddtools.enable(db,enabled=True)@action("index")@action.uses("index.html",db,tools.debug_bar)defindex():catch("Catch to Debug Bar")return{}@action("other")@action.uses("index.html",db)defpage_without_debugbar():dd("Stop executing here!")return{}@action("error")@action.uses("index.html",db)defpage_with_error():0/0return{}Caveats:When using uwsgi, the default method (in__init__) of changing py4web'scatch_errorswill not work.
This is because the routes are set up before this package can be enabled.
You can modify yourpy4web_uwsgi.pyfile:# no: from py4web.core import wsgi# yes:frompy4web_debugimportwsgiapplication=wsgi(apps_folder="apps",password_file='password.txt',dashboard_mode="full")After this, you cantools.enableas before.
Do note this process will keep py4web patched though, even whenenable(enabled=False)is passed!
Package: py50
py50py50 is used to generate dose-response curves. The package can be installed using the following:pip install py50SummaryThe project was created for laboratory use. I found many of my classmates/coworkers were
using a program that I found to be unfriendly to generate dose-response curves. I found
a few other repositories that can also generate dose-response curves in python, however,
they did not meet my requirements:Use Pandas for the Data so that it can be plugged into a typical Jupyter Notebook or Python scriptsAdaptable to user needsEasy to use (hopefully!)The curves are built on the four parameter logistic regression model:
$$Y = \text{Min} + \frac{\text{Max} - \text{Min}}{1 + \left(\frac{X}{\text{IC50}}\right)^{\text{Hill coefficient}}}$$
where min is the minimum response value, max is the maximum response value, Y is the response values of the curves, X
is the concentration.This project meets our needs. And hopefully it can meet the needs of others.Additional documentation can be found here. The repository and the tutorials can be found at the following:https://github.com/tlint101/py50
Package: py532lib
py532lib========This package contains the useful stuff to communicate with a PN532 NFC chip in Python.@author:  DanyO <me@danyo.ca>@license: The source code within this file is licensed under the BSD 2 Clause license.See LICENSE file for more information.Built for Python3, using Quick2Wire's Python APIs for the RaspberryPI.Losely inspired from Adafruit's PN532 I2C library.Pull requests are welcomed.
Package: py5jupyter
py5jupyter (& py5)py5 is a new version ofProcessingfor Python 3.8+. It makes the JavaProcessingjars available to the CPython interpreter usingJPype. It can do just about everythingProcessingcan do, except with Python instead of Java code.The goal of py5 is to create a new version of Processing that is integrated into the Python ecosystem. Built into the library are thoughtful choices about how to best get py5 to work with other popular Python libraries and tools such asJupyter,numpy, andPillow.The py5jupyter library provides Jupyter-related functionality for py5. This includes the Jupyter kernels and Jupyter widgets.For more in-depth information about py5, see thepy5generatorgithub repo.InstallationYou can install usingpip:pipinstallpy5py5jupyterIf you are using Jupyter Notebook 5.2 or earlier, you may also need to enable
the nbextension:jupyternbextensionenable--py[--sys-prefix|--user|--system]py5jupyterGet In TouchHave a comment or question? We'd love to hear from you! The best ways to reach out are:githubdiscussionsandissuesMastodonfosstodon.org/@py5codingtwitter@py5codingprocessing foundation discourse
Package: py621dl
py621dl - an iterable E621 downloaderThis package is meant to be used in deep learning applications and automation,
not as a means to download specific images and post IDs or searching for tags.
For that application, please check outpy621which is not related to this package in any way.The package is meant to be used with the official db export format from E621,
posts information. Seeherefor available db exports
andherefor general information on the API.!! This is a pre-release version, and is not meant for production use !!Proper documentation, tests, and automated updates to the package will be added later.InstallationYou can install the package usingpip install py621dlonpython>=3.11UsageThe E621Downloader class must be initialized using the Reader class, to which
the csv file must be passed. The Reader supports only the official db export csv files
of the format "posts-YYYY-MM-DD.csv.gz", either compressed or uncompressed.TheE621Downloaderclass can be initialized with the following parameters:csv_reader:
theReaderobjecttimeout: the timeout for the requests, in secondsretries: the number of retries for the requestsIt can be used as an iterable, yielding lists ofnp.ndarrayobjects of the images. The list size
will depend on yourbatch_sizespecified forReader. The images are of opencv BGR format.
The downloader automatically handles and filters deleted or flagged posts, and will attempt to fill
the batch with new images so that it will always yield a full batch.TheReaderclass can be initialized with the following parameters:csv_file: the path to the csv filebatch_size: the size of the batch to be returned by theE621Downloaderexcluded_tags: a list of E621 tags to be excluded from the resultsminimum_score: the minimum score of the posts to be included in the resultschunk_size: the size of the chunk to be read from the csv file at oncecheckpoint_file: the path to the checkpoint file, to resume from any point. If path doesn't exist, a new file will
be created.repeat: whether to repeat from the beginning of the csv file when the end is reached automatically.
OtherwiseStopIterationis raised.E621Downloaderhandles this exception and raises its ownStopIterationwhen the end is reached.Example usefrompy621dlimportReader,E621Downloaderreader=Reader("posts-2022-10-30.csv.gz")downloader=E621Downloader(reader,timeout=10,retries=3)forbatchindownloader:# do something with the batchpass
Package: py7file
Py7File wraps and unifies the python stdlib file handling modules with a simple
and intuitive high-level api.Think:os.path, shutil etc. via object based method access.Author:Titusz <tp at py7 de>PyPi:http://pypi.python.org/pypi/py7fileSource Code:http://github.com/titusz/py7fileLicense: BSDInstallationUse easy_install or pip:pip install py7fileUsageHere some hopefully self explaining examples of Py7File usage:from py7file import Py7File

the_file = Py7File('a_file.txt')

# Copy and Move
copied_file = the_file.copy('d_file.txt')  # copied_file is also a Py7file
the_file.move('moved_file.txt')  # moves the file and mutates the reference

# Backup and Restore
the_file.backup()  # creates a_file_backup_001.txt
the_file.backup()  # creates a_file_backup_002.txt
the_file.delete()  # removes a_file.txt from disk (ups...)
the_file.restore() # recovers file from a_file_backup_002.txt

# Unzip and Rezip
zfile = Py7File('a_file.zip')
zfile.unzip() # creates a folder a_file_unzipped with contents of zipfile
zfile.rezip() # repackages subfolder a_file_unzipped to a_file.zipSee test_py7file.py for more examples.TestingPy7File is tested against python 2.6 and 2.7To run the tests:python test_py7file.pyStatusWell I am using this this file handling library quite extensivly myself and
i got no complaints so far ;). Still please consider this Beta and
use at your own risk…BackgroundAs I started learning programming with python I found the different modules for
handling files very confusing and cumbersome to use. While writing my first
scripts I found myself writing os.path.join(…) way to often. I still
keep mixing up os and shutil based file operations like copy, move, rename.
So I started this little module to make things easier…News0.7.4fixed get_md5 to use internal filepath0.7.3.unzip() can now handle gzipped files transparently.unzip() now returns a list containing all extracted files as Py7File objectsfixed filepath encoding0.7.2Release date: 15-August-2011Added get_number() method for convenient work with numbered files.0.7.1Release date: 24-July-2011fixed setup.py0.7Release date: 17-July-2011added new get_sanitized_filename method0.6Release date: 21-May-2011new EpubFile class that suports epub packagingenhancements for Py7File subclassing0.5.1Release date: 10-May-2011basic read method addedimproved file comparison0.5Release date: 09-May-2011fixed filepath property to always give absolute path0.4Release date: 08-May-2011fixed to work with files that have no extensionfixed getsize test not returning long on osxadded md5 based file comparison.is_binary() detects if file is binary or “text”0.2Release date: 08-May-2011Fixed for tests on OSX0.1Release date: 08-May-2011Initial release
Package: py7z
📚Py7z📚InformaciónLibrería para ayudar a usar py7zr con funciones ya creadas.DesarrolladorInstalaciónWindowspy-mpipinstallpy7zLinuxpip install py7zFuncionesfrompy7zimportarchiving,compress,compress_encrypted# Archivar sin compresión un directorio o archivo, el proceso se realiza bastante rápido.defarchivando(path,name):f=archiving('./cosas','XD')iff:print(f'Nombre: f}\nSe archivo correctamente')else:print('No se pudo archivar el Directorio/Archivo')# Comprimir archivo o directorio, está tarea demora más ya que si usa compresión.defcompress_f(path,name):f=compress('./cosas','XD')iff:print(f'Nombre:{f}\nSe comprimio correctamente')else:print('No se pudo comprimir el Directorio/Archivo')# Comprimir con contraseña, es igual a la función de comprimir pero se le puede pasar contraseña al archivo .7zdefcompress_password(path,name,password):f=compress_encrypted('./cosas, 'prueba', '1234')iff:print(f'Nombre:{f}\nSe comprimio con contraseña correctamente')else:print('No se pudo comprimir con contraseña el Directorio/Archivo')
Package: py7za
Py7za ("pizza")Python wrapper for running the 7za.exe utility fromhttps://www.7-zip.org/The wrapper simply runs the application in a separate process and added functionality primarily aimed at running the tool in several parallel processes from the command-line.Other than providing that utility, the wrapper tries to provide users Python API access to 7za in a way as simple, and as close to the original as possible. See some documentation for the command line options herehttps://sevenzip.osdn.jp/chm/cmdline/index.htm(no affiliation).Additionally, the package contains the genericAsyncIOPoolclass, which allows you to queue up a large number of asynchronous tasks, and it will keep a certain number of them running at all times, until all tasks are done. This works for anyasyncioTask, but can be handily combined with thePy7zaclass.Finally, a command line utilitypy7za-box("pizza box", and its aliasesboxandunbox) is included, which allows you to quickly replace individual files with their zipped equivalent in-place and vice versa, without writing any code. The idea is that a user may want to zip many files in a large project, without removing them from their original location, and still be able to find them by name and easily extract them individually.For more information, check thePy7za documentation at Read the Docs (py7za.readthedocs.io).InstallInstall the package for use from scripts:pip install py7zaOf if you want to use the command-line interfacepy7za-boxas well, make sure the dependencies for it are installed like this:pip install py7za[box]
py7za-box --help
box --help
unbox --helpOn Linux, you will have to havep7zipinstalled forpy7zato work, as there is no Linux binary included in the package. For example:sudo yum install -y p7zip
sudo apt-get install -y p7zipCommand line py7za-boxTo quickly replace every .csv file in a directory and in all its subdirectories with a zip-file containing that .csv:py7za-box **/*.csvAnd the reverse:py7za-box **/*.csv.zip --unboxMore in the documentationhttps://py7za.readthedocs.ioDependenciesThe only external dependency is onconffufor the configuration of the command-line tool. If you only want to use the Py7za class, and just usepip install py7za, this dependency won't be installed. To install the dependency, usepip install py7za[box].LicenseThis package is licensed under the MIT license. SeeLICENSE.txt.ChangelogSeeCHANGELOG.md.
Package: py7zip
py7zipAn unofficial, cross platform, lightweight, and easy to use wrapper for 7zip command line binaries (7za) in Python.
Unlike other libraries, this one fully supports 7zip natively, is easy to setup/install, and is "pythonic" with
the intent to be used in code and scripts, not through the terminal. Additionally, you CAN use the '7za' binaries
directly as the specific binaries for your system will be installed automatically and you can therefor it from the
terminal/command line. This also lends to making cross platform apps using this module.Why Choose py7zip?Seamless Integration: Unlike other libraries, py7zip seamlessly integrates 7zip functionality directly into Python,
eliminating the need for external dependencies or cumbersome command-line executions.Cross-Platform Compatibility: Whether you're running Windows, Linux, or Mac, py7zip ensures consistent performance
and reliability across all major operating systems.Pythonic Design: With a focus on adhering to Python's idiomatic principles, py7zip boasts an intuitive API that is
easy to understand and use within your codebase.Lightweight and Efficient: Despite its robust feature set, py7zip remains remarkably lightweight, occupying less
than 1MB of disk space.UsageInstall using Pip/PyPi (Default; most common)pip install py7zipInstall using Git CloneBrowse to the location to install and open terminal/cmdgit clone https://github.com/aliasfoxkde/py7zip.gitpip install .Install Using Pip+Git (Alternative)pip install git+https://github.com/aliasfoxkde/py7zip.gitDocumentationCHANGELOG.md: includes versioning and a
list of changes made between them.FEATURES.md: reference documentation that
details the features of this module as well as 7zip.LICENSE.md: includes all licensing
information for use of this module.PLANNING.md: includes Tasks, Improvements,
and General planning stages.SETUP.md: includes instructions on technical
setup of the repository for use with updating and publishing best practices.TERMS.md: defines terms used throughout repo.USAGE.md: includes detailed instructions on
how to use this module.NOTE: Documentation is broken down into parts and can be found in ./docsPlatforms Supported and Tested:Linux x86-64 (64-bit)Linux x86 (32-bit)Linux arm64 (64-bit)Linux arm (32-bit)macOS (arm64 / x86-64)Windows x64 (64-bit)Windows x86 (32-bit )Windows arm64 (64-bit)
Package: py8583
#py8583
###Python library implementing the ISO-8583 banking protocolThis is an implementation of the de-facto protocol for banking applications, iso8583.#### Status:Things working:iso-8583/1987 parsing and buildingSupport of BCD/Binary/ASCII variations in field lengths and field data (where applicable)Python 2.7 and 3.x supportThings that will work(aka TODO List):Proper documentationFully automated unit testing1993 and 2003 specifications of the protocolThings that might work(aka Wishlist):Predefined (and ready to use) popular implementationsEBCDIC support#### How to use:
The module’s external module dependencies are:enum34 (for python &lt; 3.4)This paragraph will eventually have some basic/quick examples too. Until then, please have a look at the IsoHost.py file which contains a simple server which waits for ISO messages, parses them and replies in a hardcoded manner.#### License:
All the work is licensed under LGPL 2.1. Since LGPL is not very python focused, as the copyright holder, my intentions
basically boil down to:You are allowed to use the library as an API in closed source code without it being considered derivative workYou are NOT allowed to modify the library itself without publishing the changes in a compatible license
Package: py8chan
The Bibliotheca Anonoma’scomplete Python Wrapper for the 8chan API.Uses requests, respects if-modified-since headers on updating threads.
Caches thread objects. Fun stuff.An absolute must if you want to interface with or scrape from 8chan or
other vichan-based imageboards/textboards, using a Python script.Hosted
DocumentationGithub RepositoryYou can install this librarystraight from
PyPiwith:pip install py8chanGetting HelpIf you want help, or you have some trouble using this library, our
primary IRC channel is [#bibanon on
irc.rizon.net][http://qchat2.rizon.net/?channels=bibanon). Simply head
in there and talk to antonizoon. Otherwise, you can put a issue on ourGithub Issue Trackerand we’ll
respond as soon as we can!Usageimportpy8chanboard=py8chan.Board('v')thread=board.get_thread(423491034)print(thread)# supports displaying extra files in one post as well!forfileinthread.file_objects():print(file.file_url)# In a while...print("I fetched",thread.update(),"new replies.")DocumentationThis library mostly extends the classes ofBASC-py4chan, but has some
slight but major differences. See the py8chan documentation for more
info.py8chan
DocumentationThe official 8chan Swagger API documentation can be found
here.LicenseDO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
                   Version 2, December 2004

Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>

Everyone is permitted to copy and distribute verbatim or modified
copies of this license document, and changing it is allowed as long
as the name is changed.

           DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
  TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

 0. You just DO WHAT THE FUCK YOU WANT TO.
Package: py934
Mimblewimble on Ethereum with zk SNARKsStructurecircuits/: Circuitstest/: Test casesDockerfile: Docker file to test Zokrates circuitsPre-requisiteInstall docker and GNU MakeCommandCircuit TestThis will run tests/circuits/unitTest.codemaketestPython library TestThis will runpython -m unittest tests/test*.pymakepytestMake verifier contract# Specify the circuit path to compile and export the verifier contractmakeverifiercircuit=YOUR_CIRCUIT_PATH# Specify the output pathmakeverifiercircuit=YOUR_CIRCUIT_PATHoutput=MyVerifier.solMake proof# Specify the circuit path and argumentsmakeproofcircuit=YOUR_CIRCUIT_PATHargs='0 0 0 .. 0'# Specify the output pathmakeproofcircuit=YOUR_CIRCUIT_PATHargs='0 0 0 .. 0'output=myProof.json
Package: py9p
9P protocol implementationThe library allows you to use 9P protocol in your
applications. Please note, that the library is not
fully compatible with the original version by
Andrey Mirtchovski.Also, this package provides two components:fuse9p – FUSE 9p client9pfs – simple file server (alpha state)Linkshome:https://github.com/svinota/py9pbugs:https://github.com/svinota/py9p/issuespypi:http://pypi.python.org/pypi/py9p/Changes1.0.8 – Neoarcheanfuse9p: fid cache fixedfuse9p: several thread safety issues fixedfuse9p: iounit negotiationfuse9p: support rename() routinefuse9p: uid/gid map feature1.0.7 – MesoarcheanPKI auth fixedfuse9p: “persistent connection” feature, -Pfuse9p: symlink supportfuse9p: multiple fixes of the background mode9pfs: new component, that grow up from localfspy9p: provide mode conversion routines1.0.6 – PaleoarcheanTcreate client call fixedfuse9p client, supporting stateful I/O,
“reconnect after network errors” and so on.1.0.4 – Eoarchaeansupport arbitrary key files for PKI1.0.3initial pypi release
Package: py9pfactotum
py9pfactotumpy9pfactotum is Python's plan9port Factotum client. It also provides
the following extras:Helper functions that mirror plan9port's auth(3) libraryAKeyringbackend to connect
to your running factotum server.UsageIn the current (alpha) state of maturity, the implementation is
incomplete. Currently enough is implemented to support the Keyring
backend (i.e., to read passwords from the running server).When using the FactotumClient directly, arguments are passed as
keyword arguments, which are built into a key template internally:from py9pfactotum import FactotumClient
c = FactotumClient()
c.getpass(server='mail.example.org', user='johndoe')
{ 'user': 'johndoe', 'passwd': 'insecure' }As with the example above, the client provides high-level methods
that supply the correct 'proto' and 'role' attributes to the key
template. See factotum(4) for more information.When using the auth(3) functions, the function signatures mirror
their plan9port counterparts, except that structures are replaced
with dictionaries.from py9pfactotum import auth_getuserpasswd
c = auth_getuserpasswd(server='mail.example.org')
{ 'user': 'johndoe', 'passwd': 'insecure' }KeyringThe Keyring user interface is transparent, but that library must
be explicitly installed on the system (it is not a hard dependency
of py9pfactotum). Because factotum is not able to persist passwords
(or password deletions), attempts to use the Keyring to do so will
throw an error.
Package: pyA10_CB
This package provides class to control the GPIO on Cubieboard A10.Current release does no support any peripheral functions.This package is an apapted version of pyA20 for Olimex's OLinuXino-A20.Example=======Typical usage::#!/usr/bin/env pythonimport A10_GPIO as GPIO#init moduleGPIO.init()#configure moduleGPIO.setcfg(GPIO.PD2, GPIO.OUTPUT)GPIO.setcfg(GPIO.PD3, GPIO.INPUT)#read the current GPIO configurationconfig = GPIO.getcfg(GPIO.PD2)#set GPIO highGPIO.output(GPIO.PD2, GPIO.HIGH)#set GPIO lowGPIO.output(GPIO.PD2, GPIO.LOW)#read inputstate = GPIO.input(GPIO.PD3)#cleanupGPIO.cleanup()Warning=======Before using this tool it is HIGHLY RECOMENDED to check CubieboardA10 schematic on http://linux-sunxi.org.Changelog===================================* pyA10_CB 0.1.0 (2014-01-08)- Initial release
Package: pyA10S
This package provides class to control the GPIO on Olinuxino A10S.
Current release does no support any peripheral functions.ExampleTypical usage:#!/usr/bin/env python

import A10S_GPIO as GPIO

#init module
GPIO.init()

#configure module
GPIO.setcfg(GPIO.PIN#, GPIO.OUTPUT)
GPIO.setcfg(GPIO.PIN#, GPIO.INPUT)

#read the current GPIO configuration
config = GPIO.getcfg(GPIO.PIN#)

#set GPIO high
GPIO.output(GPIO.PIN#, GPIO.HIGH)

#set GPIO low
GPIO.output(GPIO.PIN#, GPIO.LOW)

#read input
state = GPIO.input(GPIO.PIN#)

#cleanup
GPIO.cleanup()WarningBefore using this tool it is HIGHLY RECOMENDED to check Olinuxino
A10S schematic.ChangelogpyA10S 0.1.0 (2013-05-03)Initial release