Saravanan666/pypi-org huggingface dataset:
Package: pull_into_place
Pull Into Place (PIP) is a protocol to design protein functional groups with
sub-angstrom accuracy.  The protocol is based on two ideas: 1) using restraints
to define the geometry you’re trying to design and 2) using an unrestrained
simulations to test designs.The design pipeline orchestrated by PIP has the following steps:Define your project.  This entails creating an input PDB file and preparing
it for use with rosetta, creating a restraints file that specifies your
desired geometry, creating a resfile that specifies which residues are
allowed to design, and creating a loop file that specifies where backbone
flexibility will be considered:$ pull_into_place 01_setup_workspace ...
$ pull_into_place 02_setup_model_fragments ...Build a large number of models that plausibly support your desired geometry
by running flexible backbone Monte Carlo simulations restrained to stay near
said geometry.  The goal is to strike a balance between finding models that
are realistic and finding models that satisfy your restraints:$ pull_into_place 03_build_models ...Filter out models that don’t meet your quality criteria:$ pull_into_place 04_pick_models_to_design ...Generate a number of designs for each model remaining:$ pull_into_place 05_design_models ...Pick a small number of designs to validate.  Typically I generate 100,000
designs and can only validate 50-100.  I’ve found that randomly picking
designs according to the Boltzmann weight of their rosetta score gives a
nice mix of designs that are good but not too homogeneous:$ pull_into_place 06_pick_designs_to_validate ...Validate the designs using unrestrained Monte Carlo simulations.  Designs
that are “successful” will have a funnel on the left side of their score vs
rmsd plots:$ pull_into_place 07_setup_design_fragments ...
$ pull_into_place 08_validate_designs ...Optionally take the decoys with the best geometry from the validation run
(even if they didn’t score well) and feed them back into step 4.  Second and
third rounds of simulation usually produce much better results than the
first, because the models being designed are more realistic.  Additional
rounds of simulation give diminishing returns, and may be more effected by
some of rosetta’s pathologies (i.e. it’s preference for aromatic residues):$ pull_into_place 04_pick_models_to_design ...
$ pull_into_place 05_design_models ...
$ pull_into_place 06_pick_designs_to_validate ...
$ pull_into_place 07_setup_design_fragments ...
$ pull_into_place 08_validate_designs ...Generate a report summarizing a variety of quality metrics for each design.
This report is meant to help you pick designs to test experimentally:$ pull_into_place 09_compare_best_designs ...
Package: pullkin
PullkinLike Pushkin, but subscribe to FCM (GCM) and receive notificationsMy alternative implementation
ofpython implementationofJS implementationTested on python (3.6, 3.8, 3.10, pypy3.7-7.3.5)I almost didn't write anything to consider it my intellectual property,
just wrapped the code already written by Franc[e]sco in a design convenient for my own useNote that for the listening part Franc[e]sco has to pull in http-ece which depends
on a full-blown native crypto library rather than just oscrypto. it is
an optional dependency, so you'll have to install it explicitly by depending
onpullkin[listen]DifferencesAdd async listenerAdd async listener-coroutineReplace functions with class of listenerUsageInstallationpipinstallpullkinHow to useimportjsonimportos.pathimportasynciofrompullkinimportPullkinfrompullkin.modelsimportMessage,AppCredentialsfrompullkin.proto.mcs_protoimportDataMessageStanzaSENDER_ID='<<SENDER_ID>>'# '1234567890'# ANOTHER_SENDER_ID = '<<SENDER_ID>>'  # '1234567890'APP_ID='<<APP_ID>>'# '1:1234567890:android:abcdef1234567890'API_ID='<<API_ID>>'# 'AIzaSyDce4zFw4CqLqW2eCOqTbXfDx9a8mRnLpI'FIREBASE_NAME='<<FIREBASE_NAME'# 'pullkin-example'APP_NAME='<<APP_NAME>>'# 'cc.pullkin.example'#ANDROID_CERT='da39a3ee5e6b4b0d3255bfef95601890afd80709'# 'da39a3ee5e6b4b0d3255bfef95601890afd80709' is default hashpullkin=Pullkin()ifnotos.path.exists('.persistent_ids.txt'):withopen('.persistent_ids.txt','w+')asf:...withopen(".persistent_ids.txt","r")asf:received_persistent_ids=[x.strip()forxinf]@pullkin.on_notification()asyncdefon_notification(message:Message,data_message:DataMessageStanza):idstr=data_message.persistent_id+"\n"withopen(".persistent_ids.txt","r")asf:ifidstrinf:returnwithopen(".persistent_ids.txt","a")asf:f.write(idstr)print(message.notification)asyncdefmain():ifnotos.path.exists('.pullkin_app_credentials'):withopen('.pullkin_app_credentials','w+')asf:credentials=awaitpullkin.register(SENDER_ID,APP_ID,API_ID,FIREBASE_NAME,ANDROID_CERT,APP_NAME)f.write(json.dumps(credentials.model_dump(mode="json")))else:withopen('.pullkin_app_credentials','r')asf:credentials=AppCredentials.model_validate(json.loads(f.read()))awaitpullkin.add_app(sender_id=SENDER_ID,credentials=credentials,persistent_ids=received_persistent_ids)# await pullkin.add_app(sender_id=ANOTHER_SENDER_ID, credentials=another_credentials, persistent_ids=another_received_persistent_ids)awaitpullkin.run()asyncio.run(main())
Package: pullnrun
pullnrunA simple python app for running a set of commands from remote sources and pushing result files to remote targets.InstallingEnsure that you are using Python >= 3.6 withpython --version. To install, run:pipinstallpullnrunUsageExamplesSeeexamplesfor usage examples.TestingCheck and automatically fix formatting with:pycodestylepullnrun
autopep8-aaar--in-placepullnrunRun static analysis with:pylint-E--enable=invalid-name,unused-import,useless-object-inheritancepullnrunRun unit tests with command:python3-munittestdiscover-stst/Get test coverage with commands:coveragerun--branch--sourcepullnrun/-munittestdiscover-stst/
coveragereport-m
Package: pullover
The simplest Pushover API wrapper for Python.FeaturesNo extraneous requests - just sends non-emergency messages quickly and without fussAims to get the basics right, and be open to extension for more advanced use casesTimeouts and automatic back-off should Pushover be experiencing issuesIntuitive command-line interface with sane, parseable outputUnit and integration testedSigned PyPi releasesLimitationsPullover does not support:Anything other than sending messagesSending messages to a subset of a user’s devicesEmergency messagesCustomising the notification soundIf you need one of these, I’d recommend using Karan Lyons’sChumpwrapper.Installation$ pip install pulloverModuleThe following code snippets demonstrate the main features of pullover. For an exhaustive guide, see thedocumentation.High-levelimportpulloverresponse=pullover.send('message','user key','app token')ifresponse.ok:print(response.id)# 647d2300-702c-4b38-8b2f-d56326ae460bLow-levelfrompulloverimportApplication,User,Message,ClientSendError,\ServerSendErrortry:aws=Application('app token')george=User('user key')message=Message('message',title='hello')response=message.send(aws,george)response.raise_for_status()print(response.id)# 647d2300-702c-4b38-8b2f-d56326ae460bexceptClientSendErrorase:# it was our faultprint(e.status,e.errors)exceptServerSendError:# Pushover is having issuesprint(e.response.text)CLIThe CLI supports the same functionality as the library.$ pullover -a <app_token> -u <user_key> hello!
647d2300-702c-4b38-8b2f-d56326ae460b
$ export PUSHOVER_APP_TOKEN=token
$ export PUSHOVER_USER_KEY=key
$ pullover hello!
647d2300-702c-4b38-8b2f-d56326ae460b
$ pullover --help
usage: pullover [-h] [-V] [-v] -a APP -u USER [-p PRIORITY] [-t TITLE]
                [--timestamp TIMESTAMP] [--url URL] [--url-title URL_TITLE]
                message

The simplest Pushover API wrapper for Python.

positional arguments:
  message               the message content to send

optional arguments:
  -h, --help            show this help message and exit
  -V, --version         show program's version number and exit
  -v, --verbosity       increase output verbosity
  -a APP, --app APP     the application token to send from; defaults to
                        PUSHOVER_APP_TOKEN
  -u USER, --user USER  the user key to send to; defaults to PUSHOVER_USER_KEY
  -p PRIORITY, --priority PRIORITY
                        the priority of the message, either an integer or
                        string (e.g. '0' or 'normal')
  -t TITLE, --title TITLE
                        the title of the message; defaults to the name of the
                        sending application
  --timestamp TIMESTAMP
                        the timestamp of the message, in ISO 8601 format;
                        defaults to now
  --url URL             a url to include in footer of the message
  --url-title URL_TITLE
                        the URL title; requires --url
Package: pullparser
This project is obsolete.  There are many better ways to parse HTML these days.  If you really need the tarball, edit the path component of the URL to add an initial “/old”.A simple “pull API” for HTML parsing, after Perl’s HTML::TokeParser.
Many simple HTML parsing tasks are simpler this way than with the
HTMLParser module.  pullparser.PullParser is a subclass of
HTMLParser.HTMLParser.
Package: pull-request-auto-labeler
pull_request_auto_labelerAutomatically label Github pull requests based on elements of the PR title.
Default configuration expects Jira style ticket code(PROJ-100) in PR titleThis labeler does the following:get all open Pull Requests for all the repositories for an organization/usercheck each PR to see if it has any matching a Jira style ticket code in the title (PROJ-100)apply a label to the Pull Request matching the uppercase version of the project codes from the title (PROJ)InstallationIf you want to run this as a cron, you can install from pypi with pip:pip install pull-request-auto-labelerBut if you're going to set this up as an AWS Lambda, you'll want theserverless.yaml,serverless-requirements.txtandhandler.pyso you might as well pull the source.SetupSet the following enviornment vars:[Required] GITHUB_API_TOKEN:A Github API Token which has access to read the repositories you want
and modify
pull requests.
If you don't have one you see the guidehere[Required] ORGANIZATION:the name of the github organization/username that you want to check PRs for.[Optional] LABEL_EXTRACTING_REGEX:Regex expression which will be applied on the PR title using python'sre.findall.This regex expression should have one matching group which returns the portion of the title which
should be used as a label. i.e. if the regex finds PROJ-100, the matching group should be PROJSince we're usingre.findallthis can have multiple matches on the title, but each
match must have only one group.Default is\s*[\[]*([a-zA-Z0-9]{2,})[-|\s][0-9]+which matches:PROJ-100,[PROJ-100],B2C-1,Proj 100.Running from command linepython auto_labeler.pyRunning as a Cron on AWS LambdaFor convenience I've included setup instructions to run this as a cron using aws lambda made easy by theserverlesstoolkit. If you haven't used serverless, I have a getting started with serverless guidehereInstall serverless pluginsserverless-python-requirementsIts pretty annoying to add external requirements to a lambda when deploying manually. You have to build the wheels
for the packages on an aws linux ami and include those in the zip that you upload. Luckily, there's a serverless plugin
to make that all super easy.sls plugin install -n serverless-python-requirementsSetup serverless for this projectCopy theserverless.yaml,serverless-requirements.txtandhandler.pyfiles in this repo to wherever you're using this, or simply download this repo and use that as your sourcetweak any provider params you need to to match your setupSet the run frequency (update underfunctions>lambdaCron>events>schedule)Deploy to AWSsls deploy
Package: pull-requests
pull-requests⬆️ A command line tool for creating pull requests.RequirementsPython 3.10 or aboveInstallationpip install pull-requestsUsageFirst of all, you need to have a file in your project root directory calledpr.json. That file needs
to have the following fields in order to make the program works. See below an example of that file structure:{"username":"YOUR_GITHUB_USERNAME","repository":"YOUR_REPOSITORY_NAME","token":"YOUR_GITHUB_ACCESS_TOKEN"}That's is everything we need to use the program. Now, on your project root directory, you can the
following command:pull-requests--from"HEAD_BRANCH"--to"BASE_BRANCH"--title"Some title"--body"Some optional body text"LicenseThis project is licensed under the MIT license. SeeLICENSE.
Package: pull-webhook
Pull WebhookPull latest changes from a git remoteFree software: MIT licenseDocumentation:https://pull-webhook.readthedocs.io.FeaturesRuns a simple HTTPServer that waits for a POST request and triggers a git pull.CreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2018-07-17)First release on PyPI.
Package: pullyou
PullYou is a tool for opening the PR associated with a given git hash.Installpip3 install pullyouUsage$ pullyou 2aaf764552e012ac33cd7b2d6

$ pullyou 2aaf76455 --repo transcom/mymoveAuthIf accessing a private repository, create a github personal access token with thereposcope and drop it in ~/.github_token asusername:tokenReleasing$ python setup.py sdist bdist_wheel
$ twine upload dist/* [-r testpypi]
$ rm -rf dist/*
* tag the release
* bump the version number
Package: pulm
pulm: PlantUML script generatorInstallingpulmYou can install it from Pypi:pipinstallpulmYou can directly install it from source too:$gitclonepythongit@github.com:jjerphan/pulm.git
$cdpulm
$pythonsetup.pyinstallUsageAs an example we can usepulmon its own code.$pulm./pulm/pulm.py|plantuml-p>out/pulm.png&&openout/pulm.pnget voilà.You can do some more magic withentrto generate UML diagram on the fly 🛩LicenseThis project licenseis MIT.
Package: pulp2mat
pulp2matConvert pulp model into matrix formulation.It can be easily thrown to scipy.optimize.milp function.How to install$ pip install pulp2matWithout poetry, please look at pyproject.toml and install all dependencies manually.Quick ExampleFor example, the binpacking problem can be formulated with pulp as below;importpulpasplimportnumpyasnpitem_sizes=np.array([7,3,3,1,6,8,4,9,5,2])num_items=len(item_sizes)num_bins=len(item_sizes)bin_size=10# Variables * must be defined as dictionariesx={(i,j):pl.LpVariable("x_{}_{}".format(i,j),cat=pl.LpBinary)foriinrange(num_items)forjinrange(num_bins)}y={j:pl.LpVariable("y_{}".format(j),cat=pl.LpBinary)forjinrange(num_bins)}problem=pl.LpProblem()# Bin size constraint for each binforjinrange(num_bins):problem+=(pl.lpSum(x[i,j]*item_sizes[i]foriinrange(num_items))<=bin_size*y[j])# One-hot constraint for each itemforiinrange(num_items):problem+=pl.lpSum(x[i,j]forjinrange(num_bins))==1# Objective: minimize number of bins used.problem+=pl.lpSum(y[j]forjinrange(num_bins))thepulp.LpProblemobject and the list of variable dictionaries can be converted to the matrix format forscipy.optimize.milp.importpulp2matfromscipy.optimizeimportmilpc,integrality,constraints,bounds=pulp2mat.convert_all(problem)result=milp(c,integrality=integrality,constraints=constraints,bounds=bounds)
Package: pulp-ansible
A Pulp plugin to support hostingRoleandCollectionAnsible content.For more information, please see thedocumentation.Collection SupportWarningThe ‘Collection’ content type is currently in tech-preview. Breaking changes could be introduced
in the future.pulp_ansible can manage themulti-role repository contentreferred to as aCollection. The following features are
supported:ansible-galaxy collection publish- Upload a Collection to pulp_ansible for association with one or more
repositories.ansible-galaxy collection install- Install a Collection from pulp_ansible.Configuring Collection SupportYou’ll have to specify the protocol and hostname the pulp_ansible REST API is being served on. For
pulp_ansible to interact withansible-galaxycorrectly it needs the entire hostname. This is done
using theANSIBLE_HOSTNAMEsetting in Pulp. For example if its serving with http on localhost it
would be:export PULP_ANSIBLE_API_HOSTNAME='http://localhost:24817'
export PULP_ANSIBLE_CONTENT_HOSTNAME='http://localhost:24816/pulp/content'or in your systemd environment:Environment="PULP_ANSIBLE_API_HOSTNAME=http://localhost:24817"
Environment="PULP_ANSIBLE_CONTENT_HOSTNAME=http://localhost:24816/pulp/content"How to File an IssueNew pulp_ansible issue.WarningIs this security related? If so, please follow theSecurity Disclosuresprocedure.
Package: pulp-certguard
WarningThis pulp plugin has been merged into the main pulpcore project.
This repository can only accept bugfixes on release branches.A Pulp plugin that provides an X.509 capableContentGuardfor pulpcore. Instances ofX509CertGuardare useful for requiring clients to submit a certificate proving their entitlement
to content before receiving the content.For more information, please see thedocumentationor thePulp project page.Development moved to PulpcoreSince this plugin has been moved to pulpcore, issues can no longer be reported here. Please go toPulpcore - Issuesinstead.
Any issues that arise should also be solved there first and if needed backported here.
Package: pulp-container
This is thepulp_containerPlugin forPulp Project
3.0+. This plugin provides Pulp with support for container
images, similar to the pulp_docker plugin for Pulp 2.For more information, please see thedocumentationor thePulp project page.How to File an IssueNew pulp_container issue.WarningIs this security related? If so, please follow theSecurity Disclosuresprocedure.
Package: pulpcore
Acquire, Organize, and Distribute SoftwarePulp is a platform for managing repositories of content, such as software
packages, and pushing that content out to large numbers of consumers.Using Pulp you can:Locally mirror all or part of a repositoryHost your own content in a new repositoryManage content from multiple sources in one placePromote content through different repos in an organized wayPulp is completely free and open-source!License: GPLv2+Documentation:https://docs.pulpproject.org/Source:https://github.com/pulp/pulpcore/Bugs:https://github.com/pulp/pulpcore/issuesFor more information, check out the project website:https://pulpproject.orgGet HelpCheck out our help page for ways to get help:https://pulpproject.org/help/
Package: pulp-deb
pulp_debA Pulp plugin to host APT repositories.Visit thePulp project homepageor see theplugin documentationfor more information.
If you want to report a bug, see theissue tracker.The most important places:ThePulp project homepage.Theplugin documentation.Theplugin issue tracker.Theplugin source repository.Releasedpython packages on pypi.org.pulp-deb-clientAPI bindings for python and ruby for talking to the pulp_deb REST API.
These are automatically generated for each pulp_deb release using thepulp-openapi-generator.The most important places:Thepulp-deb-client Python package(contains API bindings for Python).Thepulp-deb-client Ruby Gem(contains API bindings for Ruby).pulp-cli-debA pulp-cli plugin to add the commands for using pulp_deb via Pulp CLI.The most important places:Thepulp-cli documentation.Thepulp-cli quick start guide.Thepulp-cli-deb source repository.Releasedpython packages for the deb Pulp CLI plugin.
Package: pulpfiction
*****PulpFiction*****.. image:: ./images/jules.png*English, *****! Do you speak it?*A simple tool to detect non-English commments in a code base (directory).Inspired by the fictional character, `Jules Winnfield, played by Samuel L Jackson in the film, Pulp Fiction`__... __: https://www.urbandictionary.com/define.php?term=Jules%20WinnfieldInstall#######.. code-block:: bash# requires Python3$ pip install pulpfictionUsage#####.. code-block:: bash$ jules --helpUsage: jules [OPTIONS]Simple tool to detect non-English commments in a code base..Options:--path TEXT           path to project or repository--help                Show this message and exit... code-block:: bash# by default, it looks at the current directory or $PWD# alternatively,$ jules --path=~/personal/my-awesome-git-projectScript exits with `sys.exit(0)` if successful, else the earliest invalid comment is found and raised.Known Issues############- Commented-out code will be considered non-English; false positive.
Package: pulpo
Build Statusmaster:pulpoA library and sdk for non-contextual and contextual Multi-Armed-Bandit (MAB) algorithms for multiple use cases. The sdk version enables you to deploy it on AWS.InstallationPrerequisitespulpo requires Python 3.6+Install pulpoAt the command line:pip install pulpoHow ToLibraryPulpo can be used as a library to instantiate and run online MABs. The core of the library are the bandit implementations underpulpo/badnitsmodule. The super class of them isOnlineBanditif you wish to implement your own MAB implementation.Currently, the following MAB implementations are available:Epsilon Greedy (EGreedy)The usage of this library starts fromPulpoclass. For example, let's say that we want to run 1 online bandit with 3 arms usingEGreedy, then:frompulpo.bandits.dataclassesimportEpsilonGreedyArmfrompulpo.bandits.epsilon_greedyimportEGreedyfrompulpo.pulpoimportPulpoarm_names=["article1","article2","article3"]arms=[EpsilonGreedyArm(name,1,0)fornameinarm_names]# priors for n=1 and sum=0, i.e. steps and total reward so farbandit=EGreedy("article_recommendation",arms,epsilon=0.9)pulpo=Pulpo([bandit])# Instantiate Pulpoarm_id=pulpo.choose(bandit.bandit_id)# to get an arm decision# get some feedback for the arm decision and pass it to backfeedback=1.0pulpo.update(bandit.bandit_id,arm_id,feedback)Alternatively, thePulpoclass can be instantiated in the following manner:importjsonfrompulpo.pulpoimportPulpobandit_id="article_recommendation"config=config=[{"bandit_id":bandit_id,"bandit_type":"epsilon_greedy","arm_ids":["article1","article2","article3"]}]pulpo=Pulpo.make_from_json(json.dumps(config))# Instantiate Pulpoarm_id=pulpo.choose(bandit_id)# to get an arm decision# get some feedback for the arm decision and pass it to backfeedback=1.0pulpo.update(bandit_id,arm_id,feedback)AWS SDKPulpo can be used as an sdk to deploy and run MABs on AWS. Soon...
Package: pulpo-dev
◦ Python-based User-defined Lifecycle Production Optimization!📍 OverviewThe project, "pulpo," is a life cycle assessment (LCA) optimization tool that aims to import, optimize, solve, retrieve, save, and summarize LCA results. It provides functionalities for data import from the Ecoinvent database, conversion of inputs into a dictionary for the optimization model, definition and solving of the optimization model using the pyomo package, and saving and summarizing of the model results. The tool's value lies in streamlining LCA processes, enabling optimization and analysis of environmental impacts, and facilitating the decision-making process for sustainable solutions.🚀 Getting Started🔧 InstallationYou can now install PULPO via pip:pipinstallpulpo-devThis will install PULPO and all its dependencies. It is advised to create a new venv/conda environment for
performing tasks with PULPO, in order to avoid package conflicts with other tools such as brightway, activity-browser,
or premise.🤖 Running pulpoAfter installing PULPO, check if the package has been set up properly by running the setup function:frompulpo.utilsimporttests

tests.setup()This function mimics the development test functions and if all tests have passed you are good to go.To learn the PULPO workflow for more complex case studies, find example notebooks for ahydrogen caseand anelectricity casehere.You can also follow these notebooks locally with the shipped package by calling:frompulpoimportpulpo

pulpo.electricity_showcase()pulpo.hydrogen_showcase()It should be noted that to run these showcase it is necessary to install the ecoinvent cutoff38 system model via brightway2/activity-browser.
Please follow instructions onBrightway2orActivity-Browserto see how this is done.📄 LicenseThis project is licensed under theℹ️  BSD 3-ClauseLicense.
Copyright (c) 2023, Fabian Lechtenberg. All rights reserved.👏 AcknowledgmentsWe would like to acknowledge the authors and contributors of these main packages that pulpo is based on:pyomobrightway2Authors@flechtenberg@robyistrate@vtulus↑ Return