Saravanan666/pypi-org huggingface dataset:
Package: plasclass
PlasClassThis module allows for easy classification of sequences as either plasmid or chromosomal.
For example, it can be used to classify the contigs in a (metagenomic) assembly.Installationplasclassis written in Python3 and requires NumPy and scikit-learn and their dependencies. These will be installed by the setup.py script.We recommend using a virtual environment. For example, in Linux, before running setup.py:python -m venv classification-env
source classification-env/bin/activateIn Windows:pip install virtualenv
virtualenv classification-env
classification-env\Scripts\activateTo install, download and run setup.py:git clone https://github.com/Shamir-Lab/PlasClass.git
cd PlasClass
python setup.py installIt is possible to install as a user without root permissions:python setup.py install --userAfter installing, run the tests:python test/test.pyUsageThe scriptclassify_fasta.pycan be used to classify the sequences in a fasta file:python classify_fasta.py -f <fasta file> [-o <output file> default: <fasta file>.probs.out] [-p <num processes> default: 8]The command line options for this script are:-f/--fasta: The fasta file to be classified-o/--outfile: The name of the output file. If not specified, <input filename>.probs.out-p/--num_processes: The number of processes to use. Default=8The output file is a tab separated file with each line containing a sequence header and the corresponding score. The sequences are in the same order as in the input fasta file.The classifier can also be imported and used directly in your own python code. For example, once theplasclassmodule has been installed you can use the following lines in your own code:from plasclass import plasclass
my_classifier = plasclass()
my_classifier.classify(seqs)Theplasclass()constructor takes optional parameters:n_procs- number of processes to use for classification. Default=1.scales- array of the scales for the sequence lengths. Default=[1000,10000,100000,500000]ks- array of the k-mer lengths. Default=[3,4,5,6,7]The sequence(s) to classify,seqs, can be either a single string or a list of strings. The strings must be uppercase.The functionplasclass.classify(seqs)returns a list of plasmid scores, one per input sequence, in the same order as the input.Training new modelsThe scripttrain.pycan be used to train new models:python train.py -p <plasmid file> -c <chromosome file> -o <output directory> [-n <num processes> default: 16] [-k <kmer lengths> default: 3,4,5,6,7] [-l <sequence lengths> default: 1000,10000,100000,500000]The command line options for this script are:-p/--plasmid: The fasta file of the plasmid references.-c/--chromosome: The fasta file of the chromosome references.-n/--num_processes: Number of processes to use.-o/--outdir: The path of the output directory. Default=bin.-k/--kmers: Comma separated list of the k-mer sizes to use. Default=3,4,5,6,7.-l/--lengths: Comma separated list of the sequence lengths to use. Default=1000,10000,100000,500000.The models should be put into thedatadirectory.Note that if k-mer and sequence lengths other than the default are used, then these must be specified when calling theplasclass()constructor.
Package: plasIDome
PlasIDomeA tool to detect plasmids and contamination in bacterial and archaeal genome assembliesIntroductionIn bacterial genome assembly, it is important to account for all of the contigs. PlasIDome finds all contigs in an assembly file that are less than a specified length (default: 200,000bp) and uses sequences homology to categorize each as chromosomal, plasmid, or contamination. With this tool a key step in assessing assembly quality has been automated and can be integrated into existing workflows.Getting StartedRequirementspython 3.7+blast+ 2.10.1+bioseqInstallationPlasIDome is available on PYPI and can be installed using pippip install plasIDomeUsageAs input, PlasIDome takes a genome assembly file in fasta format (.fasta, .fa, .fna).Example:plasidome -b path/to/blastn -f genome.fastaExamine contigs up to 50,000 bp in length:plasidome -b path/to/blastn -f genome.fasta -l 50000Extensive Usage:plasidome -b path/to/blastn -f genome.fasta -p path/to/output -o output_nameOutput FilesPlasIDome generates three outputs:report.tsvalignment_results.tsvdirectory of contigsThe report.tsv file contains a summary of the alignment results in table format. From left to right, the table includes the contig name, its classification, and its contamination status followed by the number of matches that were to chromosomal, plasmid, undetermined, or human sequences in the database.A file called alignment_results.tsv is created that contains the raw, uninterpreted alignment results in table format. From left to right, the table includes the contig name, subject name, subject taxonomic ID, the percent sequence identity, query coverage, qcovhsp, alignment length, and e-value. The raw data allows the investigator to parse the alignment results manually. The alignment results written to this file are limited to homology matches where the subject and query shared at least 95% sequence identity and the subject covered at least 95% of the length of the length of the query sequence.FASTA files with each contig sequence are saved to a subdirectory called single_contigs so the user can re-align any sequence without having to find and isolate the contig themselves.At this time, PlasIDome is not able to determine if a plasmid is complete or if multiple contigs are fragments of the same plasmid. PlasIDome also does not comment on the taxonomic identification of the species. If the user wants to see the taxonomic makeup of the sample, it is best to review the raw alignment results in the alignment_results.tsv file.
Package: plasmasaver
PlasmaSaverA CLI Tool to Manage KDE Plasma Settings/Configurations.FeaturesSave Profile: Save existing plasma config/settings.Import Profile: Import existing plasma config/settings from .plsv file.Export Profile: Export and share existing plasma config/settings to .plsv file.Installationpip install plasmasaverCli GuideSave Profileplasmasaver save <profile_name>
eg: plasmasaver save MyProfileOptions:-f, --forceOverwrite already saved profiles-c <path>, --config-file <path>Use external config file-e <env>, --env <env>Desktop environment (e.g. kde)-p <password>, --password <password>Sudo Password to authorize restricted data (e.g. /usr/share)--include-globalInclude data from global data directory (/usr/share)--include-sddmInclude sddm data/configs directory (/usr/share/sddm, /etc/sddm.conf.d)--sddm-onlyPerform operation only on sddm data/configurations (Note: sudo password required)--skip-sudoSkip all sudo operationsRemove Profileplasmasaver remove <profile_name>
eg: plasmasaver remove MyProfileList Profileplasmasaver listApply Profileplasmasaver apply <profile_name>
eg: plasmasaver apply MyProfileOptions:-p <password>, --password <password>Sudo Password to authorize restricted data (e.g. /usr/share)--sddm-onlyApply only sddm (Note: sudo password required)--skip-globalSkip data from global data directory (/usr/share)--skip-sddmSkip sddm data/configs directory (/usr/share/sddm, /etc/sddm.conf.d)--skip-sudoSkip all sudo operationsImport Profileplasmasaver import <profile_path>
eg: plasmasaver import MyProfile.plsvOptions:-p <password>, --password <password>Sudo Password to authorize restricted data (e.g. /usr/share)--config-onlyPerform operation only on plasma configs (skip data, e.g. ~/.config)--data-onlyPerform operation only on plasma data (skip configs, e.g. ~/.local/share)--sddm-onlyPerform operation only on sddm data/configurations (Note: sudo password required)--skip-globalSkip data from global data directory (/usr/share)--skip-sddmSkip sddm data/configs directory (/usr/share/sddm, /etc/sddm.conf.d)--skip-sudoSkip all sudo operationsExport Profileplasmasaver export <profile_path>
eg: plasmasaver export MyProfile.plsvOptions:-p <password>, --password <password>Sudo Password to authorize restricted data (e.g. /usr/share)--config-onlyPerform operation only on plasma configs (skip data, e.g. ~/.config)--data-onlyPerform operation only on plasma data (skip configs, e.g. ~/.local/share)--sddm-onlyPerform operation only on sddm data/configurations (Note: sudo password required)--skip-globalSkip data from global data directory (/usr/share)--skip-sddmSkip sddm data/configs directory (/usr/share/sddm, /etc/sddm.conf.d)--skip-sudoSkip all sudo operationsWipe all Profilesplasmasaver wipeHelpplasmasaver -h
plasmasaver <action> -h
eg: plasmasaver import -hVersionplasmasaver -vWho do I talk to?Repo owner or adminOther community or team contact
Package: plasmatk
plasmatkA collection of tools for plasma physicistsInstallation$pipinstallplasmatkUsageTODOContributingInterested in contributing? Check out the contributing guidelines. Please note that this project is released with a Code of Conduct. By contributing to this project, you agree to abide by its terms.Licenseplasmatkwas created by Ryan Park. It is licensed under the terms of the MIT license.Creditsplasmatkwas created withcookiecutterand thepy-pkgs-cookiecuttertemplate.
Package: plasmic
Configuration files with a Python-like syntaxParse a very Python-like mini-language to produce a dictionary.  This
allows Python programs to be configured using a Python-like language
consisting of dictionaries, tuples, and literal values.  Plasmic
dictionary keys must be literal values.  Plasmic dictionary values can
be literal values and, possibly nested, tuples and other plasmic
dictionaries.Here is a sample configuration:{section1:
  {key1: "value1",
   key2: 2},
 section2:
  {key1: "othervalue",
   key3: 3.0
   subsection1:
    {key4: (1, 2, 3)
     key5: {"foo": "meta",
            "bar": "syntactic"}
    }
  }
}As a convenience all dictionary entries keyed by symbols have their
keys converted to the lower case string equivalent.The plasmic Python-like language contains almost no expression
evaluation.  The single, optional, expression allowed is astring.Formmatter.format()formatting syntax used for
interpolation – the insertion of of data into values by reference to
Plasmic dictionary keys.The recommended suffix for files written in the Plasmic language is:.pcfSub-ProjectsPlasmic has the following sub-projects to support configuring
applications using files written in Plasmic.  Most users will not want
to use plasmic directly but will import one of these sub-projects.plasmic.configparserAconfigparser-like API for the reading and writing of
configuration files in plasmic syntax.import plasmic.configparserplasmic.montagueA plugin allowing Plasmic configuration files to drive theMontagueWSGI component loader.Complete DocumentationThe complete documentation set can be found on the Plasmic home page athttp://plasmic.readthedocs.org/.
Package: plasmid-assessor
Plasmid assessment for Golden Gate cloningInstall:pipinstallplasmid_assessorWeb documentation:https://edinburgh-genome-foundry.github.io/Plasmid_assessor/Github page:https://github.com/Edinburgh-Genome-Foundry/Plasmid_assessorLicense:MIT, Copyright 2021 Edinburgh Genome Foundry, University of EdinburghMore biology softwarePlasmid assessor is part of theEGF Codonssynthetic biology software suite for DNA design, manufacturing and validation.
Package: plasmid-design
Installationpipinstallplasmid_designExampleIn a new directory, save the following toconfig.yaml, then runplasmid_design run. Thedrive_keybelow refers tothis spreadsheet.drive_key:&drive_key1QWFQUlIJYERJ6zY-THD9uNagD2a_He7RUfcOeF2eEKMtables:# vector definitionstemplates:table:drive_key:templates# selects just these rowsgate:experiment == "example"drive_key:*drive_key# DNA and protein part definitionsparts:table:drive_key:partsdrive_key:*drive_key# these DNA features will automatically be annotatedfeatures:table:drive_key:featuresdrive_key:*drive_key# these restriction sites will be avoidedrestriction_enzymes:table:drive_key:enzymes# selects just these rowsgate:pT02_BsaI == "x"drive_key:*drive_keyTheruncommand prints estimated cost and complexity scores. The following files will be generated:gene_order.fa# genes, ready to ordergene_order_idt_scores.csv# IDT gene synthesis complexity scores (different from gblock complexity)parts.csv# snapshot of input tabletemplates.csv# snapshot of input tablefeatures.csv# snapshot of input tablereverse_translations/restriction_enzymes.csv# snapshot of input tablereverse_translations/input.fa# amino acid parts that need reverse translationreverse_translations/output.fa# corresponding DNA, generated by DNA Chiselreverse_translations/idt_scores.csv# per-part IDT gene synthesis complexity scores, not meaningful for short partsreverse_translations/dna_chisel/# DNA Chisel logsConfigurationTables can be sourced in different ways.local csvtable: /path/to/csvprivate google sheetstable: "drive:{spreadsheet name}/{sheet name}"public google sheetstable: "drive_key:{sheet_name}"drive_key: {drive_key}For the public option, first enable link access in google sheets, then copydrive_keyfrom the URL:https://docs.google.com/spreadsheets/d/{drive_key}/.Changing the vector backboneThe DNA sequences upstream and downstream of the designed gene in the plasmid map are identified by having "up" or "down" in the part name. To change the vector backbone, define new upstream and downstream DNA parts, then change the template column in the templates sheet accordingly.
Package: plasmidhunter
presented by Institute of Food Safety and Health, Illinois Institute of TechnologyPlasmidHunter: Accurate and Fast Plasmid Prediction Based on Gene Content Using Machine LearningPlasmids are extrachromosomal DNA found in microorganisms. They often carry beneficial genes that help bacteria adapt to harsh conditions. Plasmids are also important tools in genetic engineering, gene therapy, and drug production. However, it can be difficult to identify plasmid sequences from chromosomal sequences in genomic and metagenomic data. Here, we have developed a new tool called PlasmidHunter, which uses machine learning to predict plasmid sequences based on gene content profile. PlasmidHunter achieved high accuracies (up to 97.6%) and high speeds in benchmark tests including both simulated contigs and real metagenomic plasmidome data, outperforming other existing tools.Keywords: artificial intelligence (AI), machine learning (ML), plasmid prediction, genomic sequencingInstallation and runconda create -n plasmidhunter -c bioconda -y python=3.10 diamond=2.1.8 prodigalconda activate plasmidhunterpip install plasmidhunterplasmidhunter -hResult InterpretationThe result is a tab-delimited table showing the prediction of each sequence. The columns include Prediction (0: chromosome, 1: plasmid), Probability of 0 (chromosome), and Probability of 1 (plasmid).CitationPlasmidHunter: Accurate and fast prediction of plasmid sequences using gene content profile and machine learningRenmao Tian, Jizhong Zhou, Behzad ImanianbioRxiv 2023.02.01.526640; doi:https://doi.org/10.1101/2023.02.01.526640ContactIf you have any questions, please contact Renmao Tian (tianrenmao[at]gmail.com) or Behzad Imanian (bimanian[at]iit.edu).LicenseEducational Community License, Version 2.0
Package: plasmidin
PlamidInsertCheckerCode for SWbioDTP Data Science and Machine Learning moduleThis is an installable python package that can be used to interrogate DNA sequences for restriction enzyme cutting sites. It can produce:i. a table of cut sites with useful information on the number of cut sites, the cut site locations, the enzyme cut overhang, and the commercial suppliersii. a figure showing the cut locations on a plasmid or linear section of DNAInstallationCreate a virtual environment using your favourite tool, clone the repsotiory to obtain the data and install the package using pipvirtualenv env_plasmidin
source env_plasmidin/bin/activate
git clone git@github.com:bmm514/PlamidInsertChecker.git
pip install plasmidinBasic useageImport required plasmidin Classesfrom plasmidin.plasmidin import RSInserter
from plasmidin.plasmid_diagrams import PlasmidDrawerInput fasta file or bio python Seq() for plasmid and insertplasmid_seq = 'path/to/plasmid_fasta.fa'
plasmid_linear = False
insert_seq = 'path/to/insert_fasta.fa'
insert_linear = True
remove_ambiguous_enzymes = TrueRun analysis on these to find restriction enzyme cut sites and
show the enzymes of interest i.e. single cut enzymesrsinserter = RSInserter(plasmid_seq, plasmid_linear, insert_seq, insert_linear, remove_ambiguous_enzymes)

rsinserter_XbaI_BamHI.shared_single_enzymesSelect from the list appropriate restriction enzymes to cutplasmid_cut_enzymes = ('EnzymeA', 'EnzymeB')
insert_cut_enzymes = ('EnzymeA', 'EnzymeB')Integrate insert sequence into plasmid sequencersinserter.integrate_seq(plasmid_cut_enzymes, insert_cut_enzymes)Analyse the output restriction sites and save a table of the restriction sites presentintegrated_table = '/path/to/restriction_enzymes.csv'

rsinserter.integrated_rsfinder.save_enzyme_table(integrated_table, delimiter = ',')Create plasmid map for the integrated sequenceinput_seq = rsinserter.integrated_rsfinder.input_seq
feature_info = rsinserter.integrated_rsfinder.feature_info
integrated_figure = '/path/to/integrated_restriction_map.pdf'

plasmid_drawer = PlasmidDrawer(input_seq, 'IntegratedSeq', feature_info)
plasmid_drawer.draw_gd_diagram(integrated_figure, 'circular', {'pagesize' : 'A4', 'circle_core' : 0.5, 'track_size' : 0.1})ExamplesSee plasmidin_example.py for code to run and produce output from PlasmidInsertChecker:python3 scripts/plasmidin_examples.pyThis will use the example fasta files indata/directory and produce output intoplasmidin_output
Package: plasmidrender
Plasmid_renderCLI tool to illustrate plasmids with a structure described by json.This program is a CLI tool that can describe the plasmid structure in json and output it as an image in SVG format.The output is in vector format, so there is no possibility of poor quality images being output.UsagePrerequisitesPython3DownloadDownload the code with git clone.git clone https://github.com/strelka145/Plasmid_render.git
cd Plasmid_renderJson file notationIf you want to draw a plasmid like the one shown in the figure, you can write a json like this.[{"type":"arrow","angle":"10","label":"primer","color":"black"},{"type":"space","angle":"10"},{"type":"tag","angle":"45","label":"EGFP","color":"green"},{"type":"space","angle":"10"},{"type":"arrow","angle":"-10","label":"primer","color":"black"},{"type":"space","angle":"20"},{"type":"tag","angle":"60","label":"RFP","color":"red"},{"type":"tag","angle":"60","label":"BFP","color":"#1E90FF"},{"type":"space","angle":"30"},{"type":"line","angle":"45","label":"BamHI","color":"black"}]typeIf the value oftypeis "tag", a annular sector is drawn; if it is "space", nothing is drawn and a space is opened at the angle specified byangle.Ifspaceis not described betweentagas shown between RFP and BFP in the example of json,{"type":"space","angle":"5"}is automatically inserted. If you do not want gaps between the annular sectors, write{"type": "space", "angle": "0"}.angleCentral angle of an annular sector or a gap. Specify the value using the degree method, NOT the radian method.labelText of an annular sector.colorColor of an annular sector.SVG output from json filespython3 main.py -i (Path of input json file) --output_svg_file (Path of output svg file)SVG output from json stringpython3 main.py --input_json (json code) --output_svg_file (Path of output svg file)Output as png formatpython3 main.py -i (Path of input json file) --output_png_file (Path of output png file)FutureTo be able to change the text styleAllow the hight of a annular sector to be changedAllow adjustable line thicknessMore futureRestriction Enzyme IndicationShow primerShow translation direction
Package: plasp
Topic:Generic implementations of weakly supervision algorithms
developped in[CAB20],[CAB21a],[CAB21b].Author:Vivien CabannesVersion:1.0.0 of 2021/06/07InstallationTo install our package, run the setup file$python<pathtocodefolder>/setup.pyinstallYou can also install it in develop mode, eventually with pip$cd<pathtocodefolder>$pipinstall-e.UsageSee files:problems/classification/libsvm_experiments.pyproblems/classification/semi_supervision_experiments.pyand more generally*_experiements.pyPackage RequirementsMost of the code is based on the following python libraries:numpynumbamatplotlibSome testing done with notebook are based on:jupyter-notebookipywidgetsFor ranking, we used the following lp solver library:cplexTo load LIBSVM files, more precisely to read libsvm files format we used:scikit-learnTo load MULAN files, more precisely to read mulan files format we used:arffskmultilearnDatasets linksDatasets can be download at:LIBSVM:https://www.csie.ntu.edu.tw/~cjlin/libsvm/oldfiles/index-1.0.htmlMULAN:http://mulan.sourceforge.net/datasets-mlc.htmlChange path in config filedataloader/config.pyto specify path to your data.References[CAB20]Structured Prediction with Partial Labelling through the Infimum Loss,
Cabannes et al.,ICML, 2020[CAB21a]Disambiguation of weak supervision with exponential convergence rates,
Cabannes et al.,ICML, 2021[CAB21b]Overcoming the curse of dimensionality with Laplacian regularization
in semi-supervised learning, Cabannes et al.,Preprint, 2021
Package: plasso
===============================Author: Stephen Anthony RoseOriginal paper: [https://arxiv.org/abs/1712.00484]```pip install plasso```Abstract--------We propose a generalization of the lasso that allows the model coefficients to vary as a function of a general set of modifying variables. These modifiers might be variables such as gender, age or time. The paradigm is quite general, with each lasso coefficient modified by a sparse linear function of the modifying variables Z. The model is estimated in a hierarchical fashion to control the degrees of freedom and avoid overfitting. The modifying variables may be observed, observed only in the training set, or unobserved overall. There are connections of our proposal to varying coefficient models and high-dimensional interaction models. We present a computationally efficient algorithm for its optimization, with exact screening rules to facilitate application to large numbers of predictors. The method is illustrated on a number of different simulated and real examples.Example-------```pythonfrom plasso import PliableLasso# Input data looks just like sklearn except an extra matrix Zy = target_data()x = data()  # Main effects dataz = modifying_data()  # Data used to modify the estimate coefficients for X# Fit modelmodel = PliableLasso()model.fit(x, z, y)# Cool things to do afterwardsy_hat = model.predict(x, z)```Check out the `example.py` file to see more ways to use it.Installation / Usage--------------------To install use pip:$ pip install plassoOr clone the repo:$ git clone https://github.com/arose13/PliableLasso.git$ python setup.py installAlso for large data sets I recommend install `pytorch`Contributing------------Me (Stephen Anthony Rose)If you want to add and improve things be my guest.Platform: UNKNOWNClassifier: Development Status :: 4 - BetaClassifier: Intended Audience :: DevelopersClassifier: Programming Language :: Python :: 3Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence