Saravanan666/pypi-org huggingface dataset:
Package: bi-objectiveClassification
#boRankingAlpha version with most useful functions implemented.Developed by Iago Augusto Carvalho, Pedro Augusto Mendes, Tiago Costa SoaresOverviewThe project implements a bi-objective lexicographic ranking approach. The classification is done based on two input files, one containing the results of each algorithm, and the other containing the execution times for each scenario.InstallationMake sure you have Python 3 installed. Then, you can install the package using the following command:import boRankingUsageAfter installing the package.from boRanking import biobjective_lexicographicFunction biobjective_lexicographic:from boRanking import biobjective_lexicographic#Case your files have a header:
has_header = True
matrix_ranking = biobjective_lexicographic('results.csv', 'time.csv', has_header)
'Replace 'results.csv' and 'time.csv' with your file names'#Case your files don't have a header:
matrix_ranking = biobjective_lexicographic('results.csv', 'time.csv')
'Replace 'results.csv' and 'time.csv' with your file names'
'You can define has_header as false, but not obligatory'LicenseThis project is licensed under the GNU General Public License v3.0 - see the LICENSE file for details.
Package: biobrary
BiobraryIntroductionBiobrary is a python library, which contain data and methods for biological computation.Requirementete3
pyqt5 is needed by ete3. you maybe need install it manually.Installusing pippip install biobrary --usermanally installgit clone https://github.com/benjaminfang/biobrary.gitcd biobrarymv biobrary PYTHONPATHwhere PYTHONPATH is python library searching path.Usageimport biobrary  
dir(biobrary)Data and MethodbiopaserFasta_parserclass for fasta file.Gff_parserclass for gff file.biocondonCODON_AApython dictionary of codon and amino acids.base_complementstart_codonstop_codonamino_acids_mwCircleNodeclass for phylogenic tree traverse and operations. And divide tree to circle node according
to phylogenic distance.
Package: biobricks
BioBricksBioBricks makes loading data from biological datasets easy.pipxinstallbiobricksinitializeTo get started configure biobricks with a path for bricks and a biobricks.ai token:biobricks configure
> Choose path to store bricks: <input a local path>
> Input a token from biobricks.ai/token: <this is your access token>Install and Use BricksTo install a brick the command line command:>biobricksinstalltox21You can then use the brick in python as below:importbiobricksasbbbb.assets('tox21')# get the paths for the 'tox21' brickTo list the bricks currently available visitstatus.biobricks.ai
Package: biobuild
Biobuild is a molecular building suite designed to facilitate the creation of large biomolecules such as glycans.
It allows for an easy molecule creation process in a jupyter-notebook environment. Biobuild offers direct integrations
toPubChem, and thePDBE component libraryas well as theCHARMM projectfor pre-defined component structures and linkage types.biobuildallows users to:build any larger molecular structure they likeimprove the conformation of an existing structureconvert data formatsvisualize the structures as they build themquickly obtain molecular structures for chemical compoundsbiobuildcannot:generate circular structures (users need to choose suitable templates with rings already present)imitate real-life chemical reaction mechanismsperform molecular dynamics or quantum chemistry computationsgenerate moleculesforthe user - the user needs to know what they want to build...Example - building a dendrimerLet's build a polyphenylene dendrimerimportbiobuildasbbbb.load_small_molecules()benzene=bb.molecule("benzene")# -----------------------------#     make the periphery# -----------------------------periphery=benzene.copy()# set up the linkage instructions# always shifting the carbon at which to attachlink=bb.linkage("C1","C1")forcarboninrange(1,6):link.atom1=f"C{carbon}"periphery.attach(benzene,link,at_residue=1)# -----------------------------#     assemble the molecule# -----------------------------mol=benzene.copy()link2=bb.linkage("C1","C4")# and attach the periphery to the coreforcarboninmol.get_atoms("C",by="element"):link2.atom1=carbonmol.attach(periphery,link2,at_residue=1,other_residue=2)# -----------------------------#   optimize the conformation# -----------------------------mol.optimize()mol.to_pdb("polyphenylene.pdb")Example - building a glycanBecause Biobuild has data on glycosyidic linkages from CHARMM, we can build glycan structures from scratch by referencing the linkages from CHARMM.importbiobuildasbb# load the sugar dataset from PDBEbb.load_sugars()# get the monosaccharides# (using their PDBE identifiers)nag=bb.molecule("NAG")# N-acetylglucosamine, a.k.a. GlcNAcbma=bb.molecule("BMA")# beta-mannoseman=bb.molecule("MAN")# alpha-mannose# start by connecting two NAGs together# 'beta 1->4' glycosydic linkage is pre-defined# in the CHARMM force field and can be used by its name '14bb' directlyglycan=bb.connect(nag,nag,"14bb")# add a beta-mannose to the last NAGglycan.attach(bma,"14bb")# add an alpha-mannose to the beta-mannose# using an 'alpha 1->3' linkage ('13ab' in CHARMM)glycan.attach(man,"13ab")# add another alpha-mannose# at the second-to-last residue (BMA)glycan.attach(man,"16ab",at_residue=-2)# add one final alpha-mannose (using shorter syntax)glycan=glycan%"16ab"+man# now visualise the structureglycan.show()# and save to a PDB fileglycan.to_pdb("my_glycan.pdb")
Package: bioc
bioc - Processing BioC, Brat, and PubTator with PythonBioC XML / JSON formatcan be used to
share text documents and annotations.Brat standoff formatis created by the brat annotation tool to store
annotations on disk in a standoff format. annotations are stored separately from the annotated document text, which is
never modified by the tool.PubTator formatis created by the PutTator Central system.biocexposes an API familiar to users of the standard librarymarshalandpicklemodules.Development ofbiochappens on GitHub:https://github.com/bionlplab/biocGetting startedInstallingbioc$pipinstallbiocBioCEncoding the BioC collection objectcollection:frombiocimportbiocxml# Serialize ``collection`` as a BioC formatted stream to ``fp``.withopen(filename,'w')asfp:biocxml.dump(collection,fp)Decoding the BioC XML file:frombiocimportbiocxml# Deserialize ``fp`` to a BioC collection object.withopen(filename,'r')asfp:collection=biocxml.load(fp)BratEncoding the Brat documentfrombiocimportbrat# Serialize ``doc`` as a brat formatted stream to ``text_fp`` and ``ann_fp``.withopen(annpath,'w')asann_fp,open(txtpath,'w')astext_fp:brat.dump(doc,text_fp,ann_fp)Decoding the Brat document:frombiocimportbrat# Deserialize two streams (text and ann) to a Brat document object.withopen(annpath)asann_fp,open(txtpath)astext_fp:doc=brat.load(text_fp,ann_fp)PubTatorEncoding the PubTator document objectdoc:frombiocimportpubtator# Serialize ``collection`` as a BioC formatted stream to ``fp``.withopen(filename,'w')asfp:pubtator.dump([doc],fp)Decoding the PubTator filefrombiocimportpubtator# Deserialize ``fp`` to a PubTator object.withopen(filename,'r')asfp:docs=pubtator.load(fp)DocumentationYou will find complete documentation at ourRead the Docs
site.ContributingYou can find information about contributing to bioc at ourContribution
page.ReferenceIf you use bioc in your research, please cite the following paper:Comeau DC, Doğan RI, Ciccarese P, Cohen KB, Krallinger M, Leitner F, Lu Z, Peng Y, Rinaldi F, Torii M,
Valencia V, Verspoor K, Wiegers TC, Wu CH, Wilbur WJ. BioC: a minimalist approach to interoperability
for biomedical text processing. Database (Oxford). 2013;2013:bat064. doi: 10.1093/database/bat064.
Print 2013. PMID: 24048470; PMCID: PMC3889917AcknowledgmentThis work is supported by the National Library of Medicine under Award No.
4R00LM013001.LicenseCopyright BioNLP Lab at Weill Cornell Medicine, 2023.Distributed under the terms of theMITlicense,
bioc is free and open source software.
Package: biochatter
BioChatterLicensePythonPackageBuild statusTestsCoverage coming soon.DockerDevelopmentContributionsDescriptionGenerative AI models have shown tremendous usefulness in increasing
accessibility and automation of a wide range of tasks. Yet, their application to
the biomedical domain is still limited, in part due to the lack of a common
framework for deploying, testing, and evaluating the diverse models and
auxiliary technologies that are needed.  This repository contains thebiochatterPython package, a generic backend library for the connection of
biomedical applications to conversational AI.  Described inthis
preprintand used inChatGSE, which is being developed athttps://github.com/biocypher/ChatGSE. More to come, so stay tuned!BioChatter is part of theBioCypherecosystem,
connecting natively to BioCypher knowledge graphs. The BioChatter paper is
being writtenhere.InstallationTo use the package, install it from PyPI, for instance using pip (pip install biochatter) or Poetry (poetry add biochatter).ExtrasThe package has some optional dependencies that can be installed using the
following extras (e.g.pip install biochatter[xinference]):xinference: support for querying open-source LLMs through Xorbits Inferencepodcast: support for podcast text-to-speech (for the free Google TTS; the
paid OpenAI TTS can be used without this extra)streamlit: support for streamlit UI functions (used in ChatGSE)UsageCheck out thedocumentationfor
examples, use cases, and more information. Many common functionalities covered
by BioChatter can be seen in use in theChatGSEcode base.More information about LLMsCheck outthis repositoryfor more info on computational biology usage of large language models.Developer notesIf you're on Apple Silicon, you may encounter issues with thegrpciodependency (grpclibrary, which is used inpymilvus). If so, try to install
the binary from source after removing the installed package from the virtual
environment fromhere:pipuninstallgrpcioexportGRPC_PYTHON_LDFLAGS=" -framework CoreFoundation"pipinstallgrpcio==1.53.0--no-binary:all:```# chat
Package: biocli
CLI tool for Computational BiologyPlease read before use!

Works with python version >= 3.9
For Linux users only
Works with `.txt` files only.
Install requirements via pip3.
Make the "compute" file executable using linux terminal typing `chmod +x compute` commandHow to useExamples:$./computebiocli-husage: compute biocli [-h] {count,pattern,translate}positional arguments:{count,pattern,translate}count                    Count feature to count the nucleotides and patterns in thegiven DNA or RNA sequence.pattern                  Pattern feature for finding given pattern in the given DNAor RNA sequence.translate                Translate feature to translate the given DNA sequence toRNA and vice versa.optional arguments:-h, --help                 show this help message and exit$./computebioclitranslatedna-to-rna"sample.txt"to_file=FalseUGCUCCGCCGAACCAUUCAUGCGGGAUACGACUUGGAUGACAUAGGAAAUUCAUAAUUAUCGUGUCUAAGUAAUUGCAUGCAGGCUGCAAUAACGUUGUUGGCCGAGCGUAAUACAAGAUUAGCCGCUGUUGAUGCUCAUUAGACGCGUUGGUAAAUUUGACGUUCUUAUGACCCCUACGUAUAACAGAAUAGCCUCUGGUGACUUUUCUGAGCACCGAUCUCGCAAUAUAUUAGCCACUAUAUUAUCUAAGCCGAGCCAAUCAUUGAUACACAUAGUAAUGUCAGGACGUCGAACCUAGAUUGUAUGACUCCGCUAAGGUAUUCCGAGAGACACUAGGAUACUAGAUAUAUUCCCAAAGUAAGGCGACGCCUAGUCUUUAGAGAGCGAGUAUGCCUUUGCCAAGUGUUGGAUGAGCCCGCCCCUUAAUAGGUGCUACGCUAGAGGCAAAGCAUGUGGGCGGUGGCCACACUUCAAUCAGGUGGCGAGUAGACGCUUCAGCCCGUUCGAUCUUAAGUAUCAGUAUAGGGACUCGAGUACAGUGUCCAAAUUACUGCGCUCGGUCCUAUGCUGACAAGGCGAACUCUGCAGAGAAUGGUCCGAAUUCACAUUCGGACAAUACGAUGUAGGACCGAACAAGCACAGUUUGAUUCGCCUCGGAAGACGGUGCAACUGAAACAGUAGAUCUCCUUAUCAAUGUAGGGCGAAGUACUGCCCGCGUGAGGGCACCAGCAUCCAGUCUCGUUGCUGUUCGUAUGGGGAUCAACGGCGGGUUGUUCUUAAGAACAUCAGGAUGAGUUAAUCGAGAGUACUGAACCGCUAUUCGACACCGCAGGUUGCGACACCAAAUUGCCUAAACAUCAACAGCCUCAAUUACCUGCUGUCCACUCGAGCUUGGGGUACAGUGUUAUCCUUCACUUGAACGACAAGAUAAUGAACAUUGUGGACUUGCGUAUAProject layout├── biocli├── biocli│   ├── count.py│   ├── pattern.py│   ├── translate.py│   ├── _errors.py│   ├── _helper.py│   ├── _sequence.py│   ├── __init__.py├── computeContains:DNA to RNA sequence translator
RNA to DNA sequence translator
Pattern matcher
Pattern counter
Nucleotide counter
Frequency counter

Sample files added.Built on top of DynaCLI by BST Labs.Check it out!
Package: biocma
Consensus Multiple Alignment format, using Biopython alignments.I/O support and relevant functionality for the Consensus Alignment Format (CMA).
This format represents protein sequence alignments. It is used by a few tools by
Dr. Andrew F. Neuwald, notablyCHAINandMAPGAPS.Biopython objects and conventions are used where possible.InstallationThis is an ordinary Python package. You can install it from source with the
setup.py script:python setup.py build
python setup.py installStable releases are uploaded to PyPI as well, so you can install BioFrills with
Python package managers:pip install biofrillsOr:easy_install biofrillsSome scripts that I find useful are in the scripts/ directory. By default these
are not installed, but you can include them by uncommenting the line in setup.py
that starts withscripts=glob…Alternatively, you can just copy those scripts into another directory in your$PATH.What can the CMA format do for me?Like the A2M and Stockholm formats, alignments are shown with insertions as
lowercase characters and deletions are dashesLike the A3M format, alignments are pairwise versus a profile (or “consensus”
sequence), which also dictates which sites are indels. By compressing the
insert columns, a large of alignment of many divergent (but related) sequences
can be shown without filling it will mostly gap characters, as Stockholm can.Like Stockholm, but unlike A2M and A3M, more than one alignment can be
contained in a single file.Typically, an ungapped consensus sequence will be included as the first
sequence.A FASTA-like header contains additional, optional fields for the number of
leading and trailing sites and NBCI taxonomy codesWho uses CMA?The CMA format appears to have been invented by Dr. Andrew Neuwald at the
University of Maryland, and is used in these programs:MAPGAPS:http://mapgaps.igs.umaryland.edu/CHAIN:http://chain.igs.umaryland.edu/Should I use CMA in my own work?Unless you’re working with MAPGAPS or CHAIN, no.
Package: biocode_fims
Biocode FIMSA Python client for accessing data from theBiocode FIMSdatabase.Free software: MIT licenseDocumentation:https://biocode-fims.readthedocs.io.Installationpipinstallbiocode_fimsBasic UsageReturning a list of allpublicProjects in the Biocode FIMS.>>>importbiocode_fims>>>all_projects=biocode_fims.list_projects()>>>print(all_projects){"Barcode of Wildlife Nigeria":10,"Amphibian Disease":26,"SI Barcoding CBOL":12,"Hawaii Dimensions":3,"University and Jepson Herbaria":22,"Barcode of Wildlife Nepal":23,"Barcode of Wildlife Kenya":8,"New York Botanical Garden":28,"Barcode of Wildlife Proficiency Testing":24,"Barcode of Wildlife Mexico":9,"Barcode of Wildlife South Africa":11,"Barcode of Wildlife Training":5}Return the first 4 datasets in the “SI Barcoding CBOL” project (project id: 12).>>>importbiocode_fims>>>all_sibn_datasets=biocode_fims.list_datasets(12)>>>print(all_sibn_datasets[:4])['Brazil_Ants_A','Brazil_Ants_B','Brazil_Ants_C','Brazil_Ants_D']Grab the contents of the dataset “DJBirds_P01”.>>>importbiocode_fims>>>contents=biocode_fims.dataset_contents(12,['DJBirds_P01'])>>>print(len(contents))83To do something useful with the dataset contents, it’s best of load them into a Pandas DataFrame.TODOGet testing implemented correctlyExpand to API endpoints behind OAuthCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.2.0 (2017-06-29)Changed dataset_contents function to filter out empty fields by defaultGot documentation running on RTD, and continuous integration running on TravisCI0.1.0 (2017-06-21)Initial release on PyPI.
Package: biocommons.example
biocommons.example Test PackageThis repo provides a template for biocommons Python packages.  Here's how to use it:Click theUse this templatebutton. Name the new repo like "biocommons.something".Clone your repo locally.In the repo, typemake rename. The new name will be chosen based on the repo name.Remove this header.Commit and push.InstallationTo install from pypi:pip install biocommons.exampleDeveloper SetupSetup like this:make devready
source venv/bin/activateCode reformatting:make reformatInstall pre-commit hook:# included in `make devready`, not necessary for new installations
pre-commit installTest:make test   # for current environment
make tox    # for Python 3.9 and Python 3.10Build:git tag 0.0.0
make buildTry it:$ python3 -m biocommons.example
Marvin says:
There's only one life-form as intelligent as me within thirty parsecs...
       
$ marvin-quote 
Marvin says:
You think you've got problems? What are you supposed to do if you...

$ ipython
>>> from biocommons.example import __version__, get_quote_from_marvin
>>> __version__
'0.1.dev8+gd5519a8.d20211123'
>>> get_quote()
"The first ten million years were the worst, ...FeaturesCode structure and featuresModern pyproject.toml with setuptoolsVersioning based on git tag (only)Easy development setupSupport for namespacesTesting with coverage using pytest; tests may be intests/, embedded in the package, and in doc stringsExamples for logging and package dataCommand-line with argument parsing with argparseDevOpsQuality tools: Code reformatting with black and isortGitHub Actions for testing and packaging
Package: bioconverters
BioConverters PackageThe bioconverters packages contains functions for converting PubMed and PMC style XML into BioC format.Getting StartedInstall with pippipinstallbioconvertersNow you are ready to start converting files. Assuming you already have a file containing PMC formatted XMLfrombioconvertersimportpmcxml2biocfordocinpmcxml2bioc('/path/to/pmc/xml/file.xml'):# do stuff with bioc docCustomizing HandlersYou can overload the parse functions that deal with specific tags but providing the handlers argument. In the example below we are writing a parser for an element which we are omitting from the final text content.frombioconverters.utilimportTextChunkfrombioconvertersimportpmcxml2biocdefignore_element(xml_element,custom_handlers):tail=(elem.tailor"").strip()return[TextChunk(tail,elem)]fordocinpmcxml2bioc('/path/to/pmc/xml/file.xml',tag_handlers={'table':ignore_element}):# do stuff with bioc docTrim SentencesYou can also choose to truncate sentences to a maximum length. This is off by default. To turn this option off use the flagfordocinpmcxml2bioc('/path/to/pmc/xml/file.xml',trim_sentences=True):# do stuff with bioc docAdd XML structure InformationTo keep track of approximately where in the XML heirarchy a passage was derived from use theall_xml_path_infonoption. Note that this will be default added for any table and figure elements regardless of the flagfordocinpmcxml2bioc('/path/to/pmc/xml/file.xml',all_xml_path_infon=True):# do stuff with bioc docThis will add an infon to each passage (where possible) which resembles the following<infonkey="xml_path">body/sec/p</infon>
Package: bio-corgi
InstallationThe software can be installed usingpippipinstallbio-corgiWarningDo not try justpip install corgibecause that is a different package.To install the latest version from the repository, you can use this command:pipinstallgit+https://github.com/rbturnbull/corgi.gitNoteSoon corgi will be able to be installed using conda.UsageTo make predictions, run thecorgicommand line tool:corgi--file<inputseqfile>This will create a directory with the predictions in a CSV file and in fasta format.For more information about the other options, see the help with:corgi--helpFor help on training a model with corgi, run:corgi-train--helpCreditsRobert Turnbull <robert.turnbull@unimelb.edu.au>Created using torchapp (https://github.com/rbturnbull/torchapp)
Package: bio-curve-fit
bio-curve-fitA Python package for fitting common dose-response and standard curve models. Designed to follow thescikit-learnapi.QuickstartInstallationpipinstallbio-curve-fitWe recommend using pythonvirtual environmentsto manage your python packages in an isolated environment. Example:python-mvenvvenvnamesourcevenvname/bin/activateExample usage:frombio_curve_fit.logisticimportFourPLLogistic# Instantiate modelmodel=FourPLLogistic()# create some example datastandard_concentrations=[1,2,3,4,5]standard_responses=[0.5,0.55,0.9,1.25,1.55]# fit the modelmodel.fit(standard_concentrations,standard_responses,)# interpolate the response for new concentrationsmodel.predict([1.5,2.5])# interpolate the concentration for new responsesmodel.predict_inverse([0.1,1.0])Calculate and plot the curve and limits of detection:plot_standard_curve(standard_concentrations,standard_responses,model,show_plot=True)ExamplesSee theexample notebookfor more detailed usage.ContributingContributions are welcome! We built this package to be useful for our own work, but we know there is more to add.
Please seeCONTRIBUTING.mdfor more information.
Package: biocutils
Utilities for BiocPyMotivationThis repository contains a variety of simple utilities for theBiocPyproject,
mostly convenient aspects of R that aren't provided by base Python.
The aim is to simplify development of higher-level packages likescranpyandsinglerthat would otherwise have to implement these methods individually.Available utilitiesmatchimportbiocutilsbiocutils.match(["A","C","E"],["A","B","C","D","E"])## [0, 2, 4]factorimportbiocutilsbiocutils.factor(["A","B","B","A","C","D","C","D"])## (['A', 'B', 'C', 'D'], [0, 1, 1, 0, 2, 3, 2, 3])intersectimportbiocutilsbiocutils.intersect(["A","B","C","D"],["D","A","E"])## ['A', 'D']unionimportbiocutilsbiocutils.union(["A","B","C","D"],["D","A","E"])## ['A', 'B', 'C', 'D', 'E']subsetimportbiocutilsbiocutils.subset(["A","B","C","D","E"],[0,2,4])## ['A', 'C', 'E']importnumpyasnpy=np.array([10,20,30,40,50])biocutils.subset(y,[0,2,4])## array([10, 30, 50])is_list_of_typeChecks if all elements of a list or tuple are of the same type.importbiocutilsimportnumpyasnpx=[np.random.rand(3),np.random.rand(3,2)]biocutils.is_list_of_type(x,np.ndarray)## True
Package: biocwl-dash
biocwl-dashA Dash frontend for viewing the outputs of the biocwl precision oncology pipeline. Reports are interactive, and printable.UsageThis dash app is meant to be embedded in a flask app. Seetest/test_main.pyfor an example implementation. The import method to use isbiocwl_dash.app.init_app(server, prefix, report_service_factory), where:server is a flask appprefix is the URL prefix to prepend to all routesreport_service_factory is an implementation ofbiocwl_dash.report_service.ReportServiceContributingSetup your venv with:python3-mvenvvenvsourcevenv/bin/activate
pipinstall-e.
pipinstallsetuptoolswheeltwine
brewinstallpopplerAnd rerun the final install whenever you add dependencies to setup.py.Then, for development, run with:PYTHONPATH=$PWD:$PYTHONPATHpythontest/test_main.pyDeployment / PushingUpdate your package withpython3setup.pysdistbdist_wheel
twineuploaddist/*
rm-rfdistTo make sure your dependencies are in order and that your package installs well, try doing a Docker build with:dockerbuild-tbiocwldash.&&dockerrun-p5000:5000biocwldash