Saravanan666/pypi-org huggingface dataset:
Package: pino
pino.pyJson natural logger for pythoninspired bypino.js:evergreen_tree:In building port ofpinojslogging library to python :snake::warning: This is a in building prototype, it's API is subject to change.
A CHANGELOG will be introduced once it's stable enough and publicized.
Use it at you own risk, but feel free to reach with an issue.Basic Examplefrompinoimportpinologger=pino(bindings={"apptype":"prototype","context":"main"})logger.info("Hello, I just started")logger.debug({"details":42},"Some details that won't be seen")child_logger=logger.child(context="some_job")child_logger.info("Job started")child_logger.info({"duration":4012},"Job completed%s","NOW")logger.info("Program completed")Which would output:{"level": "info", "time": 1587740056952, "message": "Hello, I just started", "host": "SomeHost", "apptype": "prototype", "context": "main", "millidiff": 0}
{"level": "info", "time": 1587740056952, "message": "Job started", "host": "SomeHost", "context": "some_job", "apptype": "prototype", "millidiff": 0}
{"level": "info", "time": 1587740056952, "message": "Job completed NOW", "host": "SomeHost", "duration": 4012, "context": "some_job", "apptype": "prototype", "millidiff": 0}
{"level": "info", "time": 1587740056952, "message": "Program completed", "host": "SomeHost", "apptype": "prototype", "context": "main", "millidiff": 0}APIpino() constructor argumentsbindings: meta attached to the messages by defaultlevel: minimal level to output logs,default toinfoenabled: is logger enabled,default to truemillidiff: whether a millidiff is added to message,mssince last message,enabled by default.stream: stream to write logs to, default tosys.stdoutdump_function: function to be used to serialise object to JSON,defaultjson.dumpsmessagekey: key for message entry,defaultmessagepino logger instancelog methods:critical,error,warn,info,debug: (extra_bindings?), message, template value.level: access or update current log levelchild(metas): create a child logger instance with new metas/bindings attached to it. (metas can be provided either as dict or kwargs)Complex examplesYou can see more detailed examples in theexamplesfolder, notablycomplex.pyDevelopment :hammer_and_wrench:This library usePoetryfor management of the project, it's dependencies, build and else.You can run test on all supported python version withpoetry run task test(which will runtox),
or you can run on your current python version withpoetry run task pytest.
Package: pinout
pinoutSVG diagram creation from Python code -pinoutprovides an easy method of creating pinout diagrams for electronic hardware.Please visitpinout.readthedocs.iofor the fullquick starttutorial and detailed documentation on all options provided by thepinoutpackage.Quick startpinoutcan be easily installed with pip and provides some sample files that demonstrate key features.InstallUsing a virtual environment is recommended; Start by installing thepinoutpackage. Either clone this repo and pip install it or install from PyPi:pip install pinout

# Or upgrade to the latest version
pip install --upgrade pinoutDuplicate sample filesA normal pinout diagram will include a hardware image, stylesheet, data file, and a Python script. Sample files are included with the package and can be duplicated for your use. Open a command line (with enabled virtual environment if you are using one) in the location you plan to work and enter the following:py-mpinout.manager--duplicatequick_start# expected output:# >>> data.py duplicated.# >>> hardware.png duplicated.# >>> pinout_diagram.py duplicated.# >>> styles.css duplicated.Once you have these file a finished diagram can be generated from a command linepy -m pinout.manager --export pinout_diagram diagram.svg. An SVG file is created and can be conveniently view in a browser.For a detailed walk throughpinout_diagram.pyand more information onpinoutplease visitpinout.readthedocs.io.
Package: pinpaver
pin-paver=======pin-paver provides 'project-wide' access to commands inside your pavement.py file. pin-paver will list your paver commands in the **pin help** command.$pin helpusage: pin [-v]optional arguments:-v, --version  show program's version number and exitAvailable commands for /home/dlacewell/dev/pmcs:destroy  - Destroy and unregister the project from pin.go       - Teleport to a specific project.help     -  This help information.init     - Initialize pin in the current directory.paver    --------------------------------------------------------------------------Commands inside your pavement file.test  - A test command that does nothing.### Commands* **pin paver [paver args]** : Execute any commands inside your pavement.py file
Package: pinpayments
PinPayments-Python is a Python interface to the [Pin Payments](https://pin.net.au/docs/api)
API## Installation:` pip install pinpayments `## Quickstart:` python >>> from pinpayments import PinPayments >>> api_secret = <api_secret> >>> pin = PinPayments(api_secret = api_secret, test = False) >>> customers = pin.getCustomers() `
Package: pinpip
pin-pip adds some basic pip functionality to pin projects.### Hookspin init:–pip- Will process a‘requirements.txt’in the project root if there is one. If used with pip-venv, the pin virtual-environment will be used.### Commandspin pip:requires- Lists the‘requirements.txt’file in the project root if there is one.meet- Will process a‘requirements.txt’in the project root if there is one. If used with pip-venv, the pin virtual-environment will be used.
Package: pinpointPy
Visitour official websitefor more information andthe Latest updates on PinpointThe current stable version isthe Latest.Pinpoint Common AgentIt is an agent written by C++, PHP and Python languages. And we hope to support other languages by this agent. Until now, it supportsPHPandPYTHON.LicenseThis project is licensed under the Apache License, Version 2.0.
SeeLICENSEfor full license text.Copyright 2020 NAVER Corp.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Package: pinpy
PINPyPINPy is a Python package used for data processing for the development of a novel specialized database of Potato Type Inhibitor-II family PIs (Pin-II type PIs) plant protease inhibitors. The database, together with the web-based information system, is called PINIR (Pin-II type PIsInformationResource) and can be accessed using following web-link.Database URL :https://pinir.ncl.res.in/It consist of following modules:domain_finder.py:This module provides a function which indentifies which Domains are found in a Sequence and what are their location i.e. it's start and end position.domain_type.py:This module provides a function which based upon Linker organization in IRD's (Domains) identifies the Domain Typedsbond_finder.py:This module provides a function which finds the probable Di-Sulphide Bonds in the available Domain sequences.linker_finder.py:This module provides a function which finds which Linker is found in a Domain and what is its location i.e. it's start and end position.rc_finder.py:This module provides a function which finds which RCL is found in a Domain and what is its location i.e. it's start and end position.rcl_residues.py:This module provides a function which identifies the Residues at P1, P2 and P1` position in an RCL.amino_composition.py:This module provides a function which finds the Amino Acids composition of Amino Acid Sequences. These Amino Acid sequences can be PI sequences or Domain sequences. It gives each Amino Acid's count and percentage in the sequences.
Package: pin-py
PinPyPython wrapper for the Pinterest's API#What it offers
Basically its just a wrapper on Pinterest API to make things easy for projects which use pinterest's API.
Right now It only offers wrapper on few major things likeGeneral information about user who's authentication or access token is enteredGet all boards of userGet all Pins of user [IDs of pins]Using these Pin ids to get further information about specific Pin#How to use itinstall it using pippip install pin-pyusagefrom pin_py.pinterest.pinpy import PinPy

pin = PinPy()
pins_list = pin.get_details_of_all_pins("access_token")

for pin_one in pins_list:
    print(pin.get_single_pin_details(pin_one,"access_token"))
Package: pinq
pinqis a partial python implementation of the Language Integrated Query (LINQ) framework’s method syntax api.InstallationEasyTo install pinq, use pip:$pipinstallpinqFrom SourceTo install pinq from source, download thesourceand extract the contents. Then run:$pythonsetup.pyinstallTo run the tests, run the following command from the source directory:$pythontestsDocumentationBetter documentation is currently under development.The pinq api documentation can be foundhere.ContributeCheck for open issues or open a new issue.Forkthe repositoryon GitHub to start making changes.Write a test that shows the bug was fixed or the feature works as expected.Send a pull request
Package: pinry
The open-source core of Pinry, a tiling image board system for people
who want to save, tag, and share images, videos and webpages in an easy
to skim through format.For more information and a working demo board visitgetpinry.com. For the
latest documentation check outRead the Docs.RequirementsPinry is built on top of Django and optimized to run on a Linux
environment. However we have gotten Pinry to work on Windows and Mac as
well but it may require some extra digging around configuration. Pinry’s
Python requirements are all in therequirements.txtfile and easily
installable once you have up a virtual environment. What you need
initially:PythonpipvirtualenvYour OS’s build tools (Ubuntu:build-essential, Mac:Xcode)Build dependencies for PIL/Pillow (Ubuntu:apt-getbuild-deppython-imaging)TestingWe have many tests built into Pinry to ensure that changes don’t break
anything. If you are live dangerously and have cutting edge new Pinry
features first you can use our master branch for your own instance. We
recommend using our tags/versions though.To run Pinry’s tests inside the Pinry repo run:virtualenv .
bin/pip install -r requirements.txt
bin/python manage.py testProduction DeploymentOur supported and suggested way to deploy Pinry is using Docker. We
provide support and instructions for that over at thedocker-pinry
GitHub repository.If you’d like a different setup then check out the hundreds of tutorials
for production Django deployment found via Google.Current Master Build Status
Package: pinscher
Pinscher is a collection of software that manages password collections. Pinscher helps you store and retrieve passwords for as many accounts as you like. It can also create random (complex) passwords for you so you can easily have a different password for each account you own.Your username and password details are stored in strongly encrypted files so you don’t have to worry about them being stolen. These encrypted files can be kept on cloud services likeDropboxorGoogle Drive. This way you can share passwords across all of your computers and devices.What’s pinscher-core?Pinscher-core is the set of Python functions that can interact with the Pinscher password files. Using the functions in this module you can insert, update, delete and list passwords, usernames and domains. This module is not intended for end-users, it’s intended for developers who wish to include Pinscher password storage in their Python software. For more user-friendly software visithttp://pinscher.williammayor.co.uk.Getting pinscher-coreThe easiest way is to use pip:$ pip install pinscher-coreI would recommend gettingvirtualenvas well. It makes for really easy environment and dependency management.Without pipYou can get the source code from theGitHub repo.orYou can download the source using easy_install:$ easy_install pinscher-coreAgain,virtualenvis recommended.orYou can download the files directly fromPyPior thePinscher homepage.DependenciesPinscher-core relies onPyCrypto. If you use pip to install the module then you don’t need to worry about installing this. If you use one of the other methods then you’ll need to follow the installation instructions on the PyCrypto page to go about getting yourself a copy.
Package: pinscrape
pinscrapeThis package can be use to scrape images from pinterest just by using any search keywords. Install it just by usingpip install pinscrapeHow to use?frompinscrapeimportpinscrapedetails=pinscrape.scraper.scrape("messi","output",{},10,15)ifdetails["isDownloaded"]:print("\nDownloading completed !!")print(f"\nTotal urls found:{len(details['extracted_urls'])}")print(f"\nTotal images downloaded (including duplicate images):{len(details['url_list'])}")print(details)else:print("\nNothing to download !!")scrape("messi", "output", {}, 10, 15)"messi"is keyword"output"is path to a folder where you want to save images{}is proxy list if you want to add one (optional)10is a number of threads you want to use for downloading those images (optional)15is the maximum number of images you want to download (optional)
Package: pinspect
Pretty inspectInspired by the complexity ofNeo.When browsing/inspecting an object, you want to collect all methods and attributes that match the key.ExampleBrowsing the documentation ofneo.io.BlackrockIOand looking for the ways of extractingEpochs, you foundread_epoch()method. But calling this method raisesAssertionError. You need to go deeper.Runpip install pinspect neoDownload BlackRocksampledata.zipwget http://www.blackrockmicro.com/wp-content/software/sampledata.zip
unzip sampledata.zipIn python,fromneo.ioimportBlackrockIOfrompinspectimportfindsession=BlackrockIO('sampleData')graph=find(session,'epoch',verbose=True)Output:BlackrockIO.rescale_epoch_duration() -> 'TypeError'
BlackrockIO.read_epoch() -> 'AssertionError'
BlackrockIO._rescale_epoch_duration() -> 'TypeError'
BlackrockIO.read()[0].segments[0].epochs -> 'list of size 0'
BlackrockIO.read()[0].segments[0].events[0].to_epoch() -> 'Epoch'The last two lines are candidates to explore manually.Graph visualizationYou can passvisualize=Trueand enjoy the beautifulnetworkxwithpyvisinteracting graph rendering.
Hover over the nodes (objects) and edges (methods and attributes) to explore the graph in details and inspect how a particular object has been generated.Unfiltered graphBelow is the full unfiltered graph ofneo.BlackRockIOof all possible method and attribute calls. Can you find the green dot?RequirementsPython 3.6+requirements.txtAlternativeAnother package to inspect python variables isobjbrowser.
Package: pinstance
PinstanceSimplesingletonclass decorator with
ability to call bounded methods with 0 overhead.Decorated class can inherit other classes and can be inherited.Decorated class can not be collected till the end of a programmUsageDecorate a class:@instanceclassclassMyClass:def__init__(self,val):self.class_var=valNow you can instanciate itinst=MyClass(777)inst.class_var## 777and access the instance anywhere viaget_instance()class method:MyClass.get_instance().class_var## 777MyClass.get_instance().some_var=555MyClass.get_instance().class_var## 555Furthermore, to simplify calling methods via instance reference one can decorate desiered@instanceclassmethods:@instancemethoddefmy_function(self,param):print(f'{self.class_var}|{param}')and call them like static methods with0overhead:MyClass.my_function('example')## 555 | example
Package: pinta
Pinta: Job management on GPU clusters 🍺InstallationTo install the command-line client:pip3installpintaTo install the backend API server:pip3installpinta-apiPinta requires Python 3.8.DevelopmentTo start contributing to Pinta:gitclonegit@github.com:qed-usc/pinta.gitcdpinta
poetryinstallYou can run Pinta from the local directory withpoetry run pinta(or by first
startingpoetry shelland thenpinta).To run the tests:poetry run pytest.To check the documentation:poetry run mkdocs serve.To deploy the documentation:poetry run mkdocs gh-deploy.
Package: pinterest-api
Python Pinterest APIGetting Startedpipinstallpinterest-apiUsageimportpinterest# Generate OAuth2 authorization linklink=pinterest.oauth2.authorization_url(app_id,redirect_uri)# Initialize API by passing OAuth2 tokenapi=pinterest.Pinterest(token="ApFF9WBrjug_xhJPsETri2jp9pxgFVQfZNayykxFOjJQhWAw")# Fetch authenticated user's dataapi.me()# Fetch authenticated user's boardsapi.boards()# Create boardapi.board().create("Halloween",description="Fun Costumes")# Fetch boardapi.board("695665542379607495").fetch()api.board("username/halloween").fetch()# Fetch pins on boardapi.board("username/halloween").pins()# Edit boardapi.board("username/halloween").edit(new_name="Costumes",new_description="Halloween Costume Ideas")# Delete boardapi.board("username/halloween").delete()# Fetch board suggestionsapi.suggest_boards(pin=162129655315312286)# Fetch authenticated user's pinsapi.pins()# Create a pinapi.pin().create(board,note,link,image_url=image_url)# Fetch a pinapi.pin(162129655315312286).fetch()# Edit a pinapi.pin(162129655315312286).edit(board,note,link)# Delete a pinapi.pin(162129655315312286).delete()# Search boards (Optional cursor)api.search_boards(query,cursor=None)# Search pins (Optional cursor)api.search_pins(query,cursor=None)# Follow a boardapi.follow_board(board)# Follow a userapi.follow_user(username)# Return the users who follow the authenticated userapi.followers(cursor=None)# Return the boards that the authenticated user followsapi.following_boards(cursor=None)# Return the topics the authenticated user followsapi.following_interests(cursor=None)# Return the users the authenticated user followsapi.following_users(cursor=None)# Unfollow boardapi.unfollow_board(board)# Make authenticated user unfollow userapi.unfollow_user(username)# Fetch another user's infoapi.user(username)# Fetch board sectionsapi.board("695665542379586148").sections()# Create board sectionapi.board("695665542379586148").section("Section Title").create()# Delete board sectionapi.board("695665542379586148").section("4989415010584246390").delete()# Fetch pins in board sectionapi.board("695665542379586148").section("4989343507360527350").pins()ResponsesThe Pinterest API responses are in JSON format.api.me()# By default, retry http request up to 3 times{"data":{"first_name":"Bryan","id":"695665611098925391","last_name":"Andrade","url': "https://www.pinterest.com/bandrade1815/"},"ratelimit":{"limit":10,"remaining":9}}ResourcesPinterest Developer APIPinterest API Explorer
Package: pinterest-crawler
Pinterest CrawlerDownloads HD images from pinterest by your favorite keywords. A useful tool to create a dataset for machine learning projects.InstallInstall the package with pip in a Python>=3.8 environment:pip install pinterest-crawlerUsageCLIPinterest Crawler may be used directly in the Command Line Interface (CLI):pinterest-crawler--keywordsliontigerbearAlso you can write your favorite keywords in a file for examplemy_keywords.txtand set path of file in--keywordsargument:pinterest-crawler--keywordsmy_keywords.txtPythonComing soon...TODOdownload images in a loopdownload images in a specific sizedownload images in a specific format
Package: pint-pal
PINT PalA repository for standardizing timing analysis and data combination work with a Jupyter notebook framework and corresponding tools.pint_palincludes tools and notebook templates to facilitate transparency and reproducibility in timing pulsars using PINT. Configuration (.yaml) files contain relatively compact metadata to capture decisions made during the timing process so that such information can naturally be version controlled. Configuration files can be "plugged into" standardized notebook templates to asses and update results.More information about available tools and use cases coming soon!Getting startedPINTis necessary for core functionality ofpint_pal, but the following packages are also required to do detailed outlier inspection and run noise analyses:enterpriseenterprise_extensionsenterprise_outlierspypulseThere are instructions for installing these packages and setting up your environment here:https://github.com/ipta/pulsar-env. Please note that installingmambamust be done from a clean (base)condaenvironment; you can make and activate a fresh environment with, e.g.:$ conda create --name installer && conda activate installerInstallationpint_palis now available on PyPI, so users who do not wish to develop code can grab the latest tagged version with:$ pip install pint-palYou may also access the latest development (not tagged) version of the repository by cloning it from GitHub, then installing:$ git clone https://github.com/nanograv/pint_pal.git
$ cd pint_pal
$ pip install .To further developpint_palcode, fork this repository, clone your fork, then:$ cd pint_pal
$ pip install -e .
$ git remote add upstream https://github.com/nanograv/pint_palBefore making changes, we highly recommend usingpulsar-env(see above) to set up a consistent environment. Submit changes for review by opening a PR from your fork.
Package: pint-pulsar
PINTPINT is not TEMPO3PINT is a project to develop a pulsar timing solution based on
python and modern libraries. It is still in active development,
but it is in production use by the NANOGrav collaboration and
it has been demonstrated produce residuals from most “normal”
timing models that agree with Tempo and Tempo2 to within ~10
nanoseconds. It can be used within python scripts or notebooks,
and there are several command line tools that come with it.The primary reasons PINT was developed are:To have a robust system to produce high-precision timing results that is
completely independent of TEMPO and Tempo2To make a system that is easy to extend and modify due to a good design
and the use of a modern programming language, techniques, and libraries.IMPORTANT Notes!PINT has a naming conflict with thepintunits package available from PyPI (i.e. using pip) and conda.
DoNOTpip install pintorconda install pint!  See below!PINT requireslongdouble(80- or 128-bit floating point) arithmetic withinnumpy, which is currently not supported natively on M1/M2 Macs.
However, you can use an x86 version ofcondaeven on an M1/M2 Mac (which will run under Rosetta emulation):
seeinstructions for using Apple Intel packages on Apple
silicon.
It’s possible to haveparallel versions of conda for x86 and
ARM.InstallingPINT is now available via PyPI as the packagepint-pulsar, so it is now simple to install via pip.
For most users, who don’t want to develop the PINT code, installation should just be a matter of:$ pip install pint-pulsarBy default this will install in your system site-packages.  Depending on your system and preferences, you may want to append--userto install it for just yourself (e.g. if you don’t have permission to write in the system site-packages), or you may want to create a
virtualenv to work on PINT (using a virtualenv is highly recommended by the PINT developers).PINT is also available for Anaconda python under the conda-forge channel:$ conda install -c conda-forge pint-pulsarThe above two options install the latestreleasedversion. If you want access to the latest development version,
the source code, example notebooks, and tests, you can install from source, by
cloning the source repository from GitHub, then install
it, ensuring that all dependencies needed to run PINT are available:$ git clone https://github.com/nanograv/PINT.git
$ cd PINT
$ pip install .Complete installation instructions are available onreadthedocs.UsingSee the onlinedocumentation. Specifically:TutorialsAPI referenceHow-Tos for common tasksAre you a NANOGrav member?  Then join the #pint channel in the NANOGrav slack.If you have tasks that aren’t covered in the material above, you can
emailpint@nanograv.orgor one of the people below:Scott Ransom (sransom@nrao.edu)Paul Ray (Paul.Ray@nrl.navy.mil)David Kaplan (kaplan@uwm.edu)Want to do something new? Submit a githubissue.And for more details, please read and cite(!) the PINTpaper.Articles that cite the PINT paper can be found in an ADSLibrary.
A list of software packages that use PINT can be foundhere.