Saravanan666/pypi-org huggingface dataset:
Package: geneagrapher-core
geneagrapher-coreOverviewGeneagrapher is a tool for extracting information from theMathematics Genealogy Projectto
form a math family tree, where connections are between advisors and
their students.This package contains the core data-grabbing and manipulation
functions needed to build a math family tree. The functionality here
is low level and intended to support the development of other
tools. If you just want to build a geneagraph, take a look atGeneagrapher. If you
want to get mathematician records and use them in code, then this
project may be useful to you.DocumentationDocumentation about how to call into this package's functions can be
found athttp://geneagrapher-core.readthedocs.io/.DevelopmentDependencies in this package are managed byPoetry. Thus, your Python environment
will need Poetry installed. Install all dependencies with:$poetryinstallSeveral development commands are runnable withmake:make fmt(alsomake blackandmake format) formats code using
blackmake format-checkruns black and reports if the code passes
formatting checks without making changesmake lint(alsomake flake8andmake flake) does lintingmake mypy(alsomake types) checks the code for typing violationsmake testruns automated testsmake checkdoes code formatting (checking, not modifying),
linting, type checking, and testing in one command; if this command
does not pass, CI will not passReleasing New VersionsIncrease the version in pyproject.toml (e.g.,ed80c2c).Add an entry for the new version in CHANGELOG.md (e.g.,bf2931a).Push changes.Tag the new version with message "Release VERSION".$gittag-svVERSIONCOMMIT_SHAPush the tag.$gitpushoriginvVERSIONBuild the distribution.$poetrybuildPublish release to Test PyPI (this assumes that Poetry has been
configured with the Test PyPI URL).$poetrypublish-rtestpypiPublish release to PyPI.$poetrypublishCreatenew
release.
Package: genealloy
[![Build Status](https://github.com/Edinburgh-Genome-Foundry/genealloy/actions/workflows/build.yml/badge.svg)](https://github.com/Edinburgh-Genome-Foundry/genealloy/actions/workflows/build.yml)[![CoverageStatus](https://coveralls.io/repos/github/Edinburgh-Genome-Foundry/GeneAlloy/badge.svg?branch=master)](https://coveralls.io/github/Edinburgh-Genome-Foundry/GeneAlloy?branch=master)<p align=”center”>
<img alt=”GeneAlloy logo” title=”GeneAlloy” src=”https://raw.githubusercontent.com/Edinburgh-Genome-Foundry/GeneAlloy/master/logo/genealloy.png” width=”150”>
</p>Genealloyhelps designingoverlappingsequences.It takes two amino acid coding nucleotide sequences and a codon conversion table of allowed triplet -> triplet transitions, and determines whether one sequence can be inserted into the other one. Note that the package isunder development.Overlapping sequencesare nucleotide sequences that encode different amino acid sequences on the same DNA or RNA region. These sequences are either on the complementary strands (in any frame), or on the same strand as frameshift sequences. This phenomenon is made possible by the redundancy of the genetic code (codon degeneracy).In the metallurgic terminology used at the genome foundries, the host sequence (into which the shorter sequence is inserted) is called thematrixorsolvent,and the shorter guest (or parasite) is called thesolute;and a combination sequence is called agenealloy.Install`bash pip install genealloy `Usage`python import genealloy as ga swaptable = ga.generate_swaptable(ga.codon_to_aa, ga.aa_to_codon_extended) host = 'TCGTCGTACCAGCCGCAGAGGAGAGCTACTTTT' parasite =  'GTACCCGCTGCG'  # frameshift 2 ga.make_genealloy(host, parasite, swaptable) `Find partial overlaps:`python ga.find_partial_overlaps(host, parasite, swaptable) `VersionThe GeneAlloy project uses the [semantic versioning](https://semver.org) scheme. The package isunder development.License = MITGenealloy is [free software](https://www.gnu.org/philosophy/free-sw.en.html), which means the users have the freedom to run, copy, distribute, study, change and improve the software.Genealloy was written at the [Edinburgh Genome Foundry](https://edinburgh-genome-foundry.github.io/) by [Peter Vegh](https://github.com/veghp) and is released under the MIT license.
Package: geneblocks
GeneBlocks is a Python library for comparing DNA sequences. It can be used to:Find common blocks in a group of DNA sequences, to factorize them (e.g. only analyze or synthetize each common block once).Highlight differences between sequences (insertions, deletions, mutations).Transfer Genbank features from one record to another sharing similar subsequences.At the Edinburgh Genome Foundry, we use GeneBlocks to optimize sequence assembly, explore sets of non-annotated sequences, or visualize the differences
between different versions of a sequence, and re-annotate records coming from third parties such as DNA manufacturers.InfosPIP installation:pipinstallgeneblocksGithub Page:https://github.com/Edinburgh-Genome-Foundry/geneblocksLive demos:Find common sequence blocksPlot sequence diffsTransfer Genbank features between recordsLicense:MIT, Copyright Edinburgh Genome FoundryMore biology softwareGeneblocks is part of theEGF Codonssynthetic biology software suite for DNA design, manufacturing and validation.
Package: genecoder
RequirementsQt4Qt4 (Mac OS X)Install Qt4 via Homebrew is recommended. InstallHomebrewis as follows:$ ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"Install Qt4 is as follows:$ brew install qtQt4 (Ubuntu)$ sudo apt-get install libqt4-devHow to installThe genecoder can be installed viapip.$ pip install genecoder
$ pyside_postinstall.py -installUsage examplesCalculate RC distance:$ genecoder distance --coder n3_1 --coder n3_2 -gf4 ATGC --seq label1:ATGCATGCATGC --output [result]
$ genecoder --all --gf4all --input [FASTA]Survival analysis:$ genecoder stat --graph --coder n3_1 --outdir [result_dir] --input [tp53 database file]The results are stored inresult_dirfolder.Generate FASTA file from csv database:$ genecoder csv2fasta <idx_name> <idx_seq> [<length>] [--input=<csv>] [--output=<output>]Use GUI:$ genecoder guiShow help:$ genecoder -hShow support coders:$ genecoder listTP53 database file formatTP53 database is a CSV(Comma-Separated Values) format file.
Columns should be the followings:mutation_idseq_categoryregion_nameseq_naRFS(months)RFS(event)OS(months)OS(event)How to developDevelopers should usepyenvandpyenv-virtualenv.Mac OS X users can be installed via Homebrew:$ brew install pyenv-virtualenvHow to construct an environment:$ git clone https://github.com/kerug/genecoder.git
$ cd genecoder

$ pyenv install 2.7.5
$ pyenv install 3.4.1
$ pyenv virtualenv 2.7.5 genecoder-2.7.5
$ pyenv virtualenv 3.4.1 genecoder-3.4.1
$ pyenv local genecoder-2.7.5 genecoder-3.4.1

$ pip install -r test-requirements.txt
$ pip3 install -r test-requirements.txtTests for Python 2 & 3:$ toxAlternatively,$ python setup.py testSometimes, the following commands are needed:$ pyside_postinstall.py -install
$ pyenv rehashQt creator’s user-interface (*.ui) can be converted to python code as follows:$ pyside-uic -o mainwindow.py mainwindow.uiReferencesSato Keiko, Toshihide Hara, and Masanori Ohya. “The code structure of the p53 DNA-binding domain
and the prognosis of breast cancer patients.” Bioinformatics 29.22 (2013): 2822-2825. [Link]http://theory.cs.uvic.ca/gen/poly.htmlChanges1.1.1add auto ext recognition1.1.0add –compress option1.0.5change results-header of distance mode1.0.4fix csv2fasta mode1.0.3fix csv2fasta mode1.0.2update support coders1.0.1fix list mode1.0.0first version
Package: gene-connector-cli
Gene Connector (gcon)Genbank currently stands as one of the most significant global repositories of genetic information. Nevertheless, it is not always easy to find the information we need in the format we need. Gene Connector (gcon) is a command line interface (CLI) tool that aims to facilitate the metadata extraction from nucleotide records from Entrez Genbank API's. It is a tool that can be used by researchers, students and anyone interested in genetic associated metadata information.Seeproject source codefor details.Seedocumentationfor details.Installation ⚙️Recommended installation is usingpip. However alternative installations are also possible. Seeinstallation guidefor details.Usage 👨🏽‍💻Gene Connector is a command line interface (CLI) tool, them main command beinggcon, available after installation. Seeusage guidefor details.Project Architecture and Structure 🏛️Seeproject structurefor details.Data Modelling 🏗️Seedata modellingfor details.
Package: genedataset
genedatasetis a package to store and access gene expression
datasets and gene definitions. It consists of two main classes, geneset
and dataset.genesetgeneset stores gene information combined from both Ensembl and
NCBI/Entrez (mouse and human only), so that you can query it:$ gs = geneset.Geneset().subset(queryStrings='ccr3')
$ print gs.geneIds()
 ['ENSG00000183625', 'ENSMUSG00000035448']
$ gs.dataframe()
 | EnsemblId          | Species     | EntrezId | GeneSymbol | Synonyms                     | Description                      | MedianTranscriptLength | Orthologue              | ExonLength |
 |--------------------|-------------|----------|------------|------------------------------|----------------------------------|------------------------|-------------------------|------------|
 | ENSG00000183625    | HomoSapiens | 1232     | CCR3       | CC-CKR-3|CD193|CKR3|CMKBR3   | chemokine (C-C motif),receptor 3 | 1242.5                 | ENSMUSG00000035448:Ccr3 | 3568.0     |
 | ENSMUSG00000035448 | MusMusculus | 12771    | Ccr3       | CC-CKR3|CKR3|Cmkbr1l2|Cmkbr3 | chemokine (C-C motif),receptor 3 | 3273                   | ENSG00000183625:CCR3    | 3273.0     |datasetdataset can store gene expression data so that it can be queried. The
stored data consists of expression values (microarray and rna-seq) and
sample data packaged into HDF5 format.$ ds = dataset.Dataset("genedataset/data/testdataset.h5")
$ ds
 <Dataset name:testdata species:MusMusculus, platform_type:microarray>
$ ds.expressionMatrix()
 | probeId | s01  | s02  | s03  | s04  |
 |---------|------|------|------|------|
 | probe1  | 3.45 | 4.65 | 2.65 | 8.23 |
 | probe2  | 5.54 | 0.00 | 1.43 | 6.43 |
 | probe3  | 0.00 | 0.00 | 4.34 | 5.44 |
$ ds.sampleTable()
 | sampleId | celltype | tissue |
 |----------|----------|--------|
 | s01      | B1       | BM     |
 | s02      | B1       | BM     |
 | s03      | B2       | BM     |
 | s04      | B2       | BM     |ContactJarny Choie-mail:jarny.choi@gmail.comChangesv0.1.x - Initial release with minor adjustments to test pypi and github upload/download.v0.6.2 - Added a new column ‘ExonLength’ to the data.LicenseMIT License
Package: genedoku
Solve sudokus of any size using genetic algorithms with an easy approachBasic usagefromgenedoku.EvolutionimportEvolutionfromgenedoku.SudokuChromosomeimportSudokuChromosomee=Evolution(problem,SudokuChromosome,50,20000)r=e.start()Where problem contains an array of NxN representing the sudoku and using
0 in the empty spaces.Testpythontests/test_genedoku.py[options]<tests/example.txtWhere example.txt it’s an input file containing the matrix in the
following format:Each row it’s separated by ‘’, each element in row per ‘ ‘ and the final
line should be blank. Empty spaces are 0
Package: genedom
GeneDom is a python library for managing the domestication of genetic parts so that they will comply to a genetic assembly standard. It puts together asequence optimizer, genetic standards data, and a reporting system, to automate the domestication of large batches in an easy and human-friendly way.InfosPIP installation:pipinstallgenedomGithub Pagehttps://github.com/Edinburgh-Genome-Foundry/genedomLicense:MIT, Copyright Edinburgh Genome FoundryMore biology softwareGenedom is part of theEGF Codonssynthetic biology software suite for DNA design, manufacturing and validation.
Package: genefeast
GeneFEASTGeneFEAST, implemented in Python, is a gene-centric functional enrichment analysis summarisation and visualisation tool that can be applied to large functional enrichment analysis (FEA) results arising from upstream FEA pipelines. It produces a systematic, navigable HTML report, making it easy to identify sets of genes putatively driving multiple enrichments and to explore gene-level quantitative data first used to identify input genes. Further, GeneFEAST can compare FEA results from multiple studies, making it possible, for example, to highlight patterns of gene expression amongst genes commonly differentially expressed in two sets of conditions, and giving rise to shared enrichments under those conditions. GeneFEAST offers a novel, effective way to address the complexities of linking up many overlapping FEA results to their underlying genes and data, advancing gene-centric hypotheses, and providing pivotal information for downstream validation experiments.Please see theUser Guidefor installation and usage instructions.CitationIf you use GeneFEAST in your research, please cite the paper:Taylor, A., Macaulay, V.M., Maurya, A.K., Miossec, M.J., Buffa, F.M. GeneFEAST: the pivotal, gene-centric step in functional enrichment
analysis interpretation.arXiv:2309.00061If you use an upset plot generated by GeneFEAST, please also cite:Lex, A., Gehlenborg, N., Strobelt, H., Vuillemot, R., Pfister, R. UpSet: Visualization of Intersecting Sets. IEEE Transactions on Visualization and Computer Graphics (InfoVis ‘14), vol. 20, no. 12, pp. 1983–1992, 2014. doi.org/10.1109/TVCG.2014.2346248If you use a GO hierarchy image generated by GeneFEAST, please also cite:Klopfenstein, D.V., Zhang, L., Pedersen, B.S. et al. GOATOOLS: A Python library for Gene Ontology analyses. Sci Rep 8, 10872 (2018).https://doi.org/10.1038/s41598-018-28948-z
Package: gene-fetchr
fetcherLibrary to search and retrieve genomes, genes, vectors and other genomic data from public data sources.
Currently, Genbank is the only supported data source. Scrapers for Addgene are planned for future releases.A list of all genes can be extracted from a genome sequence annotation feature.
Using the ASN.1 file format, more detailed information (i.e: description, summary) than what thegbfile format
offers can be extracted. In future releases, data such as gene ontology can be extracted.Generated data is flat and unprocessed and can be used to convert to other data formats, has applications for
computational biology, or be fed to ML algorithms.
Package: gen-efi-app
Create EFI applicationgen_efi_appis tool for creating EFI project skeleton.Developed inpythoncode.The README is used to introduce the modules and provide instructions on
how to install the modules, any machine dependencies it may have and any
other information that should be provided before the modules are installed.Table of ContentsInstallationInstall using pipInstall using buildInstall using py setupInstall using dockerDependenciesTool structureDocsContributingCopyright and LicenceInstallationUsed next development environmentCurrently there are three ways to install packageInstall process based on using pip mechanismInstall process based on build mechanismInstall process based on setup.py mechanismInstall process based on docker mechanismInstall using pipgen_efi_appis located atpypi.org.You can install by using pip# python3pip3installgen_efi_appInstall using buildNavigate to releasepagedownload and extract release archive.To installgen_efi_apptype the followingtarxvzfgen_efi_app-x.y.z.tar.gzcdgen_efi_app-x.y.z/# python3wgethttps://bootstrap.pypa.io/get-pip.py
python3get-pip.pypython3-mpipinstall--upgradesetuptools
python3-mpipinstall--upgradepip
python3-mpipinstall--upgradebuild
pip3install-rrequirements.txt
python3-mbuild--no-isolation--wheel
pip3install./dist/gen_efi_app-*-py3-none-any.whl
rm-fget-pip.py
chmod755/usr/local/lib/python3.9/dist-packages/usr/local/bin/gen_efi_app_run.py
ln-s/usr/local/lib/python3.9/dist-packages/usr/local/bin/gen_efi_app_run.py/usr/local/bin/gen_efi_app_run.pyInstall using py setupNavigate torelease pagedownload and extract release archive.To installgen_efi_applocate and run setup.py with argumentstarxvzfgen_efi_app-x.y.z.tar.gzcdgen_efi_app-x.y.z# python3pip3install-rrequirements.txt
python3setup.pyinstall_lib
python3setup.pyinstall_egg_infoInstall using dockerYou can use Dockerfile to create image/container.Dependenciesgen_efi_apprequires next modules and librariesats-utilities - Python App/Tool/Script UtilitiesTool structuregen_efi_appis based on OOPGenerator structuregen_efi_app/
├──conf/
│├──gen_efi_app.cfg
│├──gen_efi_app_util.cfg
│├──project.yaml
│└──template/
│├──cflags.template
│├──ldflags.template
│├──main.template
│├──makefile.template
│├──objects.template
│└──ocflags.template
├──__init__.py
├──log/
│└──gen_efi_app.log
├──pro/
│├──__init__.py
│├──read_template.py
│└──write_template.py
└──run/└──gen_efi_app_run.pyDocsMore documentation and info atgen_efi_app.readthedocs.iowww.python.orgContributingContributing to gen_efi_appCopyright and LicenceCopyright (C) 2020 - 2024 - 2024 byelectux.github.io/gen_efi_appgen_efi_appis free software; you can redistribute it and/or modify
it under the same terms as Python itself, either Python version 3.x or,
at your option, any later version of Python 3 you may have available.Lets help and support PSF.
Package: geneflow3
# GeneFlowVersion: 3.0.0-alpha.1GeneFlow (GF) is a light-weight, extendable workflow engine for scientific computing.## RequirementsAt a minimum, GeneFlow requires a Linux environment with Python 3. The Python pip installer for GeneFlow handles all python dependencies.## Quick StartGeneral installation instructions can be found in the [Additional Documentation](#additional-documentation).### Install GeneFlow in a Python Virtual EnvironmentIf you need to install GeneFlow, it is recommended to use a Python3 virtual environment. However, if you have root access and want to install GeneFlow system-wide, you may skip the virtual environment step.Create and activate a Python3 virtual environment:` python3-mvenv gfpy source gfpy/bin/activate `Clone the GeneFlow source repository:` git clonehttps://github.com/jhphan/geneflow`Install GeneFlow:` pip3 install ./geneflow `Test the installation by running the GeneFlow CLI:` geneflow--help`## Additional DocumentationAdditional documentation can be found [here](https://geneflow.gitlab.io/). Alternatively, it can be found in the docs folder of this source repository (or by following this link: [Additional Documentation](docs/index.rst)).## LicenseThe repository utilizes code licensed under the terms of the Apache Software
License and therefore is licensed under ASL v2 or later.This source code in this repository is free: you can redistribute it and/or modify it under
the terms of the Apache Software License version 2, or (at your option) any
later version.This source code in this repository 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 Apache Software License for more details.You should have received a copy of the Apache Software License along with this
program. If not, seehttp://www.apache.org/licenses/LICENSE-2.0.htmlThe source code forked from other open source projects will inherit its license.
Package: genegist
👓 GeneGistResearchers often face challenges in deciphering the complex interactions and functions of systems of genes. GeneGist addresses this problem by providing detailed summaries and insights into gene behaviors, interactions, and their roles in biological processes.This complexity arises from the vast array of gene interactions, regulatory mechanisms, and the multifaceted roles genes play in biological processes. GeneGist generates in-depth summaries and insights into gene behaviors and interactions, as well as their roles in biological pathways and systems.GeneGist first scrapes and analyzes academic articles. GeneGist leverages the most advanced Large Language Models (LLMs) available to analyze this information. Using this distilled knowledge it produces biological process summaries.GeneGist can also create Gene Reference Into Function (GeneRIFs) directly from scientific literature. GeneRIFs are concise sentence-like annotations, typically written by a human, that describe the function of a gene. GeneGist can construct GeneRIFs using generative AI technology based on LLMs.LicenseApache LicenseInstallationTo install GeneGist, ensure you have Python 3.10 or higher. It can be installed via pip:pipinstallgenegistDevelopmentInstalling PoetryPoetry is required to handle dependencies and package management. To install Poetry, run:curl-sSLhttps://raw.githubusercontent.com/python-poetry/poetry/master/get-poetry.py|python-Setting Up genegistClone the repository:gitclone[repositoryURL]cdgenegistInstall the dependencies using Poetry:poetryinstallUsageTo use genegist, run the following command:poetryrungenegist[options]Options-g GENE,--gene GENE:
Look up GeneRIFs for a given gene.-s GENESET,--geneset GENESET:
Look up GeneRIFs for a given gene set.-f GENESET_FILE,--geneset-file GENESET_FILE:
Look up GeneRIFs for a file containing a list of genes.-p PROCESS,--process PROCESS:
Find a biological process for the inputted gene set.-d CREATE_DRY_RUN,--create-dry-run CREATE_DRY_RUN:
Don't actually run the biological process finder, but save the gene summaries to a file.-a,--abstracts:
Also look up abstracts.-r LOAD_DRY_RUN,--load-dry-run LOAD_DRY_RUN:
Load the gene summaries from a file instead of running the LLM on them explicitly.--llm {gpt-3.5-turbo-1106,gpt-4-1106-preview}:
Specify the LLM to use.-m ARTICLE,--article ARTICLE:
Get the summary for a given PMID.-t,--tasks:
Run a given custom task. Currently only E3 ligase analysis is supported.-y,--synthetic-generifs:
Create synthetic generifs and save them to a tab-delimited file.-i,--build-index:
Build an embedding index for all the generifs.DevelopmentRunning TestsTo run tests, use:poetryrunpytest
Package: geneimpacts
Given multiple snpEff or VEP or BCFTools consequence annotations for a single variant, get an orderable python object for each annotation.This is to provide a consistent interface to
different variant annotations such as fromsnpEff ANN fieldand theVEP CSQ field.
and theBCFTools consequence fieldThis will be used ingeminibut should also be of
general utility.DesignThere is an effect base-class and then a sub-class forsnpEff, one forVEP, and one forBCFTEffectobjects are orderable (via __le__ ) and should have an __eq__ method so that we can usefunctools.total_orderingto provide the other comparison operators.Given 2 effects objects,aandb:a < b == Trueiff theseverityofbis greater thana.We will have a classmethod: `Effect.top_severity([eff1, ... effn]) that will return the single highest serverity if that exists or
a list of the ties for highestRules for severity:Given 2 annotations,aandbais more severe thanbif:bis a pseudogene andais notais coding andbis notahas higher severity thanb( see below)polyphen, then sift??? transcript length? (we dont have access to this).severitySeverity is based on theimpacts from VEPand theimpacts from snpEff. We reduce from the 4 categories HIGH, MEDIUM, LOW, MODIFIER to 3 by renaming MEDIUM to MED and renaming MODIFIER to LOW.