Saravanan666/pypi-org huggingface dataset:
Package: pypachy
A python client wrapper forPachyderm<https://www.pachyderm.io/> API.NOTESCurrently implements only the PFS interface.Supports Pachyderm versions 1.4 and upInstalling$ pip install pypachyInstructionsAll of the PFS functions used inpachctlare supported (almost) as-is.
There are some helper functions that help make things more pythonic:
*commitwhich is a context manager wrapper forstart_commitandfinish_commit*get_fileswhich supports getting the data from multiple filesNaming commitsAll functions that accept acommitargument will accept a tuple of(repo, branch)or(repo, commit_id),
a string likerepo/branchorrepo/commit_idand a Commit object.e.g:>>> client.list_file(('my_repo', 'branch'), '/')    # tuple
>>> client.list_file('my_repo/commit_id', '/')      # string
>>> c = client.list_commit('my_repo')[0]            # get some commit
>>> client.list_file(c, '/')                        # and use it directlyBasic usage example>>> import pypachy

>>> client = pypachy.PfsClient()
>>> client.create_repo('test')
>>> with client.commit('test', 'master') as c:
...:     client.put_file_bytes(c, '/dir_a/data', b'DATA')
...:     client.put_file_url(c, '/dir_b/icon.png', 'http://www.pearl-guide.com/forum/images/smilies/biggrin.png')
...:
>>> client.get_files('test/master', '/', recursive=True)
{'/dir_a/data': b'DATA',
 '/dir_b/icon.png': b'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x10\x08...'}As of version 0.1.4, there is also limited support for PPS:>>> pps_client = pypachy.PpsClient()
>>> pps_client.list_pipeline()
...TODOTest, test, test!Add support forObjectAPIChangelog0.1.5- Bug fixes0.1.4- Added: Alpha support for PPS
- Changed: Adapted for Pachyderm1.5.20.1.3- Fixed:inspect_commitwas broken
- Added:provenances_for_repofunction gives all the provenances for the commits in the repo0.1.2- Added:PfsClientdefault parameters now use the environment variables for pachd
- Added:put_file_bytescan accept an iterator
- Changed:commitnow tries to close the commit if an error occurred inside the context
- Added: More examples and a changelog to README
Package: py-package
py_packageThis is a template repository for creating python packages.Learn moreabout packaging in Python.Featureshas the basic structure of any python packagehas a template setup.py filehas a data directory which serves as a storage bucket for package data.Learn Howcontains GitHub Actions workflow to publish to PyPI automatically, whenever a new release is made.Make sure to have a PyPI account and save the username and password in the GitHub Secret of your repo.has the perfect .gitignore to solve your miseryUsage GuideFork the repoFind and replacepy_packagewith the name of your packageReplace my name 'Aahnik Daw' with your nameEditMakefileas per your requirementsDont forget to change thesetup.pyfileMake sure to check the contents of every file before you use themEnjoy
Package: pypackage-auto-publish
pypackage-auto-publishDocumentation:https://namuan.github.io/pypackage-auto-publishSource Code:https://github.com/namuan/pypackage-auto-publishPyPI:https://pypi.org/project/pypackage-auto-publish/A sample package with best practicesInstallationpipinstallpypackage-auto-publishDevelopmentClone this repositoryRequirements:PoetryPython 3.7+Create a virtual environment and install the dependenciespoetryinstallActivate the virtual environmentpoetryshellTestingpytestDocumentationThe documentation is automatically generated from the content of thedocs directoryand from the docstrings
of the public signatures of the source code. The documentation is updated and published as aGithub project pageautomatically as part each release.ReleasingTrigger theDraft release workflow(pressRun workflow). This will update the changelog & version and create a GitHub release which is inDraftstate.Find the draft release from theGitHub releasesand publish it. When
a release is published, it'll triggerreleaseworkflow which creates PyPI
release and deploys updated documentation.Pre-commitPre-commit hooks run all the auto-formatters (e.g.black,isort), linters (e.g.mypy,flake8), and other quality
checks to make sure the changeset is in good shape before a commit/push happens.You can install the hooks with (runs for each commit):pre-commitinstallOr if you want them to run only for each push:pre-commitinstall-tpre-pushOr if you want e.g. want to run all checks manually for all files:pre-commitrun--all-filesThis project was generated using thewolt-python-package-cookiecuttertemplate.
Package: pypackageinspector
pypackageinspectorpypackageinspector is a package in Python that inspects a given package and prints out all the functions and methods defined in that package. It takes a single argument, package, which is a string representing the name of the package to be inspected.
This can be useful in situations where you want to explore the functionality of a package before deciding whether or not to use it in your project, or when you need to quickly get a sense of what functions and methods are available in a package.InstallationUse the package managerpipto install pypackageinspector.pipinstallpypackageinspectorSample UsageHere's an example of how to call the inspector() function:frompypackageinspectorimportinspectorinspector('numpy',inspect_functions=True,inspect_methods=False)In this example, we're inspecting the "numpy" package and setting inspect_functions=True and inspect_methods=False, so the output will only include the list of functions in the package.If we want to inspect both functions and methods, we can call the inspector() function like this:inspector('numpy',inspect_functions=True,inspect_methods=True)Here's an example of the output when we call the inspector() function with inspect_functions=True and inspect_methods=False for the "numpy" package:0. AxisError
1. DataSource
2. MatrixPowerOperator
3. VisibleDeprecationWarning
4. add_docstring
5. add_newdoc
6. add_newdoc_ufunc
7. add_newdocs
8. arange
9. array
10. array2string
11. array_equal
12. array_equiv
13. array_repr
14. array_split
15. array_str
16. asanyarray
17. asarray
18. asarray_chkfinite
19. ascontiguousarray
20. asfarray
21. asfortranarray
22. broadcast
23. broadcast_arrays
24. broadcast_to
25. busday_count
26. busday_offset
27. busdaycalendar
28. byte_bounds
29. c_
30. can_cast
31. choose
32. column_stack
33. common_type
34. compare_chararrays
35. complex128
36. complex256
37. complex64
38. complex_
39. concatenate
40. core
41. correlate
42. corrcoef
43. count_nonzero
44. datetime64
45. datetime_as_string
46. delete
47. deprecate
48. diag
49. diag_indices
50. diag_indices_from
51. diagonal
52. disp
53. division
54. dot
55. double
56. dual
57. dtype
58. e
59. einsum
60. einsum_path
61. einsumfunc
62. empty
63. empty_like
64. equal
65. errstate
66. euler_gamma
67. expand_dims
68. extractContributingPull requests are welcome. For major changes, please open an issue first
to discuss what you would like to change.
Package: pypackages
pypackagesScript specific packages similar to PEP 582 using a__pypackages__directory.
The__pypackages__directory is created in the same directory as the script being executed.
A requirements.txt file must exist in the same folder to activate package installation.IntentAvoid dependency conflicts when installing python command line utilities.Automatic requirements installPlace requirements.txt in the folder to install or upgrade on startup using pip.This saves the need for distributing python version specific packages explicitly.This also avoids the package having explicit dependencies that are installed along side
the package therefore creating the potential for package version conflicts.Activatingimport pypackages
pypackages.packages()Execute pypackages.packages() to perform a local installation of requirements.txtPre-requisitespip must already exist in the python environment if requirements.txt is used.Example setup.cfg[metadata]
name = demo
version = 1.0

[options]
packages =
    demo
install_requires =
    pypackages

[options.package_data]
demo =
    *.txt

[options.entry_points]
console_scripts =
    demo = demo.app:cliStructure of deployment for scriptsmyapp.py
pypackages/
    __init__.py
requirements.txtExample (requirements.txt)sanic==22.12.0Example (myapp.py)#!/usr/bin/python
import pypackages
pypackages.packages()

from sanic import Sanic
from sanic.response import text

app = Sanic('myapp')


@app.route('/')
async def hello(request):
    return text('Hello, world')


if __name__ == '__main__':
    app.run(port=9999)Referenceshttps://peps.python.org/pep-0582/
Package: pypackaging
pyPackagingPython Boilerplate contains all the boilerplate you need to create a Python package.Free software: MIT licenseDocumentation:https://pypackaging.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2019-08-20)First release on PyPI.
Package: py-packed-struct
py-packed-structAn implementation of C-like packed structures in Python based on thebitstructpackagepy-packed-structallows to define C-like structures in an elegant way and to convert them intobytesobjects without having to specify the format as required bystruct:# with struct>>>fromstructimport*>>>one,two,three=1,2,3>>>pack(">bhl",one,two,three)b'\x01\x00\x02\x00\x00\x00\x03'# with py-packed-struct>>>frompacked_structimport*>>>s=Struct({"one":c_signed_int(8),"two":c_signed_int(16),"three":c_signed_int(32)})>>>s.set_data(one=1,two=2,three=3)>>>serialized=s.pack(byte_endianness="big")>>>print(serialized)b'\x01\x00\x02\x00\x00\x00\x03'>>>>>>s.unpack(serialized)>>>{'one':1,'two':2,'three':3}Who needs to remember struct format strings? :)In addition,py-packed-structallows to work with bit-fields and nested structures (seeexamples).Installationpipinstallpy-packed-structSupported featuresC-like structbit-fields handlingbyte endianess(TODO) bit endiannessExampleThis example can be found inexample/mqtt.publisher.pypublishes a message on a MQTT topic andsubscriber.cis subscribed to that topic. The publisher publishes the following structure:person=Struct({"name":c_char(10*8),"age":c_unsigned_int(8),"weight":c_float(32),"dresses":Struct({"tshirt":c_char(10*8),"shorts":c_char(10*8),"shoes":Struct({"number":c_unsigned_int(8),"brand":c_char(10*8)})})})# set data valuesperson.set_data(name="Luca",age=29,weight=76.9)person.dresses.set_data(tshirt="foo",shorts="boo")person.dresses.shoes.set_data(number=42,brand="bar")The subscriber copies the incoming buffer in the followingstruct:typedefstruct__attribute__((packed)){uint8_tnumber;charbrand[10];}shoes_t;typedefstruct__attribute__((packed)){chartshirt[10];charshorts[10];shoes_tshoes;}clothes_t;typedefstruct__attribute__((packed)){charname[10];uint8_tage;floatweight;clothes_tclothes;}person;The result is the following:
Package: pypackerdetect
PyPackerDetectDetect packers on PE files using heuristics and signatures.A complete refactoring ofthis projectto a Python package with a console script to detect whether an executable is packed.pefileis used for PE parsing.peidis used as implementation of PEiD.$ pip install pypackerdetect$ pypackerdetect --help
[...]
usage examples:
- pypackerdetect program.exe
- pypackerdetect program.exe -b
- pypackerdetect program.exe --low-imports --unknown-sections
- pypackerdetect program.exe --imports-threshold 5 --bad-sections-threshold 5Detection MechanismsPEID signaturesKnown packer section namesEntrypoint in non-standard sectionThreshhold of non-standard sections reachedLow number of importsOverlapping entrypoint sectionsRelated ProjectsYou may also like these:Awesome Executable Packing: A curated list of awesome resources related to executable packing.Bintropy: Analysis tool for estimating the likelihood that a binary contains compressed or encrypted bytes (inspired fromthis paper).Dataset of packed ELF files: Dataset of ELF samples packed with many different packers.Dataset of packed PE files: Dataset of PE samples packed with many different packers (fork ofthis repository).Docker Packing Box: Docker image gathering packers and tools for making datasets of packed executables.DSFF: Library implementing the DataSet File Format (DSFF).PEiD: Python implementation of the well-known Packed Executable iDentifier (PEiD).REMINDer: Packing detector using a simple heuristic (inspired fromthis paper).
Package: pypacking
PyPackingUse a short explanatory subtitle like, Create Python packages easilyPyPackingis a Python package template. It provides the minimal set of
files and functionalities to create and distribute a python package
usingPyPI.  ThisREADMEis one of the files you must provide with
the package. Change it according to the information you want to
provide the users.To start a new package using this template follow this procedure (we
will assume that the name of your package ismypack):Getpypackingtemplate:git clone https://github.com/seap-udea/pypacking mypackRemove the.gitdirectory.Install system prerrequisites:sudo apt install python3-pip gccInstall python prerrequisites:pip3 install build twineConfigure your package:Change variables in.packrc.Change key variables in setup filesetup.py.Change package prerrequisites inpyroject.toml.Change package name insrc/__init__.pyCreate an account inPyPIand get a token and place it in$HOME/.pypircRelease your first version:make release VERSION=0.0.1Always 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 pypackingQuick startIn this section you should provide the most simple instructions to use
your package.For instance:import pypacking
print(pypacking.version)Code examplesProvide some detailed examples for more advanced users.For instance:import pypacking
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: pypackinit
Python Package InitializerThis utility is aimed at creating the boilerplate necessary when starting a new python package.
I've found out that packaging even my own script helps tremendously in the long run, and also
improves the general quality of my projects.How do I install it?Simply open a terminal/prompt and typepipinstallpypackinitand a new command,ppinitwill be added to yourPATH.If you can't install packages in your system interpreter (you shouldn't anyway), you can add the--useroption.What does this script do?Following the PyPA guide on packaging, this script simply generates the essential files
to get you started on a new project. Suppose you want to start a project namedpanino.
This means that you have to create by hand thesetup.pyscript, fill it up, then createREADME,CHANGELOG,LICENSE, etc. Withpypackinit, all of this is done with a single
line (spread on multiple lines for clarity).ppinit panino 'The best panino on Earth, with even more cheese!' \
    -a 'Nino Pa' \
    -e ninopa@bread.com \
    -u https://panino.bread.comNow you have a directory structure like thisproject_root/
├── panino
│   └── __init__.py
├── CHANGELOG.md
├── LICENSE.txt
├── MANIFEST.in
├── README.md
└── setup.pyready to go! In practice, this script is an extremely simplified version ofcookiecutter(and it'snota fork).Why packaging my own modules?Packaging means that you don't have to set up yourPYTHONPATHevery time you change machine and
that your virtualenvs can simply "install" your other projects.Suppose that you haveProject AandProject B, whereBdepends onA. With packaging, you
could installAinB's virtual environment and then you could fix issues and work on additional
features ofAwithout compromising the functionality ofB. I have had this issue several times
and by pacakging basically all my scripts and modules I have solved most of my problems when it
comes to re-use my projects!Also, I found out that sharing code with people that are not comfortable withgitand the likes
is way easier if you can just send them awheel. :)Changelog1.0First fully-working version.
Package: pypacklib
Single command for python package creation from one/multiple .py files (Make packaging fun again!)Support meMost of the packages are simple and a collection of few functions or classes.
We have created a package for that now that can create python packages, upload to github and distribute to pypi all in a single call.
We collect desired packagename, author name and a few info interactively and create the package from a single python file.
You can use multiple python scripts too.
To use multiple scripts give a space seperated list when asked for file locations with main file (the file where all the functions and classes you want user to use is present) at the start.
For simple packaging, one single file is enough.Supports python 3.6+Autopopulates setup files, README.md and version etc , uploads to GitHub and PyPIEasily CustomizableEasiest to use with only single interactive command1 min video tutorialFun part: This package is also created by running the script located at src/pypacklib/__main__.pyInstall from PyPipip3 install pypacklibOr Install from main branchpip3 install git+https://github.com/Souvic/pypacklib.gitOne command to create/upload/update them all!Easy-to-follow prompts will guide you through the processpypackUnnecessary detailed instructions (just see the 1 min video)To make a new package and upload to github from a some/one python file(s):Run the commandpypack(and just follow the interactive framework forgetting the lines[2,3,4] written below)Input yes at the first prompt as you will be questioned.Follow the instructions that will appear.Make necessary changes if you have to (e.g. updating README.md file) now on the github repo before submitting to PyPi(by following the upload instruction below)To update/upload a package to PyPi which already has a GitHub repo:Make all necessary changes in the python files(location: src/packagename/) in the github repo.Run the commandpypack(and just follow the interactive framework forgetting the lines[2,3,4] written below)Input no at the first prompt.Follow the instructions that will appear.Extras to save GitHub and PyPI passtokens (save typing time)Set up your $HOME/.pypirc file with the passtoken like this to save twine password to avoid typing username and password everytimeDoc LinkCreate $HOME/.pypirc and paste the below code replacing only _yourpasstoken[pypi]
  username = __token__
  password = yourpasstokenUse git store password utility to avoid typing GitHub username and password everytimeDoc LinkPaste the below code for that with your passtoken and usernamegit credential-store --file ~/.mysecretfilelocation store
protocol=https
host=github.com
username=yourusername
password=passtokenImportant note:You can useGithub-flavored Markdownto write your content for your README.md
Package: py-packman
PACKMAN: PACKing and Motion ANalysisThis package focuses on studying molecular structures and their dynamics using a simple yet informative property known as Protein Packing. Over the last few years, we have worked on several techniques to capture and quantify the protein packing, resulting in a few publications. This package has all the code to repeat and further develop these techniques.DOCUMENTATIONIMPORTANT : Documentation, Tutorials & MoreINSTALLATIONInstalling with pip (Recommended)pip install py-packmanInstalling from sourcegit clone https://github.com/Pranavkhade/PACKMAN
cd PACKMAN
python setup.py installHOW TO USEPACKMAN, along with its components, can be accessed via Graphical User Interface (GUI), Command-line Interface (CLI), and Application programming interface (API).For the GUI, please run the following command.python -m packman guiORpython3 -m packman guiFor the CLI and API, please read the tutorials & documentation.REPORTING ISSUESClick hereto report issues with any aspect of the package. Please search for the resolved issues first.WEB SERVERSHinge Prediction Web Serverhd-ANM Web ServerPacking Entropy Web ServerDCI web serverRELATED RESEARCH ARTICLESPACKMAN-moleculeHinge PredictionCompliancehd-ANMPacking EntropyDCIACKNOWLEDGEMENTSThe development of the PACKMAN package webservers are supported byNSFgrant DBI 1661391. The authors also thankResearchIT@Iowa State Universityfor helping with many aspects of computing.
Package: pypackproxy
PyPackProxyA caching proxy for Python package indexes.For more information see thedocumentation.History2020-06-29 (0.3.1)Switch template engine to Jinja22020-02-23 (0.3.0)Use form-based authentication for admin login and enable logout2020-02-11 (0.2.0)Can now run without external package repository2020-02-08 (0.1.0)First public release
Package: pypack-template
How toUsed as a projectpython-mpipinstallpip-tools
pip-compile--upgrade# produces and update requirements.txtpip-syncUsed as a packagepython-mpipinstall-e.# install locallyPublish as a packagepython-mpipinstallbuildtwine

python-mbuild# build sdist(tar.gz) and bdist(wheel)twineuploaddist/*# publish to pypiReferencepip-toolshttps://realpython.com/pypi-publish-python-package/https://pybind11.readthedocs.io/en/stable/compiling.html
Package: pypad2
PyPad2PyPad2is simple and easy to use wrapper aroundevdevto read gamepad input from PS4 controllerLicense:Python & Pypi:Install & Upgrade:# install via pypipip3installpypad2# upgradepip3install--upgradepypad2Import:frompypad2importGamepad,KeymapUsage:Examples:frompypad2importGamepad,Keymap# create instancegamepad=Gamepad(path='/dev/input/event2')# get gamepad's namename=gamepad.name()print(name)# get gamepad's statusstatus=gamepad.status()print(status)# print's: {'capacity': '100', 'status': 'Discharging'}# set gamepad's colorgamepad.color()whileTrue:buttons=gamepad.pressed()forbuttoninbuttons:print(f'{button.name}:{buttons[button]}')Author:👨🏼‍💻Vinzenz Weist
Package: pypads-padre
PadrePadsAn extension of pypads that implements and tracks other concepts from machine learning experiments.IntallingThis tool requires those libraries to work:Python (>= 3.6),
pypads (>= 0.1.8)PadrePads only support python 3.6 and higher. To install pypads_padre run this in you terminalUsing source codeFirst, you have to installpoetryif not installedpip install poetry
poetry build (in the root folder of the repository padre-pads/)This would create two files under dist/ that can be used to install,pip install dist/pypads-padre-X.X.X.tar.gz
OR
pip install dist/pypads-padre-X.X.X-py3-none-any.whlUsing pip (PyPi release)The package can be found on PyPi in followingproject.pip install pypads_padreTestsThe unit tests can be found under 'test/' and can be executed usingpoetry run pytest test/DocumentationFor more information, look into theofficial documentation of PadrePads.Scientific work disclaimerThis was created in scope of scientific work of the Data Science Chair at the University of Passau. If you want to use this tool or any of its resources in your scientific work include a citation.AcknowledgementThis work has been partially funded by theBavarian Ministry of Economic Affairs, Regional Development and Energyby means of the funding programm"Internetkompetenzzentrum Ostbayern"as well as by theGerman Federal Ministry of Education and Researchin the project"Provenance Analytics"with grant agreement number03PSIPT5C.