Saravanan666/pypi-org huggingface dataset:
Package: progenitor-probability
[![PyPI](https://img.shields.io/pypi/v/progenitor-probability.svg)](https://pypi.python.org/pypi/progenitor-probability/) [![Python](https://img.shields.io/pypi/pyversions/progenitor-probability.svg)](https://pypi.python.org/pypi/progenitor-probability/)## *README* for `tabulate_progenitor_probability.py`### Reference:[***Martin et al. 2018a***](https://doi.org/10.1093/mnras/stx3057 "Martin+18a"),*Martin, G., Kaviraj, S., Devriendt J. E. G., Dubois Y., Pichon C. and Laigle C., MNRAS, 474, 3140*### Contact:[g.martin4@herts.ac.uk](mailto:g.martin4@herts.ac.uk "email")### Purpose:Reads `fractions.dat` binary file and returns the joint progenitor probability for given redshift, mass, environment (percentile) and star-formation rate (i.e. the probability that a galaxy with given properties has spheroidal morphology at z=0). If one or more dimensions are not specified, the joint progenitor probability is returned with missing dimensions marginalised out.### Prerequisites:* `fractions.dat`* numpy* scipy### Installation:pip install progenitor-probability### Usage:#### Using the built-in script:```tabulate_progenitor_probability.py -z 0.4 -m 10.80.266751184855``````tabulate_progenitor_probability.py --helpusage: tabulate_progenitor_probability.py [-h] [-z REDSHIFT] [-m MASS][-p DENSITY] [-s SFR]optional arguments:-h, --help            show this help message and exit-z REDSHIFT, --redshift REDSHIFTRedshift-m MASS, --mass MASS  Log10 stellar mass/M_sun-p DENSITY, --density DENSITYLocal number density percentile [0,100]-s SFR, --SFR SFR     SFR in M_sun/yr```**-z** *redshift***-m** *log<sub>10</sub>(stellar mass / M<sub>sun</sub>)***-p** *percentile of local number density* in the range [0,100] (see [Martin et al. 2018a](https://doi.org/10.1093/mnras/stx3057 "Martin+18a"))**-s** *star formation rate in M<sub>sun</sub>/yr*#### Importing the package```from progenitor_probability import progenitor_probability>>> progenitor_probability(redshift=0.4, mass=10.8)0.266751184855```
Package: progen-torch
ProgenImplementation of Progen in Pytorch, from the paper "ProGen: Language Modeling for Protein Generation"GPT for proteins sequencesPaper LinkAppreciationLucidrainsAgoriansInstallpip install progen-torchUsageimporttorchfromprogen.modelimportProGenx=torch.randint(0,100,(1,1024))importtorchfromprogen.modelimportProGenx=torch.randint(0,100,(1,1024))# Initialize the model with specific parametersmodel=ProGen(num_tokens=100,# The size of the vocabularydim=512,# The dimension of the embeddingsseq_len=1024,# The length of the sequencesdepth=6,# The number of layers in the modelwindow_size=256,# The size of the window for local attentionglobal_mlp_depth=2,# The depth of the MLP in the global attention mechanismheads=8,# The number of attention headsdim_head=512,# The dimension of each attention headff_mult=4,# The multiplier for the feed-forward network's hidden layer sizeff_glu=True,# Whether to use a GLU activation in the feed-forward networkattn_dim=None,# The dimension of the attention mechanism (None means it defaults to `dim`)clamp_gate=True,# Whether to clamp the gate values in the GLU activationshift_tokens=True,# Whether to shift the tokens for the causal attention mechanismdropout=0.1,# The dropout rate)# Forward pass through the modellogits=model(x)# The output is the logits for each token in the vocabulary, for each position in the input sequences# Shape: (batch_size, sequence_length, num_tokens)print(logits.shape)# Should print: torch.Size([1, 1024, 100])Dataset StrategyHere is a table of the datasets used in the paper with metadata and source links:DatasetDescriptionSourceUniparcContains protein sequences from various sourceshttps://www.uniprot.org/uniparc/UniprotKBContains protein sequences and annotationshttps://www.uniprot.org/uniprot/SWISS-PROTCurated protein sequence databasehttps://www.uniprot.org/swiss-prot/TrEMBLComputer-annotated protein sequenceshttps://www.uniprot.org/trembl/PfamDatabase of protein familieshttps://pfam.xfam.org/NCBI taxonomyTaxonomic classification of organismshttps://www.ncbi.nlm.nih.gov/taxonomyHere is a diagram showing the data preprocessing flow:graph TD
    A[Uniparc] --> B[Filter and merge]
    C[UniprotKB] --> B
    D[SWISS-PROT] --> B 
    E[TrEMBL] --> B
    F[Pfam] --> B
    G[NCBI taxonomy] --> B
    B --> H[Train/test split]
    H --> I[Train set]
    H --> J[ID test set] 
    H --> K[OOD test set]The Uniparc, UniprotKB, SWISS-PROT, TrEMBL, Pfam, and NCBI taxonomy datasets are filtered and merged in step B. The aggregated dataset is then split into training, in-distribution test, and out-of-distribution test sets in step H.ArchitectureTodoLicenseMITCitations
Package: progentrl
Pro Generative Tensorial Reinforcement Learning (proGENTRL)This is aPytorch Lightningimplementation ofGENTRL. Recently Pytorch Lightning has gained much popularity due to its lightweight framework and flexibility with handling multiple devices from a single GPU to a HPC cluster. So in order to maximize the efficiency of using GENTRL on multi-GPU environment I have implemented this pytorch lightning code.What is GENTRL?The GENTRL model is a variational autoencoder with a rich prior distribution of the latent space. We used tensor decompositions to encode the relations between molecular structures and their properties and to learn on data with missing values. We train the model in two steps. First, we learn a mapping of a chemical space on the latent manifold by maximizing the evidence lower bound. We then freeze all the parameters except for the learnable prior and explore the chemical space to find molecules with a high reward.InstallationStep 1 :Make a new conda environment and install RDKit.conda create -c rdkit -n my-rdkit-env rdkitThen activate this new environment.conda activate my-rdkit-envNote :Make sure that the python3 version is 3.5 or higher and pip3 is installedStep 2 :Inside this environment install proGENTRL.Using pip (Recommended)pip install progentrlUsing sourcegit clone https://github.com/Bibyutatsu/proGENTRL.git
cd proGENTRL
python3 setup.py installStep 3 :Then I will suggest you install pytorch's latest version according to your cuda version (For e.g. 10.2)python3 -m pip uninstall torch torchvision
conda install pytorch torchvision cudatoolkit=10.2 -c pytorchStep 4 : (Optional)Making a newKernelfor jupyter notebook is recommended. For making a new kernel please follow these steps.python3 -m pip install ipykernel
python3 -m ipykernel install --user --name rdkit_kernelNow when you open jupyter notebook. Go toChange Kernel>rdkit_kernelWith these the installation is over and now we are ready to run theExample.ipynbnotebook provided in the Repo.Example.ipynbThis notebook is a good starting point to look at how proGENTRL works. It incorporates all the steps fromVAE TrainingtoReinforcement Learningand finallySamplingor generation of new molecules in the form of SMILES strings.The basic flow of the model is:VAE Train:arrow_right:Reinforcement Learning:arrow_right:SamplingBelow we show examples of generated molecules (more sampleshere). You can find more explanations in my originarlly forked Repo of GENTRL please visithereFor reading more  visit myblogSupporting Information for the paper"Deep learning enables rapid identification of potent DDR1 kinase inhibitors".
OriginalRepo
Package: progeny
Simple (but powerful) management for complex class hierarchies.MotivationWhileXYZClass.__subclasses__()returns the children of a class, there is
no built-in way to return all descendants. This is the core of Progeny’s
purpose.In addition, Progeny provides tools to help manage complex, deeply nested
class hierarchies - hiding individual classes, keeping a registry of
descendants, etc.ExamplesBasic UsageimportprogenyclassNotificationHandler(progeny.Base):defsend_message(self,*args,**kwargs):raiseRuntimeErrorclassCustomerOneNotificationHandler(NotificationHandler):defsend_message(self,*args,**kwargs):# .. business logic ...classCustomerTwoNotificationHandler(NotificationHandler):defsend_message(self,*args,**kwargs):# .. business logic ...Now we can iterate over all of the subclasses ofNotificationHandler:defsend_newsletter():forhandlerinNotificationHandler.progeny.values():handler.send_message('Your attention, please!')Omitting descendant classesIn some cases, it may be useful to prevent descendant classes from being visible to Progeny.fromprogenyimportprogeny.BaseclassNotificationHandler(progeny.Base):defsend_message(self,*args,**kwargs):raiseRuntimeErrorclassEmailNotificationHandler(NotificationHandler):__progeny_tracked__=Falsedefsend_message(self,*args,**kwargs):# .. business logic ..classSmsNotificationHandler(NotificationHandler):__progeny_tracked__=Falsedefsend_message(self,*args,**kwargs):# .. business logic ..classCustomerOneNotificationHandler(EmailNotificationHandler):passclassCustomerTwoNotificationHandler(SmsNotificationHandler):passAny classes with__progeny_tracked__set to a falsy value during class
construction will be ignored by Progeny. It’s descendant classes are unaffected:NotificationHandler.progeny.values()# {CustomerOneNotificationHandler, CustomerTwoNotificationHandler}This can be especially handy to conditionally track subclasses based on config
context:classCustomerFooNotificationHandler(EmailNotificationHandler):__progeny_tracked__=config.get('CUSTOMER_FOO_ACTIVE')Using the descendants registryProgeny makes it easy to choose between descendant classes at runtime:fromprogenyimportprogeny.Basefrommy_app.usersimportUserLevelclassUploadParser(progeny.Base):passclassFreeUserUploadParser(UploadParser):__progeny_key__=UserLevel.FREEdefparse_upload(self,*args,**kwargs):# .. logic to parse the upload slowly, using shared resourcesclassPremiumUserUploadParser(UploadParser):__progeny_key__=UserLevel.PAIDdefparse_upload(self,*args,**kwargs):# .. logic to parse the upload immediately with dedicated resourcesdefparse_upload(data):UploadParser.progeny.get(session.user.level).parse_upload(data)Publishing to PyPIpythonsetup.pysdistbdist_wheeltwineupload"dist/*"
Package: progeval
Progressive evaluationDocumentation|Installation|Examples|RelatedThis package lets the user define a computation such that:Depending on the requested output, only the required (partial) computations are executed.Intermediate quantities can be overriden by the user such that dependent values are recomputed.The computational graph can either be defined as a class, or is constructed dynamically by registering nodes.InstallationTo use progeval, it can be installed with pip:(.venv)$pipinstallprogevalExamplesConsider the following toy computation:alpha = x * y
beta = x + y
total = alpha + betaWe can define this computational graph in multiple ways, all via the computational graph classProgEval.
The first is by dynamically adding nodes corresponding to the computable objects:fromprogevalimportProgEvalgraph=ProgEval()graph.alpha=lambdax,y:x*ygraph.beta=lambdax,y:x+ygraph.total=lambdaalpha,beta:alpha+beta# we can then set inputs ...graph.x,graph.y=3,6# ... and evaluate any (intermediate) valuegraph.total==27The above example relies on the fact that the inputs (x,alpha, etc.) can be read from the function signatures.
If we want to reuse some external function this is not possible.
The following syntax allows one to (optionally) specify the input arguments:fromprogevalimportProgEvaldefadd(x,y):returnx+ygraph=ProgEval()graph.register('alpha',lambdax,y:x*y)graph.register('beta',add)# here the inputs we want are different from the names# in the function definition of `add`graph.register('total',add,['alpha','beta'])Another way to define the computational graph is by collecting all parts of the computation as methods of a class:fromprogevalimportProgEvalclassComputation(ProgEval):def__init__(self,x,y):super().__init__(x=x,y=y)@staticmethoddefalpha(x,y):returnx*y@staticmethoddefbeta(x,y):returnx+y@staticmethoddeftotal(alpha,beta):returnalpha+beta# The class then acts almost like a normal functionComputation(3,8).total==35RelatedA similar functionality of delayed evaluation of a computational graph is provided byDask delayed.
However, the construction is slightly different.
There, the graph is built dynamically by replacing intermediate quantities withDelayedobjects and wrapping functions.
The functionality ofDask, which is intended for computational parallelism, can even be combined with the structures here, as shown in the how-to section of the documentation.
Package: progfiguration
progfigurationPROGrammatic conFIGURATION.
I'm tired of writing YAML when what I want to write is Python.DevelopmentMake and activate a venv, and install as editable.python3-mvenvvenv
.venv/bin/activate
python3-mpipinstall--upgradepip
python3-mpipinstall--editable'.[development]'From there:progfiguration --helpto run the programinvoke -lto list tasks for building documentation, running tests, and making releasesBuilding and releasingWe only actually need to build a source version of the package,
because progfiguration expects that your progfigsite package will pull in the source code.
We avoid building the binary version because it takes longer.TestingRun tests withinvoke tests.
Run with--slowto run slow tests too.
Special environment variables:PROGFIGURATION_TEST_VERBOSE=1: Show verbose output, including stdout/stderr of commands run inside of testsPROGFIGURATION_TEST_DEBUG=1: Launch a debugger on any test failure or exceptionPROGFIGURATION_TEST_SLOW_ALL=1: Run all slow tests (same asinvoke tests --slow)PROGFIGURATION_TEST_SLOW_PACKAGING=1: Run just slow tests related to packaging (progfiguration build, etc)Building the example sitesIn the same venv as above:# Install the example progfigsitepython3-mpipinstall--editable'tests/data/simple[development]'# Run the progfigsite itselfprogfigsite--helpMaking a releaseCheck out themasterbranch.
Make sure your checkout is clean, with all changes committed to git and pushed to GithubSet the version inpyproject.tomland updatedocs/appendix/changelog.rst.
Don't commit the change yet.
We'll read this file to determine the version to tag in git and push to PyPI.This will require Python 3.11 because we parse the TOML file directly withtomllib.We can't useprogfiguration versionfor this because it will return the version as it was at install time.Runinvoke make-releaseThe documentation will be updated with the lastest version number and content as well via Github Actions.
Package: proggy
ProggyProgressively progressing through progress bar generation.Proggy generates text-based progress bars. Mildly inspired by Rust'sindicatif.Proggy only renders progress bars to a string. Displaying them is, as of now,
not handled and left to the user.ExamplesAPI usage>>> from proggy import ProgressBar
>>> pb = ProgressBar(30, 100, progress=75)
>>> pb.render()
'⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇       'CLI outputSingle progress bar (test.py):importtimefromproggyimportBarInfofromproggy.ttyimportTTYProgressBarwithTTYProgressBar(BarInfo(size=30,total=100))asp:foriinrange(100):time.sleep(0.1)p.progress+=1Output:Multi-progress bar withasyncio(async_test.py):from asyncio import ensure_future, run, sleep

from proggy import BarInfo, LogicalProgressBar
from proggy.types import ProgressBar
from proggy.tty import TTYMultiProgressBar


async def task1(p: ProgressBar):
    for _ in range(100):
        await sleep(0.1)
        p.progress += 1


async def task2(p: ProgressBar):
    for _ in range(50):
        await sleep(0.1)
        p.progress += 1


async def main():
    with TTYMultiProgressBar(bar_infos=[
        BarInfo(size=30, total=100),
        BarInfo(size=30, total=50),
    ]) as mp:
        x = ensure_future(task1(mp.bar_at(0)))
        await task2(mp.bar_at(1))
        await x

run(main())Output:
Package: proglearn
ProgLearnProgLearn(ProgressiveLearning) is a package for exploring and using progressive learning algorithms developed by theneurodata group.Installation Guide:http://proglearn.neurodata.io/install.htmlDocumentation:http://proglearn.neurodata.ioTutorials:http://proglearn.neurodata.io/tutorials.htmlSource Code:http://proglearn.neurodata.io/reference/index.htmlIssues:https://github.com/neurodata/proglearn/issuesContribution Guide:http://proglearn.neurodata.io/contributing.htmlSome system/package requirements:Python: 3.6+OS: All major platforms (Linux, macOS, Windows)Dependencies: tensorflow, scikit-learn, scipy, numpy, joblib
Package: progmon
progmon - a simple progress monitorThis module offers different methods to show the current status of an
iterative calculation algorithm, or to control its execution, i.e. abort it
when certain criterions are met.Copyright noticeCopyright (C) 2013-2023 Daniel Jung.
Contact:proggy-contact@mailbox.orgThis program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the Free
Software Foundation; either version 2 of the License, or (at your option)
any later version.This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
more details.You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
Package: progo
ProgoAn Upside-Down and Backwards™ implementation of GoPro's Open API.But first!Frequently Asked QuestionsWTF would you do this?I bought a Hero10 and wanted to see how it works. And what can be done with it.I also wanted an excuse to useattrs.What model of GoPro is this compatible with?Hero10 (Open GoPro API 2.0)Older models (Open GoPro API 1.0), but with some functionality degradation (shutter/encoding control).Does it work with more than one camera?Good question! If you send me another Hero10 I'll make sure it works 😉.Installing Progo$ pip install progoDeveloping Progo$ FIXME
Package: progpysmt
progpysmt - A SMT-LIB, SyGuS and ProgSynth parserThis repository is a modification ofpySMT: a Python API for SMT. The goal of this project is to extend the parser in order to accept theSyGuSformat and adapts the output to theProgSynthformat.UsageIn order to use the SMT-LIB parser from the originalpySMTrepository, please follow the instructions on their personal github.
In order to use the parser on a given file of namefile_name:fromprogpysmt.smtlib.parserimportProgSmtLibParserfromprogpysmt.pslobjectimportPSLObjectparser=ProgSmtLibParser()withopen(file_name)asf:pslobject=parser.get_script(f,file_name)This will create aPSLObjectthat contains all the values required to use ProgSynth.InstallationFrom sourceIf you install this from source, you will need Python 3.7 or higher.InstallYou can use pip to install the project.pipinstallprogpysmt
Package: programGUI
programGUIDescriptionMakes it easy to start your application in GUI mode.Requiredpython3pipDirectories structure.githubISSUE_TEMPLATEbug_report.mdfeature-request.mdworkflowspypi-on-push.ymlpypi-on-release.ymlpython-test.ymlprogramGUI__init__.pytest-programGUI.pydocsLICENSEREADME.mdlogtrace.logrequirementsrequirements.txt.gitignoresetup.pyExecution examplespython3 programGUI.pypython3 test_programGUI.pyChangelogVersion_01.04_2021-04-23Version_01.03_2021-04-22Version_01.02_2021-04-22Version_01.01_2021-04-22Version_01.04_2021-04-23Fixed a GUI bugVersion_01.03_2021-04-22Fixed a bugVersion_01.02_2021-04-22Fixed a bugVersion_01.01_2021-04-22Initial versionMade by Castellani Davide
If you have any problem please contact me:help@castellanidavide.itIssue
Package: programl
ProGraML: Program Graphs for Machine LearningAn expressive, language-independent representation of programs.Checkthe websitefor more information.IntroductionProGraML is a representation for programs as input to a machine learning model.
The key features are:Simple:Everything is available through apip install, no compilation
required. Supports several programming languages (C, C++, LLVM-IR, XLA) and
several graph formats (NetworkX, DGL, Graphviz, JSON) out of the box.Expressive:Captures every control, data, and call relation across entire
programs. The representation is independent of the source language. Features
and labels can be added at any granularity to support whole-program,
per-instruction, or per-relation reasoning tasks.Fast:The core graph construction is implemented in C++ with a low
overhead interface to Python. Every API method supports simple and efficient
parallelization through anexecutorparameter.To get stuck in and play around with our graph representation, visit:Or if papers are more your ☕, have a read of ours:Supported Programming LanguagesThe following programming languages and compiler IRs are supported
out-of-the-box:LanguageAPI CallsSupported VersionsCprograml.from_cpp(),programl.from_clang()Up to ISO C 2017C++programl.from_cpp(),programl.from_clang()Up to ISO C++ 2020 DISLLVM-IRprograml.from_llvm_ir()3.8.0, 6.0.0, 10.0.0XLAprograml.from_xla_hlo_proto()2.0.0Is your favorite language not supported here? Submit afeature
request!Getting StartedInstall the latest release of the Python package using:pip install -U programlThe API is very simple, comprising graphcreationops, graphtransformops,
and graphserializationops. Here is a quick demo of each:>>>importprogramlaspg# Construct a program graph from C++:>>>G=pg.from_cpp("""... #include <iostream>...... int main(int argc, char** argv) {...   std::cout << "Hello, world!" << std::endl;...   return 0;... }... """)# A program graph is a protocol buffer:>>>type(G).__name__'ProgramGraph'# Convert the graph to NetworkX:>>>pg.to_networkx(G)<networkx.classes.multidigraph.MultiDiGraphat0x7fbcf40a2fa0># Save the graph for later:>>>pg.save_graphs('file.data',[G])For further details check out theAPI
reference.ContributingPatches, bug reports, feature requests are welcome! Please use theissue trackerto file a
bug report or question. If you would like to help out with the code, please
readthis document.CitationIf you use ProGraML in any of your work, please citethis
paper:@inproceedings{cummins2021a,
  title={{ProGraML: A Graph-based Program Representation for Data Flow Analysis and Compiler Optimizations}},
  author={Cummins, Chris and Fisches, Zacharias and Ben-Nun, Tal and Hoefler, Torsten and O'Boyle, Michael and Leather, Hugh},
  booktitle = {Thirty-eighth International Conference on Machine Learning (ICML)},
  year={2021}
}
Package: programmers-dice
Programmers' diceGenerates excuses for programmers.Inspired by this product:https://pretendstore.co/products/pocket-developerInstallationpipinstallprogrammers_diceUsageIn your terminal, typerollto get an excuse:$rollCtrl+Shift+R should fix it.Or, typeroll --count NforNexcuses to choose from!$roll-c3My wrist hurts.It's a feature.Clear your cache.Local Development / TestingCreate and activate a virtual environmentRunpip install -r requirements-dev.txtto do an editable installRunpytestto run testsType CheckingRunmypy .Create and upload a package to PyPIMake sure to bump the version insetup.cfg.Then run the following commands:rm-rfbuilddist
pythonsetup.pysdistbdist_wheelThen upload it to PyPI usingtwine:twineuploaddist/*
Package: programmershousewrapper
programmershousewrapperProgrammers House api official wrapper:https://www.programmershouse-api.gaInstall:pipinstallprogrammershousewrapperExample of using:importprogrammershousewrapperjoke=programmershousewrapper.joke()print(joke)​​​​NSFW endpoints using exampleimportprogrammershousewrapperconstnsfw=programmershousewrapper.hentai("api key from our discord server: https://discord.gg/gqKbGBWmRz")NEW endpointsalerts - endpoint for air alert notification in Ukraineimportprogrammershousewrapperconstalerts=programmershousewrapper.alerts()All endpointsjokeeightballcatsukrainewantedwastedredditukrmemesreversetextemojifyshotoniphonenumberfactyearsfactcosmosfactsqrcoderandomtextcurrentdayminecraftserveraboutinvitemarsgeometrydashsubredditrandomanimehugcrydancelaughkisspatwinkpunchhentai