semvec/pypi-packages huggingface dataset:
toxinpred3 1.4
A tool to predict toxic and non-toxic peptides
Requires Python: >=3.6

# Toxinpred3.0
A method for predicting toxicity of the peptides
# Introduction
ToxinPred3.0 is developed for predicting, mapping and scanning toxic/non-toxic peptides. It uses only composition based features for predicting toxic/non-toxic peptides.The final model also deploys a motif-based module which has been implemented using MERCI. More information on ToxinPred3.0 is available from its web server http://webs.iiitd.edu.in/raghava/toxinpred3. Please read/cite the content about toxinpred3 for complete information including algorithm behind the approach.


## Installation
To install the package, type the following command:
```
pip install toxinpred3
```


**Minimum USAGE** 

To know about the available option for the standalone, type the following command:
```
toxinpred3.py -h
```
To run the example, type the following command:
```
toxinpred3.py -i peptide.fa

```
**Full Usage**: 
```
Following is complete list of all options, you may get these options
usage: toxinpred3.py [-h] 
                     [-i INPUT]
                     [-o OUTPUT]
                     [-t THRESHOLD]
                     [-m {1,2}] 
                     [-d {1,2}]
```
```
Please provide following arguments

optional arguments:
  -h, --help            show this help message and exit
  -i INPUT, --input INPUT
                        Input: protein or peptide sequence in FASTA format or
                        single sequence per line in single letter code
  -o OUTPUT, --output OUTPUT
                        Output: File for saving results by default outfile.csv
  -t THRESHOLD, --threshold THRESHOLD
                        Threshold: Value between 0 to 1 by default 0.38
  -m {1,2}, -- model Model
                        Model: 1: ML model, 2: Hybrid model, by default 2
  -d {1,2}, --display {1,2}
                        Display: 1:Toxin peptide, 2: All peptides, by
                        default 1

```

**Input File**: It allow users to provide input in two format; i) FASTA format (standard) (e.g. peptide.fa) and ii) Simple Format. In case of simple format, file should have one peptide sequence in a single line in single letter code (eg. peptide.seq). 

**Output File**: Program will save result in CSV format, in case user do not provide output file name, it will be stored in outfile.csv.

**Threshold**: User should provide threshold between 0 and 1, please note score is proportional to toxic potential of peptide.

**Models**:  In this program, two models have been incorporated;  i) Model1 for predicting given input peptide sequence as toxic and non-toxic peptide using Extra tree based on amino-acid composition (AAC) and di peptide composition (DPC) of the peptide; 

ii) Model2 for predicting given input peptide sequence as toxic and non-toxic peptide using Hybrid approach, which is the ensemble of Extra tree + MERCI. It combines the scores generated from machine learning (ET), and MERCI as Hybrid Score, and the prediction is based on Hybrid Score.
camSort 0.4.1
make sorted() fast for strings
Keywords: python,sorted,sort,camSort,reverse,list,strings

# camSort 0.4.1!

Working on `python 3.7.3`! (at least I think.)

`camSort` is a Python library that makes sorted() look slow while also using sorted(). It's built on Cython, and provides preallocation to string sorting by using a custom key calculation for each string. Normal key calculation and object creation are often computationally expensive—but here we optimize that with Cython >:)!

## Overview

The `camSort` library sorts a list of strings by creating a custom object for each string. This custom object, `StringWithKey`, holds the string and a unique key calculated from it. The key is a long integer derived from the sum of Unicode code points of the characters in the string, and the string's length.

The actual sorting operation uses Python's built-in `sorted` function (based on Timsort), however, now with precalculated keys, rather than comparing the strings themselves. Making sorting quite faster.

The primary benefit of using `camSort` is realized when working with very large lists of strings, see: Performance.

## Installation

```pip install camSort```, or build locally :)

## Usage

```python
from camSort import sortStrings

myList = ['your', 'list', 'of', 'strings', ':)!']

# By length
sortedStrings = sortStrings.byLength(myList)
# By alphabetically
sortedStrings = stringSort.byAlphabet(myList)
# By sorting alphabetically and length
sortedStrings = stringSort.byLengthAndAlphabet(myList)
# Reversing! (This is the exact same as Python's)
# Please read the demo.py file for an explaination.
sortedStrings = stringSort.byLength(myList).reverse()
# Returns a list of strings that contain a given substring/key, this is list comprehension.
# Speed increase will be looked at in future.
filteredStrings = sortedStrings.filterWithSubstring('hello'))

```

## Performance

Try out the demo.py file!

Average output on my 2017 macbook pro:
    (1 million strings, with a random legnth of 1 to 1000 chararacters)

```
Time taken by Python sorted():               52.74097275733948 seconds
    Using camSort!
Time taken sorting by length:                2.0430028438568115 seconds
By sorting alphabetically:                   3.7439329624176025 seconds
By sorting alphabetically and length:        2.3696372509002686 seconds

Not optmised (yet)

Python reverse:                              2.4335076808929443 seconds
Camsort reverse:                             2.4054980278015137 seconds
Using python list comprehension:             0.40741705894470215 seconds
Using filterWithSubstring:                   0.5404400825500488 seconds

Results pre 0.4.

Python reverse:                              5.526482105255127 seconds
Camsort reverse:                             5.083630084991455 seconds
Using Python's list comprehension:           0.4732799530029297 seconds
Using filterWithSubstring:                   0.38806891441345215 seconds
```