pepdata 1.2.2__py3-none-any.whl

pepdata/__init__.py

@@ -0,0 +1,26 @@
+from .amino_acid_alphabet import (
+    AminoAcid,
+    canonical_amino_acids,
+    canonical_amino_acid_letters,
+    extended_amino_acids,
+    extended_amino_acid_letters,
+    amino_acid_letter_indices,
+    amino_acid_name_indices,
+)
+from .peptide_vectorizer import PeptideVectorizer
+from .version import __version__
+from . import iedb
+
+
+
+__all__ = [
+    "iedb",
+    "AminoAcid",
+    "canonical_amino_acids",
+    "canonical_amino_acid_letters",
+    "extended_amino_acids",
+    "extended_amino_acid_letters",
+    "amino_acid_letter_indices",
+    "amino_acid_name_indices",
+    "PeptideVectorizer",
+]

pepdata/amino_acid.py

@@ -0,0 +1,34 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+class AminoAcid(object):
+    def __init__(
+            self, full_name, short_name, letter, contains=None):
+        self.letter = letter
+        self.full_name = full_name
+        self.short_name = short_name
+        if not contains:
+            contains = [letter]
+        self.contains = contains
+
+    def __str__(self):
+        return (
+            ("AminoAcid(full_name='%s', short_name='%s', letter='%s', "
+             "contains=%s)") % (
+            self.letter, self.full_name, self.short_name, self.contains))
+
+    def __repr__(self):
+        return str(self)
+
+    def __eq__(self, other):
+        return other.__class__ is AminoAcid and self.letter == other.letter

pepdata/amino_acid_alphabet.py

@@ -0,0 +1,158 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+"""
+Quantify amino acids by their physical/chemical properties
+"""
+
+import numpy as np
+
+from .amino_acid import AminoAcid
+
+canonical_amino_acids = [
+    AminoAcid("Alanine", "Ala", "A"),
+    AminoAcid("Arginine", "Arg", "R"),
+    AminoAcid("Asparagine","Asn", "N"),
+    AminoAcid("Aspartic Acid", "Asp", "D"),
+    AminoAcid("Cysteine", "Cys", "C"),
+    AminoAcid("Glutamic Acid", "Glu", "E"),
+    AminoAcid("Glutamine", "Gln", "Q"),
+    AminoAcid("Glycine", "Gly", "G"),
+    AminoAcid("Histidine", "His", "H"),
+    AminoAcid("Isoleucine",  "Ile", "I"),
+    AminoAcid("Leucine", "Leu", "L"),
+    AminoAcid("Lysine", "Lys", "K"),
+    AminoAcid("Methionine",  "Met", "M"),
+    AminoAcid("Phenylalanine", "Phe", "F"),
+    AminoAcid("Proline", "Pro", "P"),
+    AminoAcid("Serine", "Ser", "S"),
+    AminoAcid("Threonine", "Thr", "T"),
+    AminoAcid("Tryptophan", "Trp", "W"),
+    AminoAcid("Tyrosine", "Tyr", "Y"),
+    AminoAcid("Valine", "Val", "V")
+]
+
+canonical_amino_acid_letters = [aa.letter for aa in canonical_amino_acids]
+
+###
+# Post-translation modifications commonly detected by mass-spec
+###
+
+# TODO: figure out three letter codes for modified AAs
+
+modified_amino_acids = [
+    AminoAcid("Phospho-Serine", "Sep", "s"),
+    AminoAcid("Phospho-Threonine", "???", "t"),
+    AminoAcid("Phospho-Tyrosine", "???", "y"),
+    AminoAcid("Cystine", "???", "c"),
+    AminoAcid("Methionine sulfoxide", "???", "m"),
+    AminoAcid("Pyroglutamate", "???", "q"),
+    AminoAcid("Pyroglutamic acid", "???", "n"),
+]
+
+###
+# Amino acid tokens which represent multiple canonical amino acids
+###
+wildcard_amino_acids = [
+    AminoAcid("Unknown", "Xaa", "X", contains=set(canonical_amino_acid_letters)),
+    AminoAcid("Asparagine-or-Aspartic-Acid", "Asx",  "B", contains={"D", "N"}),
+    AminoAcid("Glutamine-or-Glutamic-Acid", "Glx", "Z", contains={"E", "Q"}),
+    AminoAcid("Leucine-or-Isoleucine", "Xle", "J", contains={"I", "L"})
+]
+
+###
+# Canonical amino acids + wilcard tokens
+###
+
+canonical_amino_acids_with_unknown = canonical_amino_acids + wildcard_amino_acids
+
+
+###
+# Rare amino acids which aren't considered part of the core 20 "canonical"
+###
+
+rare_amino_acids = [
+    AminoAcid("Selenocysteine", "Sec", "U"),
+    AminoAcid("Pyrrolysine", "Pyl", "O"),
+]
+
+###
+# Extended amino acids + wildcard tokens
+###
+
+extended_amino_acids = canonical_amino_acids + rare_amino_acids + wildcard_amino_acids
+extended_amino_acid_letters = [
+    aa.letter for aa in extended_amino_acids
+]
+extended_amino_acids_with_unknown_names = [
+    aa.full_name for aa in extended_amino_acids
+]
+
+
+amino_acid_letter_indices = {
+    c: i for (i, c) in
+    enumerate(extended_amino_acid_letters)
+}
+
+
+amino_acid_letter_pairs = [
+    "%s%s" % (x, y)
+    for y in extended_amino_acids
+    for x in extended_amino_acids
+]
+
+
+amino_acid_name_indices = {
+    aa_name: i for (i, aa_name)
+    in enumerate(extended_amino_acids_with_unknown_names)
+}
+
+amino_acid_pair_positions = {
+    pair: i for (i, pair) in enumerate(amino_acid_letter_pairs)
+}
+
+def index_to_full_name(idx):
+    return extended_amino_acids[idx].full_name
+
+def index_to_short_name(idx):
+    return extended_amino_acids[idx].short_name
+
+def index_to_letter(idx):
+    return extended_amino_acids[idx]
+
+def letter_to_index(x):
+    """
+    Convert from an amino acid's letter code to its position index
+    """
+    assert x in amino_acid_letter_indices, "Unknown amino acid: %s" % x
+    return amino_acid_letter_indices[x]
+
+def peptide_to_indices(xs):
+    return [amino_acid_letter_indices[x] for x in xs]
+
+def letter_to_short_name(x):
+    return index_to_short_name(letter_to_index(x))
+
+def peptide_to_short_amino_acid_names(xs):
+    return [amino_acid_letter_indices[x] for x in xs]
+
+def dict_to_amino_acid_matrix(d, alphabet=canonical_amino_acids):
+    n_aa = len(d)
+    result_matrix = np.zeros((n_aa, n_aa), dtype="float32")
+    for i, aa_row in enumerate(alphabet):
+        d_row = d[aa_row.letter]
+        for j, aa_col in enumerate(alphabet):
+            value = d_row[aa_col.letter]
+            result_matrix[i, j] = value
+    return result_matrix
+

pepdata/amino_acid_properties.py

@@ -0,0 +1,357 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .amino_acid_alphabet import letter_to_index
+
+"""
+Quantify amino acids by their physical/chemical properties
+"""
+
+
+def aa_dict_to_positional_list(aa_property_dict):
+    value_list = [None] * 20
+    for letter, value in aa_property_dict.items():
+        idx = letter_to_index(letter)
+        assert idx >= 0
+        assert idx < 20
+        value_list[idx] = value
+    assert all(elt is not None for elt in value_list), \
+        "Missing amino acids in:\n%s" % aa_property_dict.keys()
+    return value_list
+
+def parse_property_table(table_string):
+    value_dict = {}
+    for line in table_string.splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        fields = line.split(" ")
+        fields = [f for f in fields if len(f.strip()) > 0]
+        assert len(fields) >= 2
+        value, letter = fields[:2]
+        assert letter not in value_dict, "Repeated amino acid " + line
+        value_dict[letter] = float(value)
+    return value_dict
+
+
+"""
+Amino acids property tables copied from CRASP website
+"""
+
+hydropathy = parse_property_table("""
+1.80000 A ALA
+-4.5000 R ARG
+-3.5000 N ASN
+-3.5000 D ASP
+2.50000 C CYS
+-3.5000 Q GLN
+-3.5000 E GLU
+-0.4000 G GLY
+-3.2000 H HIS
+4.50000 I ILE
+3.80000 L LEU
+-3.9000 K LYS
+1.90000 M MET
+2.80000 F PHE
+-1.6000 P PRO
+-0.8000 S SER
+-0.7000 T THR
+-0.9000 W TRP
+-1.3000 Y TYR
+4.20000 V VAL
+""")
+
+volume = parse_property_table("""
+91.5000 A ALA
+202.0000 R ARG
+135.2000 N ASN
+124.5000 D ASP
+118.0000 C CYS
+161.1000 Q GLN
+155.1000 E GLU
+66.40000 G GLY
+167.3000 H HIS
+168.8000 I ILE
+167.9000 L LEU
+171.3000 K LYS
+170.8000 M MET
+203.4000 F PHE
+129.3000 P PRO
+99.10000 S SER
+122.1000 T THR
+237.6000 W TRP
+203.6000 Y TYR
+141.7000 V VAL
+""")
+
+polarity = parse_property_table("""
+0.0000 A ALA
+52.000 R ARG
+3.3800 N ASN
+40.700 D ASP
+1.4800 C CYS
+3.5300 Q GLN
+49.910 E GLU
+0.0000 G GLY
+51.600 H HIS
+0.1500 I ILE
+0.4500 L LEU
+49.500 K LYS
+1.4300 M MET
+0.3500 F PHE
+1.5800 P PRO
+1.6700 S SER
+1.6600 T THR
+2.1000 W TRP
+1.6100 Y TYR
+0.1300 V VAL
+""")
+
+pK_side_chain = parse_property_table("""
+0.0000 A ALA
+12.480 R ARG
+0.0000 N ASN
+3.6500 D ASP
+8.1800 C CYS
+0.0000 Q GLN
+4.2500 E GLU
+0.0000 G GLY
+6.0000 H HIS
+0.0000 I ILE
+0.0000 L LEU
+10.530 K LYS
+0.0000 M MET
+0.0000 F PHE
+0.0000 P PRO
+0.0000 S SER
+0.0000 T THR
+0.0000 W TRP
+10.700 Y TYR
+0.0000 V VAL
+""")
+
+prct_exposed_residues = parse_property_table("""
+15.0000 A ALA
+67.0000 R ARG
+49.0000 N ASN
+50.0000 D ASP
+5.00000 C CYS
+56.0000 Q GLN
+55.0000 E GLU
+10.0000 G GLY
+34.0000 H HIS
+13.0000 I ILE
+16.0000 L LEU
+85.0000 K LYS
+20.0000 M MET
+10.0000 F PHE
+45.0000 P PRO
+32.0000 S SER
+32.0000 T THR
+17.0000 W TRP
+41.0000 Y TYR
+14.0000 V VAL
+""")
+
+hydrophilicity = parse_property_table("""
+-0.5000 A ALA
+3.00000 R ARG
+0.20000 N ASN
+3.00000 D ASP
+-1.0000 C CYS
+0.20000 Q GLN
+3.00000 E GLU
+0.00000 G GLY
+-0.5000 H HIS
+-1.8000 I ILE
+-1.8000 L LEU
+3.00000 K LYS
+-1.3000 M MET
+-2.5000 F PHE
+0.00000 P PRO
+0.30000 S SER
+-0.4000 T THR
+-3.4000 W TRP
+-2.3000 Y TYR
+-1.5000 V VAL
+""")
+
+accessible_surface_area = parse_property_table("""
+27.8000 A ALA
+94.7000 R ARG
+60.1000 N ASN
+60.6000 D ASP
+15.5000 C CYS
+68.7000 Q GLN
+68.2000 E GLU
+24.5000 G GLY
+50.7000 H HIS
+22.8000 I ILE
+27.6000 L LEU
+103.000 K LYS
+33.5000 M MET
+25.5000 F PHE
+51.5000 P PRO
+42.0000 S SER
+45.0000 T THR
+34.7000 W TRP
+55.2000 Y TYR
+23.7000 V VAL
+""")
+
+local_flexibility = parse_property_table("""
+705.42000 A ALA
+1484.2800 R ARG
+513.46010 N ASN
+34.960000 D ASP
+2412.5601 C CYS
+1087.8300 Q GLN
+1158.6600 E GLU
+33.180000 G GLY
+1637.1300 H HIS
+5979.3701 I ILE
+4985.7300 L LEU
+699.69000 K LYS
+4491.6602 M MET
+5203.8599 F PHE
+431.96000 P PRO
+174.76000 S SER
+601.88000 T THR
+6374.0698 W TRP
+4291.1001 Y TYR
+4474.4199 V VAL
+""")
+
+accessible_surface_area_folded = parse_property_table("""
+31.5000 A ALA
+93.8000 R ARG
+62.2000 N ASN
+60.9000 D ASP
+13.9000 C CYS
+74.0000 Q GLN
+72.3000 E GLU
+25.2000 G GLY
+46.7000 H HIS
+23.0000 I ILE
+29.0000 L LEU
+110.300 K LYS
+30.5000 M MET
+28.7000 F PHE
+53.7000 P PRO
+44.2000 S SER
+46.0000 T THR
+41.7000 W TRP
+59.1000 Y TYR
+23.5000 V VAL
+""")
+
+refractivity = parse_property_table("""
+4.34000 A ALA
+26.6600 R ARG
+13.2800 N ASN
+12.0000 D ASP
+35.7700 C CYS
+17.5600 Q GLN
+17.2600 E GLU
+0.00000 G GLY
+21.8100 H HIS
+19.0600 I ILE
+18.7800 L LEU
+21.2900 K LYS
+21.6400 M MET
+29.4000 F PHE
+10.9300 P PRO
+6.35000 S SER
+11.0100 T THR
+42.5300 W TRP
+31.5300 Y TYR
+13.9200 V VAL
+""")
+
+
+mass = parse_property_table("""
+70.079 A ALA
+156.188 R ARG
+114.104 N ASN
+115.089 D ASP
+103.144 C CYS
+128.131 Q GLN
+129.116 E GLU
+57.052 G GLY
+137.142 H HIS
+113.160 I ILE
+113.160 L LEU
+128.174 K LYS
+131.198 M MET
+147.177 F PHE
+97.177 P PRO
+87.078 S SER
+101.105 T THR
+186.213 W TRP
+163.170 Y TYR
+99.133 V VAL
+""")
+
+###
+# Values copied from:
+# "Solvent accessibility of AA in known protein structures"
+# http://prowl.rockefeller.edu/aainfo/access.htm
+###
+"""
+Solvent accessibility of AA in known protein structures
+
+Figure 1.
+
+S   0.70    0.20    0.10
+T   0.71    0.16    0.13
+A   0.48    0.35    0.17
+G   0.51    0.36    0.13
+P   0.78    0.13    0.09
+C   0.32    0.54    0.14
+D   0.81    0.09    0.10
+E   0.93    0.04    0.03
+Q   0.81    0.10    0.09
+N   0.82    0.10    0.08
+L   0.41    0.49    0.10
+I   0.39    0.47    0.14
+V   0.40    0.50    0.10
+M   0.44    0.20    0.36
+F   0.42    0.42    0.16
+Y   0.67    0.20    0.13
+W   0.49    0.44    0.07
+K   0.93    0.02    0.05
+R   0.84    0.05    0.11
+H   0.66    0.19    0.15
+"""
+
+solvent_exposed_area = dict(
+    S=0.70,
+    T=0.71,
+    A=0.48,
+    G=0.51,
+    P=0.78,
+    C=0.32,
+    D=0.81,
+    E=0.93,
+    Q=0.81,
+    N=0.82,
+    L=0.41,
+    I=0.39,
+    V=0.40,
+    M=0.44,
+    F=0.42,
+    Y=0.67,
+    W=0.49,
+    K=0.93,
+    R=0.84,
+    H=0.66,
+)

pepdata/blosum.py

@@ -0,0 +1,73 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from os.path import join
+
+from .static_data import MATRIX_DIR
+
+from .amino_acid_alphabet import dict_to_amino_acid_matrix
+
+def parse_blosum_table(table, coeff_type=int, key_type='row'):
+    """
+    Parse a table of pairwise amino acid coefficient (e.g. BLOSUM50)
+    """
+
+    lines = table.split("\n")
+    # drop comments
+    lines = [line for line in lines if not line.startswith("#")]
+    # drop CR endline characters
+    lines = [line.replace("\r", "") for line in lines]
+    # skip empty lines
+    lines = [line for line in lines if line]
+
+    labels = lines[0].split()
+
+    if len(labels) < 20:
+        raise ValueError(
+            "Expected 20+ amino acids but first line '%s' has %d fields" % (
+                lines[0],
+                len(labels)))
+    coeffs = {}
+    for line in lines[1:]:
+
+        fields = line.split()
+        assert len(fields) >= 21, \
+            "Expected AA and 20+ coefficients but '%s' has %d fields" % (
+                line, len(fields))
+        x = fields[0]
+        for i, coeff_str in enumerate(fields[1:]):
+            y = labels[i]
+            coeff = coeff_type(coeff_str)
+            if key_type == 'pair':
+                coeffs[(x, y)] = coeff
+            elif key_type == 'pair_string':
+                coeffs[x + y] = coeff
+            else:
+                assert key_type == 'row', "Unknown key type: %s" % key_type
+                if x not in coeffs:
+                    coeffs[x] = {}
+                coeffs[x][y] = coeff
+    return coeffs
+
+
+with open(join(MATRIX_DIR, 'BLOSUM30'), 'r') as f:
+    blosum30_dict = parse_blosum_table(f.read())
+    blosum30_matrix = dict_to_amino_acid_matrix(blosum30_dict)
+
+with open(join(MATRIX_DIR, 'BLOSUM50'), 'r') as f:
+    blosum50_dict = parse_blosum_table(f.read())
+    blosum50_matrix = dict_to_amino_acid_matrix(blosum50_dict)
+
+with open(join(MATRIX_DIR, 'BLOSUM62'), 'r') as f:
+    blosum62_dict = parse_blosum_table(f.read())
+    blosum62_matrix = dict_to_amino_acid_matrix(blosum62_dict)
+