Saravanan666/pypi-org huggingface dataset:
Package: proteo-estimator
ProteoEstimatorOverviewInstallationUsagepredict_protein_abundancespredict_phosphoValueNoteOverviewWe present the first data science competition aiming at predicting protein levels from copy number and transcript levels, as well as phosphorylation levels from protein levels. The winning models outperform standard baseline machine learning methods and simply using the transcript levels as proxy for protein levels with respect to prediction performance on new patient samples.
An in depth analysis revealed associations between the commonly predictive genes and essentiality. We provide all the submitted models to the community for re-use and a web application to explore the result of this challenge to support improved large scale proteogenomic characterization of tumor samples and a better understanding of signaling deregulation.Installationpipinstallproteo_estimatorRequires Python3Usageimportproteo_estimatoraspr# Subchallenge 2: predicting protein levels from copy number and transcript levelsprediction_file_protein=pr.predict_protein_abundances(tumor,rna,cna,output_dir,logging=True)# Subchallenge 3: predicting phospho levels from protein abundance and transcript levelsprediction_file_phospho=pr.predict_phospho(tumor,rna,protein,output_dir,logging=True)predict_protein_abundancesArgumentsParameterDefaultTypeDescriptiontumorstrTumor type, options are 'breast' and 'ovarian'rnastrAbsolute file path for rna table. Table must be in TSV format of genes x samplescnastrAbsolute file path for cna table. Table must be in TSV format of genes x samplesoutput_dirstrAbsolute file path for output directory. Prediction table and confidence scores will be saved under this directory as prediction.tsv and confidence.tsvloggingTrueboolPrint progress to stdoutReturn ValueOutputTypeDescriptionprediction_filestrPath to tab-separated file of predicted protein levels in the shape of genes x samples. This file will be saved in the directory passed to the parameter "output_dir" as prediction.tsvpredict_phosphoArgumentsParameterDefaultTypeDescriptiontumorstrTumor type, options are 'breast' and 'ovarian'rnastrAbsolute file path for rna table. Table must be in TSV format of genes x samplesproteinstrAbsolute file path for protein abundance table. Table must be in TSV format of genes x samplesoutput_dirstrAbsolute file path for output directory. Prediction table and confidence scores will be saved under this directory as prediction.tsv and confidence.tsvloggingTrueboolPrint progress to stdoutReturn ValueOutputTypeDescriptionprediction_filestrPath to tab-separated file of predicted protein levels in the shape of genes x samples. This file will be saved in the directory passed to the parameter "output_dir" as prediction.tsvNotePlease ensure that your docker daemon is running in the background.
All file paths must be absolute.
Package: proteofav
Protein Feature Aggregation and VariantsProteoFAV is a Python module that address the challenge of cross-mapping protein structures and protein sequences,
allowing for protein structures to be annotated with sequence features. It implements methods for working with
protein structures (via mmCIF, PDB, PDB Validation, DSSP and SIFTS files), sequence Features (via UniProt GFF annotations) and
genetic variants (via UniProt/EBI Proteins API and Ensembl REST API). Cross-mapping of structure and sequence is
performed with the aid of SIFTS.ProteFAV relies heavily in thePandaslibrary to quickly load data into DataFrames for fast
data exploration and analysis. Structure and sequence
data are parsed/fetched onto Pandas DataFrames that are then merged-together (collapsed) onto a
single DataFrame.Getting StartedDependenciesProteoFAV was developed to support Python 3.5+ and Pandas 0.20+.Checkrequirementsfor specific requirements.InstallationTo install the stable release, run this command in your terminal:$pipinstallproteofavIf you don’t havepipinstalled, thisPython installation guidecan guide
you through the process.Installing from source in a virtual environmentGetting ProteoFAV:$wgethttps://github.com/bartongroup/ProteoFAV/archive/master.zip-OProteoFAV.zip$unzipProteoFAV.zip# alternatively, cloning the git repository$gitclonehttps://github.com/bartongroup/ProteoFAV.gitInstalling With Conda:$conda-envcreate-nproteofav-fpath/to/ProteoFAV/requirements.txt$sourceactivateproteofav$cdpath/to/ProteoFAV$pipinstall.Installing with Virtualenv:$virtualenv--python`whichpython`env$sourceenv/bin/activate$pipinstall-rrequirements.txt$pythonpath/to/ProteoFAV/setup.pyinstallTesting the installationTest dependencies should be resolved with:$pythonpath/to/ProteoFAV/setup.pydevelop--userRun the Tests with:$pythonpath/to/ProteoFAV/setup.pytest# or$cdpath/to/ProteoFAV/tests$python-munittestdiscoverProteoFAV ConfigurationProteoFAV uses a configuration fileconfig.iniwhere the user can specify the directory paths, as well as urls for commonly used data sources.After installing run:$proteofav-setupExample UsageExample usage is currently provided as aJupyter Notebook, which can be viewed with theGitHub’sfile viewer or with the Jupyternbviewer.You can download the Jupyter notebook fromGitHuband test it with your ProteoFAV’s installation.Contributing and Bug trackingFeel free to fork, clone, share and distribute. If you find any bugs or
issues please log them in theissue tracker.Before you submit yourPull-requestsread theContributing Guide.CreditsSee theCreditsChangelogSee theChangelogLicensingThe MIT License (MIT). Seelicensefor details.
Package: proteoformquant
ProteoformquantProteoformquant is a Python tool for quantitative analysis of proteoforms from mass spectrometry data.Setup/InstallationVia PyPi repository (Recommended)1. Install Proteoformquant packageThe  simplest way to use Proteformquant is to downloading it as a package from the PyPi repository using pip.pipinstallproteoformquantYou should then be able to run Proteoformquant by running the following line in a terminal2. Run ProteoformquantproteoformquantAccess help by runningproteoformquant-hMore information on how to use proteoformquant is avaible in the 'usage' section of this document.Via github (Alternative) (not available currently)You also have the possibility to clone the repository from github and manually install the dependencies. You will need to create a Conda environment.1. Install Conda (and Mamba)If not already done, install Conda (https://docs.conda.io/projects/conda/en/stable/user-guide/install/index.html#regular-installation)If you wish to use Mamba to create the Conda environment (faster) you can install mamba by running the following command in a terminal:condainstallmamba-nbase-cconda-forge2. Clone proteoformquant repositorygitclonehttps://github.com/arthur-grimaud/Proteoformquant.git3. Create and activate the environmentNext, create the environment using either Conda or Mamba by running the following command in the folder where 'environment.yml' is located# With Condacondaenvcreate--fileenvironment.yml#With Manbamambaenvcreate--fileenvironment.ymlyou should now be able to activate the environment with:mambaactivatepfq-env4. Run ProteoformquantRun Proteoformquant by running the 'proteoformquant.py' script in 'src/proteoformquant'python3src/proteoformquant/proteoformquant.pyUsage(n.b the command line listed here are given for the installation of Proteoformquant as a package. you will need to adapt the commands if you use the second installation method)Proteoform requires 3 input files:
-spectra file (.mgf or .mzml)
-indentification file (.mzid)
-a parameter file (.json)A parameter file can be generated by running.proteoformquant-cpIf you do not change the name or location of the parameter file you can run proteoformquant as followproteoformquant-ipath/to/identification/file.mzid-spath/to/spectra/file.mgfby default this will create an output file 'output/' in the local directory. If you wish to change that use the -d parameterproteoformquant-ipath/to/identification/file.mzid-spath/to/spectra/file.mgf-dpath/to/my_output_foldersimilarly you can change the outfile name with the -o parameterproteoformquant-ipath/to/identification/file.mzid-spath/to/spectra/file.mgf-dpath/to/my_output_folder-ooutput_file_1ContributingTo updateLicenseTo update
Package: proteomicruler
Proteomic RulerAn implementation of the same algorithm from PerseusWiśniewski, J. R., Hein, M. Y., Cox, J. and Mann, M. (2014) A “Proteomic Ruler” for Protein Copy Number and Concentration Estimation without Spike-in Standards. Mol Cell Proteomics 13, 3497–3506.used for estimation of protein copy number from deep profile experiment.RequirementsPython >= 3.9InstallationpipinstallproteomicrulerUsageIn order to use the package, it is required that the input data is loaded into apandas.DataFrameobject. The following
basic parameters are also required:accession_id_col- column name that contains protein accession idsmw_col- column name that contains molecular weight of proteinsploidy- ploidy numbertotal_cellular_protein_concentration- total cellular protein concentration used for calculation of total volumeintensity_columns- list of column names that contain sample intensitiesimportpandasaspdaccession_id_col="Protein IDs"# used as unique index and to directly fetch mw data from UniProtmw_col="Mass"# molecular weight column nameploidy=2# ploidy numbertotal_cellular_protein_concentration=200# cellular protein concentration used for calculation of total volumefilename=r"example_data\example_data.tsv"# example data from Perseusdf=pd.read_csv(filename,sep="\t")# selecting intensity columnsintensity_columns=df.columns[57:57+16]# select 16 columns starting from column 57th that contain sample intensityIf the data does not contain molecular weight information, it is required to fetch it from UniProt.fromproteomicRuler.rulerimportadd_mwdf=add_mw(df,accession_id_col)df=df[pd.notnull(df[mw_col])]df[mw_col]=df[mw_col].astype(float)The Ruler object can be created by passing theDataFrameobject and the required parameters.fromproteomicRuler.rulerimportRulerruler=Ruler(df,intensity_columns,mw_col,accession_id_col,ploidy,total_cellular_protein_concentration)#ruler.df.to_csv("output.txt",sep="\t",index=False)It is also possible to use the package through the command line interface.Usage:ruler[OPTIONS]Options:-i,--inputFILENAMEInputfilecontainingintensityofsamplesanduniprotaccessionids-o,--outputFILENAMEOutputfile-p,--ploidyINTEGERPloidyoftheorganism-t,--total-cellularFLOATTotalcellularproteinconcentration-m,--mw-columnTEXTMolecularweightcolumnname-a,--accession-id-colTEXTAccessionidcolumnname-c,--intensity-columnsTEXTIntensitycolumnslistdelimitedbycommas-g,--get-mwGetmolecularweightfromuniprot--helpShowthismessageandexit.
Package: proteomics-downstream-analysis
Table of ContentsPackage descriptionGetting StartedUsageContributingLicense(back to top)Package descriptionIntroducing Proteomics Downstream Analysis v0.1.0, a comprehensive Python package designed to simplify and streamline the process of downstream data analysis for proteomics research. This package offers a user-friendly and efficient way to handle, manipulate, process, and visualize large proteomics datasets, helping researchers gain valuable insights from their data more quickly and effectively.Key features of proteomics_downstream_analysis v0.1.0 include:Data import and preprocessing: Easily import and preprocess raw proteomics data from DIA-NN. Automatically handle missing values, normalization, and data transformation as needed.Statistical analysis: Perform essential statistical tests such as t-tests, ANOVA, and multiple testing correction methods to assess the significance of differentially expressed proteins.Enrichment analysis: Conduct functional enrichment analysis to identify over-represented functional categories, biological processes, or pathways in your protein sets, supporting popular databases like Gene Ontology and KEGG.Clustering and dimensionality reduction: Apply advanced unsupervised learning techniques to group similar proteins and uncover underlying biological patterns. Techniques include hierarchical clustering, k-means clustering, principal component analysis (PCA), and t-distributed stochastic neighbor embedding (t-SNE).Customizable data visualization: Create stunning and informative visualizations to better understand and communicate your results. Generate heatmaps, volcano plots, Venn diagrams, and more with full customization options.Integration with existing tools: Compatibility with popular Python libraries including NumPy, pandas, and matplotlib, allowing you to seamlessly integrate this package into your existing data analysis workflow.Proteomics Downstream Analysis v0.1.0 provides a solid foundation for your proteomics research needs.(back to top)Getting StartedProteomicsDownstreamAnalysis can be installed using:pip install proteomics-downstream-analysis(back to top)Usageimport proteomics_downstream_analysis as pda(back to top)ContributingContribution is much appreciated. Happy to get feedback and suggestions!Should you have a suggestion that could enhance this project, kindly fork the repository and create a pull request. You may also open an issue labeled as “improvement”.(back to top)LicenseDistributed under the MIT License. SeeMIT.txtfor more information.(back to top)
Package: proteovae
DocumentationproteovaeThis library implements a convenient set of modules for designing and implementing several different variational autoencoder frameworks. So far support is provided for the vanillaVAE,beta-VAE, and the here-presented guided VAE (GVAE).proteovaealso provides a few different model trainers to facilitate the training process, although you can also use standard PyTorch orLightningas you please.  This package was developed as a tool to explore genomics data (henceproteo[mics]-vae), for a much more comprehensive suite of VAE implementations I would point you in the direction ofpythae.News📢Version 0.0.1 now on PyPI! ❤️🇮🇹🧑‍🔬Quick AccessInstallationDefining Custom ArchitecturesModel TrainingTutorialsInstallationTo install the latest stable release of this library run the following usingpip$pipinstallproteovaeDefining Custom ArchitecturesIn addition to the models providedproteovae.models.basemodule you can also write your own encoder and decoder architectures for the VAE you're fitting.>>>fromproteovae.models.baseimportEncoder,Guide,Decoder>>>fromproteovae.modelsimportGuidedConfig,GuidedVAE>>>importtorch>>>fromtorchimportnn...>>>input_dim=64>>>latent_dim=10>>>guided_dim=1>>>n_classes=2# dummy...>>>config=GuidedConfig(...input_dim=input_dim,...latent_dim=latent_dim,...guided_dim=guided_dim...)...>>>#using proteovae.models objects>>>enc=Encoder(...input_dim=input_dim,...latent_dim=latent_dim,...hidden_dims=[32,16,]...)>>>dec=Decoder(...output_dim=input_dim,...latent_dim=latent_dim,...hidden_dims=[16,32,]...)...>>>gvae1=GuidedVAE(...model_config=config,...encoder=enc,...decoder=dec,...guide=Guide(dim_in=guided_dim,dim_out=n_classes))...>>>#or with generic torch objects>>>classCustomDecoder(nn.Module):...def__init__(self,**kwargs):...super().__init__(**kwargs)...self.fwd_block=nn.Sequential(...nn.Linear(latent_dim,2*latent_dim),...nn.Tanh(),...nn.Linear(2*latent_dim,input_dim),...)...defforward(self,x):...returnself.fwd_block(x)...>>>custom_dec=CustomDecoder()>>>gvae2=GuidedVAE(...model_config=config,...encoder=enc,...decoder=custom_dec,...guide=Guide(dim_in=guided_dim,dim_out=n_classes)Model TrainingTwo differentproteovae.trainersTrainers (BaseTrainerandScheduledTrainer) are provided to bundle up a lot of the annoying aspects of defining training loops in PyTorch. As shown below, their implementation is fairly straightfoward>>>fromproteovae.trainersimportScheduledTrainer>>>fromtorchimportoptim...>>>#define any proteovae.models objec and torch data loaders>>>model=# ...>>>train_loader=# ...>>>val_loader=# ......>>>#define optimizer and lr_scheduler>>>n_epochs=5>>>optimizer=optim.Adam(model.parameters(),...lr=1e-03)>>>scheduler=optim.lr_scheduler.LinearLR(optimizer,...start_factor=1.0,...end_factor=0.33,...total_iters=n_epochs*len(train_loader))...#trainer init>>>trainer=ScheduledTrainer(model,optimizer,scheduler)...>>>#train>>>trainer.train(train_loader,n_epochs,val_data=val_data)Tutorialsnonlinear_pca.ipynbmotivates a generic use case for the GVAE framework
Package: proteoxystis
Proteoxystis - Crystal solvent prediction for XRay CrystallographyUnder ConstructionGiven the DNA sequence, predicts a set of likely solvents for that proteinThings to replacegrep -ri word .will find thewordin all the filesfind . | grep wordwill find thewordin any filenamesretospect- changed to your github user nameproteoxystis- change to the name of your projectwobble- change to the internal package name you want to usefafa- change to whatever your commandline command should be if you are providing a scriptupdate the pyproject.py file to have your name and the right description.
Package: protest
python module by aarón montoya-moraga, first released on march 2017.
it is a part of “its-ok”, his graduate thesis at nyu itp.installationinstall with pip:pip install protestexamplesthese are some examples of protest.py being used for protesting against trees.special thanksallison parrish, andrew lazarow, justin peake, lauren mccarthy, sam lavigne, tigran paravyan, wipawe sirikolkarn, yuan gao, yuli cai, zoe bachmanlicensemit
Package: proteuscmd
Proteus Command Line ClientA simple command line client to modify DNS entries in Proteus.InstallationUsepipto installproteuscmd:❯ pip install proteuscmdConfigurationConfigure access credentials in~/.proteus.json:{"user":"api-user","password":"super.secret!","url":"https://proteus.example.com"}Additionally, you can specify a map of automatic replacements for domains.
This can be useful if, for example, all your domains also have an alternate domain with aDNAMErecord.{..."replace":{".ex.com":".example.com"}}Usage❯ proteuscmd
Usage: python -m proteuscmd [OPTIONS] COMMAND [ARGS]...

Options:
  --help  Show this message and exit.

Commands:
  dns  Get information about or update DNS entries.
  ip   Register IP addresses.Get information about a DNS record:❯ proteuscmd dns get lktest.uni-osnabrueck.deShell CompletionTheproteuscmdcommand line tool supports shell completion for several major shells:ForBash, add to~/.bashrc:eval "$(_PROTEUSCMD_COMPLETE=bash_source proteuscmd)"ForZSH, add to~/.zshrc:eval "$(_PROTEUSCMD_COMPLETE=zsh_source proteuscmd)"Forfish, add to~/.config/fish/completions/proteuscmd.fish:_PROTEUSCMD_COMPLETE=fish_source proteuscmd | source
Package: proteusisc
# ProteusISCProteusISC is a Linux JTAG controller abstraction library and driver framework. It is used for communicating to devices via JTAG using a JTAG controller.[![License (LGPL version 2.1)](https://img.shields.io/badge/license-GNU%20LGPL%20version%202.1-blue.svg?style=flat-square)](http://opensource.org/licenses/LGPL-2.1)
[![CircleCI](https://circleci.com/gh/diamondman/proteusisc.svg?style=shield)](https://circleci.com/gh/diamondman/proteusisc)
[![codecov](https://codecov.io/gh/diamondman/proteusisc/branch/master/graph/badge.svg)](https://codecov.io/gh/diamondman/proteusisc)
[![Downloads](https://img.shields.io/pypi/diamondman/proteusisc.svg)](https://pypi.python.org/pypi/proteusisc)
[![Codacy Badge](https://api.codacy.com/project/badge/Grade/00c07105d4e44e96935875533c673288)](https://www.codacy.com/app/jessy-diamondman/proteusisc?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=diamondman/proteusisc&amp;utm_campaign=Badge_Grade)
[![PyPI](https://img.shields.io/pypi/v/proteusisc.svg)](https://pypi.python.org/pypi/proteusisc/)
[![PyPI](https://img.shields.io/pypi/pyversions/proteusisc.svg)](https://pypi.python.org/pypi/proteusisc/)The main benefits of proteusisc are:
* Use any supported JTAG Controller to talk to any JTAG Device, regardless of manufacturer.
* Agressive optimizations to commands sent to the JTAG Controller.
* Easy to use library for creating a new tool to configure a device type.
* Works in ipython for interactive JTAG exploration/debugging.For more on the project, visithttp://proteusisc.org/post/welcome/To see hardware reverse engineering notes, visithttp://diamondman.github.io/Adapt/.For additional information on setting up supported jtag controllers, check the documentation link above.## Installation / Setup from sourcepip3 install .## Installation / Setup from pypipip3 install proteusisc## Testingpytest –cov-report term-missing –cov proteusisc -v## Installation while developingpip install . -U –no-deps
Package: proteuslib
ProteusLib is an open-source, integrated suite of predictive multi-scale models for design and optimization of water treatment processes and systems. Specifically, ProteusLib is a new library of water treatment-specific property, process unit, and network models that depend on the IDAES Platform, an open source, next generation process systems engineering platform developed at the National Energy Technology Laboratory with other partners. The ProteusLib project is funded by the NAWI  as a part of U.S. Department of Energy’s Energy-Water Desalination Hub. The goal of ProteusLib is to assist the hub and the broader water R&D community in assessing existing and emerging water treatment technologies by 1) providing predictive capabilities involving the design, optimization, and performance of water treatment systems that will lead to improved energy efficiency and lower cost, 2) advancing the state of the art for the design of water treatment components, systems and networks to be comparable with, or even surpass, that in the chemical industry, and 3) disseminating these tools for active use by water treatment researchers and engineers.
Package: protex
GoalProtex aims at providing a flexible, extensible and interfaced way to remove
TeX macros from a TeX/LaTeX document while keeping the mapping of position from
cleaned text to source. This should make it easier to apply different language
checkers to the plain text and convert the plain text position to source
positions.
When possible the resulting file should also be a reasonably readable text file
(no big blanks, no strange holes...).Non-goalThis project won't try to parse TeX in a complex way. The cleaning has to be
extensible, but nor recursive, neither Turing complete as TeX is itself.PrincipleA command prototype set is first built from the defaultcommands.json,
updated by the user~/.commands.json(if it exists) and then all thecommands.jsonfiles found in the file tree from root to the current
directory.A command prototype tell the parser how many arguments at maximum take the
command and how to use them. There are four sections incommands.jsonfiles.
The three below consist in a list of special prototype:print_name: the command take no argument and is replace by its name (ex:\phi,\sum)print_one: the command take one argument and print it unchangeddiscard: the command take up to 100 arguments and print nothing
The fourth section isotherand have a mapping as value. The
mapping is of the form{<command_name>: [<# max args>, <template>]}.
The template is a string where everything will be printed as is but:%0will be replace with the command name%1will be replaced with the first argument (and so on for%2,%3etc without limit)%%will be replaced with a raw%%followed by anything else will not be replacedWhen parsing the TeX source, the argument collection end as soon as one of
those conditions is fulfilled:the max number of arguments have been reachedthe next token is a blankthe next token is a "word" of more than one letter (a word a sequence of
contiguous everything that is neither whitespace nor a special thing in TeX
(comments, commands, curly brackets, square bracket), be carefull,
punctuation like "." is a valid one letter word that can be the last argument
of a command)the last argument was a non bracketed one letter "word"Those rules can seem a bit convoluted but if you have a valid TeX document and
valid command prototypes, the result should be what you expect.InstallationFrom source: in the folder of this README runpip install .in a terminal.
With pip directly: runpip install -U protexUsageSee the command line help by runningprotexorpython -m protex.NotesThe requirements.txt is only for development and test, not for normal usage.
There are no dependencies at all.