def find_composition(df_original):
df_copy = df_original.copy()
column_names = []
for ch in codes:
column_names.append(ch + '_percent')
column_names.append(ch + '_percent_first')
column_names.append(ch + '_percent_last')
column_names.append('len')
column_names.append('weight')
column_names.append('gravy')
column_names.append('flex_mean')
column_names.append('flex_std')
column_names.append('ss_helix')
column_names.append('ss_turn')
column_names.append('ss_sheet')
column_names.append('iep')
column_names.append('aromaticity')
df = pd.DataFrame(columns=column_names)
for _, seq in enumerate(tqdm(df_copy['seq'])):
df_temp = pd.Series()
sequence = str(seq)
analysed = ProteinAnalysis(sequence)
analysed_first = ProteinAnalysis(sequence[:first_n])
analysed_last = ProteinAnalysis(sequence[-last_n:])
df_temp['len'] = analysed.length
df_temp['ss_helix'], df_temp['ss_turn'], df_temp['ss_sheet'] = analysed.secondary_structure_fraction()
df_temp['iep'] = analysed.isoelectric_point()
# overall
for aa, percent in analysed.get_amino_acids_percent().items():
df_temp[aa + '_percent'] = percent
# # first N
for aa, percent in analysed_first.get_amino_acids_percent().items():
df_temp[aa + '_percent_first'] = percent
# last N
for aa, percent in analysed_last.get_amino_acids_percent().items():
df_temp[aa + '_percent_last'] = percent
df_temp['weight'] = analysed.molecular_weight()
df_temp['gravy'] = analysed.gravy()
df_temp['aromaticity'] = analysed.aromaticity()
df_temp['flex_mean'] = np.mean(analysed.flexibility())
df_temp['flex_std'] = np.std(analysed.flexibility())
df = df.append(df_temp, ignore_index=True)
return pd.concat([df_copy, df], axis=1)
def getProps(f):
"""
Code for getting the molecular weight and other properties using Biopython
"""
L = myPDB.loader(f)
aseq = ProteinAnalysis(L.seq)
return aseq.molecular_weight(), np.max(aseq.flexibility()), np.sum(L.ASA)
def protein_analysis():
if session.username == None:
redirect(URL(r=request, c='account', f='log_in'))
from Bio.SeqUtils.ProtParam import ProteinAnalysis
form = FORM(
TABLE(
TR(
"Amino acid sequence: ",
TEXTAREA(_type="text",
_name="sequence",
requires=IS_NOT_EMPTY())),
INPUT(_type="submit", _value="SUBMIT")))
if form.accepts(request.vars, session):
session['sequence'] = seqClean(form.vars.sequence.upper())
X = ProteinAnalysis(session['sequence'])
session['aa_count'] = X.count_amino_acids()
session['percent_aa'] = X.get_amino_acids_percent()
session['mw'] = X.molecular_weight()
session['aromaticity'] = X.aromaticity()
session['instability'] = X.instability_index()
session['flexibility'] = X.flexibility()
session['pI'] = X.isoelectric_point()
session['sec_struct'] = X.secondary_structure_fraction()
redirect(URL(r=request, f='protein_analysis_output'))
return dict(form=form)
def protAnalysis(self, content):
result, resultFlexDic = dict(), dict()
content = Parsers.normalizeSequence(content, self.sourceType)
protein = ProteinAnalysis(content)
result['proteinMWeight'] = protein.molecular_weight()
result['proteinAroma'] = protein.aromaticity()
result['proteinInstab'] = protein.instability_index()
result['proteinIsoelec'] = protein.isoelectric_point()
result['proteinGravy'] = protein.gravy()
proteinStructure = protein.secondary_structure_fraction()
protStruct = self.flatten('proteinSecstruc', proteinStructure)
result = {**protStruct, **result}
# merge result and protein Structure
flexibility = protein.flexibility()
flexibFlat = self.flatten('proteinFlex', flexibility)
flexibAmino = self.flatten(list(content), flexibility)
flattened = {**flexibFlat, **result}
flattenedFlexDic = {**flexibAmino, **result}
return result, flattened, flattenedFlexDic,
def make_dataset(fasta):
# a list of dictionaries containing features for all sequences
ls_features = []
# assign whether it's from tardigrades 'tar' or poplars 'pop'
if 'tar' in fasta:
target = 0
elif 'pop' in fasta:
target = 1
for record in SeqIO.parse(fasta, "fasta"):
analysed_seq = ProteinAnalysis(str(record.seq))
# the dictionary containing features for a single sequence
dict_features = {}
# compute length
dict_features['length'] = len(record.seq)
# compute molecular weight
dict_features['mol_weight'] = analysed_seq.molecular_weight()
# compute aromaticity
dict_features['aromaticity'] = analysed_seq.molecular_weight()
# compute stability
dict_features['stability'] = analysed_seq.instability_index()
# compute flexibility
dict_features['flexibility'] = analysed_seq.flexibility()
# compute isoelectric point
dict_features['isoelectric'] = analysed_seq.isoelectric_point()
# compute secondary structure fraction
frac = analysed_seq.secondary_structure_fraction()
dict_features['helix'] = frac[0]
dict_features['turn'] = frac[1]
dict_features['sheet'] = frac[2]
# compute AAC composition of entire sequence
aac = analysed_seq.get_amino_acids_percent()
# merge all features and dictionaries into dict_features
dict_features.update(aac)
ls_features += [dict_features]
df = pd.DataFrame(ls_features)
df['target'] = target
print(df)
df.to_pickle(name + '_set.pkl')
def get_flexibility(self):
"""
Calculates the flexibility according to Vihinen, 1994 (return proteinsequencelenght-9 values ) from biopython
:return: dictionary with proteinsequencelenght-9 values of flexiblity
"""
res = {}
analysed_seq = ProteinAnalysis(self.ProteinSequence)
flexibility = analysed_seq.flexibility()
for i in range(len(flexibility)):
res['flexibility_' + str(i)] = flexibility[i]
return res
def biopython_protein_analysis(inseq):
"""Utiize Biopython's ProteinAnalysis module to return general sequence properties of an amino acid string.
For full definitions see: http://biopython.org/DIST/docs/api/Bio.SeqUtils.ProtParam.ProteinAnalysis-class.html
Args:
inseq: Amino acid sequence
Returns:
dict: Dictionary of sequence properties. Some definitions include:
instability_index: Any value above 40 means the protein is unstable (has a short half life).
secondary_structure_fraction: Percentage of protein in helix, turn or sheet
TODO:
Finish definitions of dictionary
"""
inseq = ssbio.protein.sequence.utils.cast_to_str(inseq)
analysed_seq = ProteinAnalysis(inseq)
info_dict = {}
info_dict['amino_acids_content-biop'] = analysed_seq.count_amino_acids()
info_dict[
'amino_acids_percent-biop'] = analysed_seq.get_amino_acids_percent()
info_dict['length-biop'] = analysed_seq.length
info_dict['monoisotopic-biop'] = analysed_seq.monoisotopic
info_dict['molecular_weight-biop'] = analysed_seq.molecular_weight()
info_dict['aromaticity-biop'] = analysed_seq.aromaticity()
info_dict['instability_index-biop'] = analysed_seq.instability_index()
# TODO: What is flexibility?
info_dict['flexibility-biop'] = analysed_seq.flexibility()
info_dict['isoelectric_point-biop'] = analysed_seq.isoelectric_point()
# grand average of hydrophobicity
info_dict['gravy-biop'] = analysed_seq.gravy()
# Separated secondary_structure_fraction into each definition
# info_dict['secondary_structure_fraction-biop'] = analysed_seq.secondary_structure_fraction()
info_dict[
'percent_helix_naive-biop'] = analysed_seq.secondary_structure_fraction(
)[0]
info_dict[
'percent_turn_naive-biop'] = analysed_seq.secondary_structure_fraction(
)[1]
info_dict[
'percent_strand_naive-biop'] = analysed_seq.secondary_structure_fraction(
)[2]
return info_dict
def flexibility(self): #overrides base class
if self._contains_unknown:
new_sequence = self._sequence.replace('X',
'R') #replace with an avg aa
new_sequence = new_sequence.replace('U',
'R') #replace with an avg aa
new_sequence = new_sequence.replace('B',
'R') #replace with an avg aa
new_p = ProteinAnalysis(new_sequence)
flex = new_p.flexibility()
else:
flex = super(Protein, self).flexibility()
return flex
def protein_analysis():
if session.username == None: redirect(URL(r=request,f='../account/log_in'))
from Bio.SeqUtils.ProtParam import ProteinAnalysis
form = FORM(TABLE(
TR("Amino acid sequence: ",
TEXTAREA(_type="text", _name="sequence",
requires=IS_NOT_EMPTY())),
INPUT(_type="submit", _value="SUBMIT")))
if form.accepts(request.vars,session):
session['sequence'] = seqClean(form.vars.sequence.upper())
X = ProteinAnalysis(session['sequence'])
session['aa_count'] = X.count_amino_acids()
session['percent_aa'] = X.get_amino_acids_percent()
session['mw'] = X.molecular_weight()
session['aromaticity'] = X.aromaticity()
session['instability'] = X.instability_index()
session['flexibility'] = X.flexibility()
session['pI'] = X.isoelectric_point()
session['sec_struct'] = X.secondary_structure_fraction()
redirect(URL(r=request, f='protein_analysis_output'))
return dict(form=form)
def GetFeatures (My_seq):
Features = {}
ProteinAnalysis(My_seq)
analysed_seq = ProteinAnalysis(My_seq)
#Caracteristicas monovaloradas
Features["Molecular_weight"] = analysed_seq.molecular_weight()
Features["Aromaticity"] = analysed_seq.aromaticity()
Features["Instability_index"] = analysed_seq.instability_index()
Features["Isoelectric_point"] = analysed_seq.isoelectric_point()
#Caracteristicas multivaloradas
Features["Flexibility"] = analysed_seq.flexibility() # List 580
Features["Second_structure_fraction"] = analysed_seq.secondary_structure_fraction() #3 Tupla
Features["Count_amino_acids"] = analysed_seq.count_amino_acids() #20 Dict
Features["Amino_acids_percent"] = analysed_seq.get_amino_acids_percent() #20 Dict
return Features
def physchem_props(ara_d):
"""Calculate the physicochemical properties per protein in ara_d."""
c = 0
g = 0
for protein in ara_d:
seq = ara_d[protein]["sequence"]
# Calculates the properties
if "X" in seq:
continue # Skip non-usable sequences, only negs
if '*' in seq:
if ara_d[protein]["pos"] != []:
print(protein)
continue
a_seq = ProteinAnalysis(seq)
# Update ara_d with new physchem properties
results = [
a_seq.molecular_weight(),
a_seq.gravy(),
a_seq.aromaticity(),
a_seq.instability_index(),
a_seq.flexibility(),
a_seq.isoelectric_point(),
a_seq.secondary_structure_fraction(),
]
keys = [
"mol_weight",
"gravy",
"aromaticity",
"instab_index",
"flexi",
"iso_point",
"seq_struct",
]
ara_d[protein]["Properties"] = {}
for k, v in zip(keys, results):
ara_d[protein]["Properties"][k] = v
return ara_d
def biopython_proteinanalysis_seq(seq, scaling=False):
res = ProteinAnalysis(seq)
d = {}
flex = np.array(res.flexibility())
d['flex:min'], d['flex:max'], d['flex:std'] = flex.min(), flex.max(
), flex.std()
d['gravy'] = res.gravy()
d['instability_index'] = res.instability_index()
d['isoelectric_point'] = res.isoelectric_point()
r, c = res.molar_extinction_coefficient()
d['molar_extinction_coefficient_reduced'], d[
'molar_extinction_coefficient_cysteines'] = r, c
d['molecular_weight'] = res.molecular_weight()
d['percent_helix_naive'], d['percent_turn_naive'], d[
'percent_strand_naive'] = res.secondary_structure_fraction()
aap = res.get_amino_acids_percent()
aas = sorted(aap.keys())
d.update({'percent:%s' % aa: aap[aa] for aa in aas})
d.update({
'prop_res_%s' % key: sum([aap.get(x, 0) for x in value])
for key, value in list(property_residues.items())
})
return d
flex=[]
for seq in sequences:
X=ProteinAnalysis(str(seq))
isoelectricPt.append(X.isoelectric_point())
aromaticity.append(X.aromaticity())
aminoPercent.append(X.get_amino_acids_percent())
secstruct.append(X.secondary_structure_fraction())
# These features throw Key & Value Errors due to non standard amino acids
# (i.e. out of the 20 standard ones) e.g. X, U etc
try:
gravy.append(X.gravy())
molweight.append(X.molecular_weight())
instidx.append(X.instability_index())
flex.append(X.flexibility())
hydrophob.append(X.protein_scale(ProtParamData.kd, 9, 0.4))
hydrophil.append(X.protein_scale(ProtParamData.hw, 9, 0.4))
surface.append(X.protein_scale(ProtParamData.em, 9, 0.4))
except (KeyError,ValueError):
gravy.append(0)
molweight.append(0)
instidx.append(0)
flex.append([0,0])
hydrophob.append([0,0])
hydrophil.append([0,0])
surface.append([0,0])
isoelectricPt_df = pd.DataFrame(isoelectricPt,columns=['isoelectricPt'])
aromaticity_df = pd.DataFrame(aromaticity,columns=['aromaticity'])
def openfile():
global prob, probab, te
global my_seq
global anti
global structure, structure_id, filename
global antigenicity, hydro, flex, sec
global m, a, c, b, length, j, k
global hydroph, flexi, access
anti = []
sec = []
probab = []
from tkinter import filedialog
root = Tk()
root.filename = filedialog.askopenfilename(
initialdir="/",
title="Select file",
filetypes=(("pdb files", "*.pdb"), ("pdb files", "*.pdb")))
filename = root.filename
print(filename)
structure_id = "1e6j"
structure = PDBParser().get_structure(structure_id, root.filename)
ppb = PPBuilder()
for pp in ppb.build_peptides(structure):
my_seq = pp.get_sequence() # type: Seq
print(my_seq)
for model in structure:
for chain in model:
print(chain)
sequence = list(my_seq)
m = ''.join(sequence)
print(m)
length = len(m) # type: int
print("Sequence consist of", length, "Amino Acids")
from Bio.SeqUtils.ProtParam import ProteinAnalysis
analysed_seq = ProteinAnalysis(m)
print("Molecular weight = ", analysed_seq.molecular_weight())
print("Amino Acid Count = ", analysed_seq.count_amino_acids())
print("Secondary structure fraction =",
analysed_seq.secondary_structure_fraction())
kd = {
'A': 1.8,
'R': -4.5,
'N': -3.5,
'D': -3.5,
'C': 2.5,
'Q': -3.5,
'E': -3.5,
'G': -0.4,
'H': -3.2,
'I': 4.5,
'L': 3.8,
'K': -3.9,
'M': 1.9,
'F': 2.8,
'P': -1.6,
'S': -0.8,
'T': -0.7,
'W': -0.9,
'Y': -1.3,
'V': 4.2
}
c = list(analysed_seq.flexibility())
b = list(analysed_seq.protein_scale(kd, 10, 1.0))
hydro = list(analysed_seq.protein_scale(kd, 10, 1.0))
flex = list(analysed_seq.flexibility())
hydroph = list(analysed_seq.protein_scale(kd, 10, 1.0))
flexi = list(analysed_seq.flexibility())
i = 1
j = -1 # type: int
k = 9
while i <= (length - 10):
print("Sequence is = ", m[j + 1:k + 1])
print("Flexibility value = ", c[j + 1])
print("Hydrophilicity value = ", b[j + 1])
ana_seq = ''.join(m[j + 1:k + 1])
analyze_seq = ProteinAnalysis(ana_seq)
# For Secondary structure Analysis
print("Secondary structure fraction =",
analyze_seq.secondary_structure_fraction())
a = list(analyze_seq.secondary_structure_fraction())
a = a[0]
sec.append(a)
i += 1
j += 1
k += 1
f = length
r = 1
y = 10
global acc, logacc
acc = []
for i in range(0, f):
str1 = "accessibility, resi "
str2 = str(r) + "-" + str(y)
saving = str1 + str2
print(saving)
r = r + 1
y = y + 1
structure = freesasa.Structure("1e6j.pdb")
resulta = freesasa.calc(structure)
area_classes = freesasa.classifyResults(resulta, structure)
print("Total : %.2f A2" % resulta.totalArea())
for key in area_classes:
print(key, ": %.2f A2" % area_classes[key])
resulta = freesasa.calc(
structure,
freesasa.Parameters({
'algorithm': freesasa.LeeRichards,
'n-slices': 10
}))
selections = freesasa.selectArea(('alanine, resn ala', saving),
structure, resulta)
for key in selections:
print(key, ": %.2f A2" % selections[key])
a = selections[key]
acc.append(a)
l = acc[0::2]
access = l
print(acc)
print(l)
logacc = [math.log(y, 10) for y in l]
print(logacc)
class ProteinFeatureExtractor:
"""
Feature extraction from protein sequence for
Machine Learning classification or deeper analysis
Example usage:
from features.extractors.proteins import ProteinFeatureExtractor
pfe = ProteinFeatureExtractor(protein_sequence='MAKINELLRESTTTNSNSIGRPNLVALTRATTKLIYSDIVATQRTNQPVAA')
pfe.get_features()
"""
FEATURE_NAMES = [
"protein_length",
"gravy",
"molecular_weight",
"aromaticity",
"instability_index",
"isoelectric_point",
"flexibility",
"mec_cysteines",
"mec_cystines",
"ssf_helix",
"ssf_turn",
"ssf_sheet",
]
def __init__(self, protein_sequence: str):
self.protein_sequence = self._normalize(protein_sequence)
self.protein_analysis = ProteinAnalysis(self.protein_sequence)
@staticmethod
def _normalize(source: Union[str, SeqRecord]) -> str:
"""
Normalize each protein sequence
to uppercase and without blank chars
"""
# If source is a string
if isinstance(source, str):
entry = source
# If source is a BioPython object with seq field
else:
entry = source.seq
return str(entry).upper().strip()
def _get_protein_length(self) -> int:
"""
Protein length
"""
return len(self.protein_sequence)
def _calculate_gravy(self) -> float:
"""
GRAVY (Grand Average of Hydropathy) index score
is calculated by adding the hydropathy value for
each residue and then dividing by the length of
the protein sequence
Negative GRAVY value indicates that the protein
is non-polar and Positive value indicates that
the protein is polar
"""
return self.protein_analysis.gravy()
def _calculate_molecular_weight(self) -> float:
"""
Molecular Weight is calculated as the sum
of atomic masses of all atoms in the molecul
"""
return self.protein_analysis.molecular_weight()
def _calculate_aromaticity(self) -> float:
"""
Aromaticity is used to describe a planar, cyclic
molecule with a ring of resonance bonds which is
more stable when compared to other connective or
geometric arrangements consisting of the same set
of atoms
"""
return self.protein_analysis.aromaticity()
def _calculate_instability_index(self) -> float:
"""
Instability index gives an estimate of the stability
of the protein in a test tube
Any value above 40 means that the protein is unstable
(has a short half life)
"""
return self.protein_analysis.instability_index()
def _calculate_isoelectric_point(self) -> float:
"""
Isoelectric point (pI) is the pH at which net charge of
the protein is zero. Isoelectric point is widely useful
for choosing a buffer system for purification and
crystallisation of a given protein
"""
return self.protein_analysis.isoelectric_point()
def _calculate_flexibility(self) -> float:
"""
Flexibility is of overwhelming importance for protein function,
because of the changes in protein structure during interactions
with binding partners
"""
return sum(self.protein_analysis.flexibility())
def _calculate_molar_extinction_coefficient(self) -> Mapping[str, float]:
"""
Molar extinction coefficient of a protein sequence can be calculated
from the molar extension coefficient of amino acids which are
Cystine, Tyrosine and Tryptophan
"""
cysteines, cystines = self.protein_analysis.molar_extinction_coefficient()
residues = {self.FEATURE_NAMES[7]: cysteines, self.FEATURE_NAMES[8]: cystines}
return residues
def _calculate_secondary_structure_fraction(self) -> Mapping[str, float]:
"""
This function returns a list of the fraction of amino acids which
tend to be in Helix, Turn or Sheet
Amino acids present in Turn are:
Asparagine (N), Proline (P), Glycine (G), Serine (S)
Amino acids present in Sheets are:
Glutamic acid (E), Methionine (M), Alanine (A), Leucine (L)
"""
helix, turn, sheet = self.protein_analysis.secondary_structure_fraction()
fractions = {
self.FEATURE_NAMES[9]: helix,
self.FEATURE_NAMES[10]: turn,
self.FEATURE_NAMES[11]: sheet,
}
return fractions
def get_features(self) -> Mapping[str, Union[int, float, None]]:
"""
Return full feature space for single protein as Python dict
"""
features = {
self.FEATURE_NAMES[0]: self._get_protein_length(),
self.FEATURE_NAMES[1]: self._calculate_gravy(),
self.FEATURE_NAMES[2]: self._calculate_molecular_weight(),
self.FEATURE_NAMES[3]: self._calculate_aromaticity(),
self.FEATURE_NAMES[4]: self._calculate_instability_index(),
self.FEATURE_NAMES[5]: self._calculate_isoelectric_point(),
self.FEATURE_NAMES[6]: self._calculate_flexibility(),
}
features.update(self._calculate_molar_extinction_coefficient())
features.update(self._calculate_secondary_structure_fraction())
return features
def openfile():
global my_seq
global antigenicity
global m, a, c, b
from tkinter import filedialog
root = Tk()
root.filename = filedialog.askopenfilename(
initialdir="/",
title="Select file",
filetypes=(("pdb files", "*.pdb"), ("pdb files", "*.pdb")))
print(root.filename)
structure_id = "1e6j"
structure = PDBParser().get_structure(structure_id, root.filename)
ppb = PPBuilder()
for pp in ppb.build_peptides(structure):
my_seq = pp.get_sequence() # type: Seq
print(my_seq)
for model in structure:
for chain in model:
print(chain)
sequence = list(my_seq)
m = ''.join(sequence) # type: str
print(m)
length = len(m) # type: int
print(length)
print("Sequence consist of", len(m), "Amino Acids")
from Bio.SeqUtils.ProtParam import ProteinAnalysis
analysed_seq = ProteinAnalysis(m)
print("Molecular weight = ", analysed_seq.molecular_weight())
print("Amino Acid Count = ", analysed_seq.count_amino_acids())
print("Secondary structure fraction =",
analysed_seq.secondary_structure_fraction())
kd = {
'A': 1.8,
'R': -4.5,
'N': -3.5,
'D': -3.5,
'C': 2.5,
'Q': -3.5,
'E': -3.5,
'G': -0.4,
'H': -3.2,
'I': 4.5,
'L': 3.8,
'K': -3.9,
'M': 1.9,
'F': 2.8,
'P': -1.6,
'S': -0.8,
'T': -0.7,
'W': -0.9,
'Y': -1.3,
'V': 4.2
}
c = list(analysed_seq.flexibility())
b = list(analysed_seq.protein_scale(kd, 10, 1.0))
i = 1
j = -1 # type: int
k = 9
while i <= (length - 10):
print("Sequence is = ", m[j + 1:k + 1])
print("Flexibility value = ", c[j + 1])
print("Hydrophilicity value = ", b[j + 1])
ana_seq = ''.join(m[j + 1:k + 1])
analyze_seq = ProteinAnalysis(ana_seq)
# For Secondary structure Analysis
print("Secondary structure fraction =",
analyze_seq.secondary_structure_fraction())
a = list(analyze_seq.secondary_structure_fraction())
global tupleall
tupleall = (m[j + 1:k + 1], c[j + 1], b[j + 1], a)
print(tupleall[0], tupleall[2], tupleall[1], tupleall[3])
i = i + 1
if a[0] >= a[1]:
a[0] = 1
else:
a[0] = a[1]
# For Hydrophilicity
if b[j + 1] > 0.5:
b[j + 1] = 2
elif b[j + 1] < 0.5 or b[j + 1] > 0:
b[j + 1] = 1
elif b[j + 1] > 0 or b[j + 1] > -0.4:
b[j + 1] = -1
elif b[j + 1] < -0.4:
b[j + 1] = -2
else:
b[j + 1] = 0
# For Flexibility
if c[j + 1] > 1.0:
c[j + 1] = 1
else:
c[j + 1] = 0
# For antigenicity Index
antigenicity = 0.3 * b[j + 1] + 0.15 * 1 + 0.15 * c[j + 1] + 0.2 * a[0]
print("antigenicity", antigenicity)
j += 1
k += 1
def protein_features(protein_sequences):
"""
This function calculates a number of basic properties for a list of protein sequences
Input: list of protein sequences (as strings), length can also be 1
Output: a dataframe of features
"""
import numpy as np
import pandas as pd
from Bio.SeqUtils.ProtParam import ProteinAnalysis
# AA frequency and protein characteristics
mol_weight = []
aromaticity = []
instability = []
flexibility = []
prot_length = []
pI = []
helix_frac = []
turn_frac = []
sheet_frac = []
frac_aliph = []
frac_unch_polar = []
frac_polar = []
frac_hydrophob = []
frac_pos = []
frac_sulfur = []
frac_neg = []
frac_amide = []
frac_alcohol = []
AA_dict = {
'G': [],
'A': [],
'V': [],
'L': [],
'I': [],
'F': [],
'P': [],
'S': [],
'T': [],
'Y': [],
'Q': [],
'N': [],
'E': [],
'D': [],
'W': [],
'H': [],
'R': [],
'K': [],
'M': [],
'C': []
}
for item in protein_sequences:
# calculate various protein properties
prot_length.append(len(item))
frac_aliph.append(
(item.count('A') + item.count('G') + item.count('I') +
item.count('L') + item.count('P') + item.count('V')) / len(item))
frac_unch_polar.append((item.count('S') + item.count('T') +
item.count('N') + item.count('Q')) / len(item))
frac_polar.append(
(item.count('Q') + item.count('N') + item.count('H') +
item.count('S') + item.count('T') + item.count('Y') +
item.count('C') + item.count('M') + item.count('W')) / len(item))
frac_hydrophob.append(
(item.count('A') + item.count('G') + item.count('I') +
item.count('L') + item.count('P') + item.count('V') +
item.count('F')) / len(item))
frac_pos.append(
(item.count('H') + item.count('K') + item.count('R')) / len(item))
frac_sulfur.append((item.count('C') + item.count('M')) / len(item))
frac_neg.append((item.count('D') + item.count('E')) / len(item))
frac_amide.append((item.count('N') + item.count('Q')) / len(item))
frac_alcohol.append((item.count('S') + item.count('T')) / len(item))
protein_chars = ProteinAnalysis(item)
mol_weight.append(protein_chars.molecular_weight())
aromaticity.append(protein_chars.aromaticity())
instability.append(protein_chars.instability_index())
flexibility.append(np.mean(protein_chars.flexibility()))
pI.append(protein_chars.isoelectric_point())
H, T, S = protein_chars.secondary_structure_fraction()
helix_frac.append(H)
turn_frac.append(T)
sheet_frac.append(S)
# calculate AA frequency
for key in AA_dict.keys():
AA_dict[key].append(item.count(key) / len(item))
# make new dataframe & return
features_protein = pd.DataFrame.from_dict(AA_dict)
features_protein['protein_length'] = np.asarray(prot_length)
features_protein['mol_weight'] = np.asarray(mol_weight)
features_protein['aromaticity'] = np.asarray(aromaticity)
features_protein['instability'] = np.asarray(instability)
features_protein['flexibility'] = np.asarray(flexibility)
features_protein['pI'] = np.asarray(pI)
features_protein['frac_aliphatic'] = np.asarray(frac_aliph)
features_protein['frac_uncharged_polar'] = np.asarray(frac_unch_polar)
features_protein['frac_polar'] = np.asarray(frac_polar)
features_protein['frac_hydrophobic'] = np.asarray(frac_hydrophob)
features_protein['frac_positive'] = np.asarray(frac_pos)
features_protein['frac_sulfur'] = np.asarray(frac_sulfur)
features_protein['frac_negative'] = np.asarray(frac_neg)
features_protein['frac_amide'] = np.asarray(frac_amide)
features_protein['frac_alcohol'] = np.asarray(frac_alcohol)
features_protein['AA_frac_helix'] = np.asarray(helix_frac)
features_protein['AA_frac_turn'] = np.asarray(turn_frac)
features_protein['AA_frac_sheet'] = np.asarray(sheet_frac)
return features_protein
def get_flexibility(seq):
"""
Get weight ignoreing modifications.
"""
bio_seq = ProteinAnalysis(seq)
return (bio_seq.flexibility())
from Bio.SeqUtils.ProtParam import ProteinAnalysis
from Bio.SeqUtils import ProtParamData
from Bio import SeqIO
with open('../../samples/pdbaa') as fh:
for rec in SeqIO.parse(fh,'fasta'):
myprot = ProteinAnalysis(str(rec.seq))
print(myprot.count_amino_acids())
print(myprot.get_amino_acids_percent())
print(myprot.molecular_weight())
print(myprot.aromaticity())
print(myprot.instability_index())
print(myprot.flexibility())
print(myprot.isoelectric_point())
print(myprot.secondary_structure_fraction())
print(myprot.protein_scale(ProtParamData.kd, 9, .4))
def transform(self, X):
vec = np.zeros((len(X), 1))
for i in range(len(X)):
pa = ProteinAnalysis(str(X[i]))
vec[i, 0] = pa.flexibility()
return vec
