Upload data/dataset_Hydrophilic.csv with huggingface_hub

data/dataset_Hydrophilic.csv

@@ -0,0 +1,2177 @@
+"keyword","repo_name","file_path","file_extension","file_size","line_count","content","language"
+"Hydrophilic","openvax/pepdata","setup.py",".py","2574","77","# Copyright (c) 2014-2018. Mount Sinai School of Medicine
+#
+# 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 __future__ import print_function, division, absolute_import
+import os
+import re
+
+from setuptools import setup, find_packages
+
+readme_dir = os.path.dirname(__file__)
+readme_path = os.path.join(readme_dir, 'README.md')
+
+try:
+    with open(readme_path, 'r') as f:
+        readme_markdown = f.read()
+except:
+    print(""Failed to load README file"")
+    readme_markdown = """"
+
+try:
+    import pypandoc
+    readme_restructured = pypandoc.convert(readme_markdown, to='rst', format='md')
+except:
+    readme_restructured = readme_markdown
+    print(""Conversion of long_description from markdown to reStructuredText failed, skipping..."")
+
+with open('pepdata/__init__.py', 'r') as f:
+    version = re.search(
+        r'^__version__\s*=\s*[\'""]([^\'""]*)[\'""]',
+        f.read(),
+        re.MULTILINE).group(1)
+
+if __name__ == '__main__':
+    setup(
+        name='pepdata',
+        version=version,
+        description=""Immunological peptide datasets and amino acid properties"",
+        author=""Alex Rubinsteyn"",
+        author_email=""alex.rubinsteyn@mssm.edu"",
+        url=""https://github.com/openvax/pepdata"",
+        license=""http://www.apache.org/licenses/LICENSE-2.0.html"",
+        classifiers=[
+            'Development Status :: 3 - Alpha',
+            'Environment :: Console',
+            'Operating System :: OS Independent',
+            'Intended Audience :: Science/Research',
+            'License :: OSI Approved :: Apache Software License',
+            'Programming Language :: Python',
+            'Topic :: Scientific/Engineering :: Bio-Informatics',
+        ],
+        install_requires=[
+            'numpy>=1.7',
+            'scipy>=0.9',
+            'pandas>=0.17',
+            'scikit-learn>=0.14.1',
+            'progressbar33',
+            'biopython>=1.65',
+            'datacache>=0.4.4',
+            'lxml',
+        ],
+        long_description=readme_restructured,
+        packages=find_packages(exclude=""test""),
+        include_package_data=True
+    )
+","Python"
+"Hydrophilic","openvax/pepdata","deploy.sh",".sh","273","10","./lint.sh && \
+./test.sh && \
+python3 -m pip install --upgrade build && \
+python3 -m pip install --upgrade twine && \
+rm -rf dist && \
+python3 -m build && \
+git --version && \
+python3 -m twine upload dist/* && \
+git tag ""$(python3 pepdata/version.py)"" &&  \
+git push --tags","Shell"
+"Hydrophilic","openvax/pepdata","develop.sh",".sh","25","4","set -e
+
+pip install -e .
+","Shell"
+"Hydrophilic","openvax/pepdata","lint.sh",".sh","154","10","#!/bin/bash
+set -o errexit
+
+find pepdata test -name '*.py' \
+  | xargs pylint \
+  --errors-only \
+  --disable=print-statement
+
+echo 'Passes pylint check'
+","Shell"
+"Hydrophilic","openvax/pepdata","test.sh",".sh","56","4","pytest --cov=pepdata/ --cov-report=term-missing tests
+
+
+","Shell"
+"Hydrophilic","openvax/pepdata","pepdata/common.py",".py","967","28","# Copyright (c) 2014-2016. Mount Sinai School of Medicine
+#
+# 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 __future__ import print_function, division, absolute_import
+
+import numpy as np
+
+def transform_peptide(peptide, property_dict):
+    return np.array([property_dict[amino_acid] for amino_acid in peptide])
+
+def transform_peptides(peptides, property_dict):
+    return np.array([
+        [property_dict[aa] for aa in peptide]
+        for peptide in peptides])
+
+","Python"
+"Hydrophilic","openvax/pepdata","pepdata/static_data.py",".py","741","19","# 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 __future__ import print_function, division, absolute_import
+from os.path import dirname, realpath, join
+
+PACKAGE_DIR = dirname(realpath(__file__))
+MATRIX_DIR = join(PACKAGE_DIR, 'matrices')
+","Python"
+"Hydrophilic","openvax/pepdata","pepdata/version.py",".py","121","8","__version__ = ""1.2.0""
+
+
+def print_version():
+    print(f""v{__version__}"")
+
+if __name__ == ""__main__"":
+    print_version()","Python"
+"Hydrophilic","openvax/pepdata","pepdata/__init__.py",".py","597","27","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"",
+]
+","Python"
+"Hydrophilic","openvax/pepdata","pepdata/amino_acid.py",".py","1287","37","# 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 __future__ import print_function, division, absolute_import
+
+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
+","Python"
+"Hydrophilic","openvax/pepdata","pepdata/amino_acid_alphabet.py",".py","4682","161","# 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
+""""""
+
+from __future__ import print_function, division, absolute_import
+
+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
+
+","Python"
+"Hydrophilic","openvax/pepdata","pepdata/amino_acid_properties.py",".py","6268","360","# 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 __future__ import print_function, division, absolute_import
+
+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,
+)
+","Python"
+"Hydrophilic","openvax/pepdata","pepdata/reduced_alphabet.py",".py","1784","58","# Copyright (c) 2014-2018. Mount Sinai School of Medicine
+#
+# 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.
+
+""""""
+Amino acid groupings from
+'Reduced amino acid alphabets improve the sensitivity...' by
+Peterson, Kondev, et al.
+http://www.rpgroup.caltech.edu/publications/Peterson2008.pdf
+""""""
+from __future__ import print_function, division, absolute_import
+
+def dict_from_list(groups):
+    aa_to_group = {}
+    for i, group in enumerate(groups):
+        for c in group:
+            aa_to_group[c] = group[0]
+    return aa_to_group
+
+gbmr4 = dict_from_list([""ADKERNTSQ"", ""YFLIVMCWH"", ""G"", ""P""])
+
+sdm12 = dict_from_list([
+    ""A"", ""D"", ""KER"", ""N"", ""TSQ"", ""YF"", ""LIVM"", ""C"", ""W"", ""H"", ""G"", ""P""
+])
+
+hsdm17 = dict_from_list([
+    ""A"", ""D"", ""KE"", ""R"", ""N"", ""T"", ""S"", ""Q"", ""Y"",
+    ""F"", ""LIV"", ""M"", ""C"", ""W"", ""H"", ""G"", ""P""
+])
+
+""""""
+Other alphabets from
+http://bio.math-inf.uni-greifswald.de/viscose/html/alphabets.html
+""""""
+
+# hydrophilic vs. hydrophobic
+hp2 = dict_from_list([""AGTSNQDEHRKP"", ""CMFILVWY""])
+
+murphy10 = dict_from_list([
+    ""LVIM"", ""C"", ""A"", ""G"", ""ST"", ""P"", ""FYW"", ""EDNQ"", ""KR"", ""H""
+])
+
+alex6 = dict_from_list([""C"", ""G"", ""P"", ""FYW"", ""AVILM"", ""STNQRHKDE""])
+
+aromatic2 = dict_from_list([""FHWY"", ""ADKERNTSQLIVMCGP""])
+
+hp_vs_aromatic = dict_from_list([""H"", ""CMILV"", ""FWY"", ""ADKERNTSQGP""])
+","Python"
+"Hydrophilic","openvax/pepdata","pepdata/peptide_vectorizer.py",".py","2942","84","# Copyright (c) 2014-2016. Mount Sinai School of Medicine
+#
+# 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 __future__ import print_function, division, absolute_import
+
+import numpy as np
+from sklearn.feature_extraction.text import CountVectorizer
+from sklearn.preprocessing import normalize
+
+def make_count_vectorizer(reduced_alphabet, max_ngram):
+    if reduced_alphabet is None:
+        preprocessor = None
+    else:
+        preprocessor = lambda s: """".join([reduced_alphabet[si] for si in s])
+
+    return CountVectorizer(
+        analyzer='char',
+        ngram_range=(1, max_ngram),
+        dtype=np.float,
+        preprocessor=preprocessor)
+
+class PeptideVectorizer(object):
+    """"""
+    Make n-gram frequency vectors from peptide sequences
+    """"""
+    def __init__(
+            self,
+            max_ngram=1,
+            normalize_row=True,
+            reduced_alphabet=None,
+            training_already_reduced=False):
+        self.reduced_alphabet = reduced_alphabet
+        self.max_ngram = max_ngram
+        self.normalize_row = normalize_row
+        self.training_already_reduced = training_already_reduced
+        self.count_vectorizer = None
+
+    def __getstate__(self):
+        return {
+            'reduced_alphabet': self.reduced_alphabet,
+            'count_vectorizer': self.count_vectorizer,
+            'training_already_reduced': self.training_already_reduced,
+            'normalize_row': self.normalize_row,
+            'max_ngram': self.max_ngram,
+        }
+
+    def fit_transform(self, amino_acid_strings):
+        self.count_vectorizer = \
+            make_count_vectorizer(self.reduced_alphabet, self.max_ngram)
+
+        if self.training_already_reduced:
+            c = make_count_vectorizer(None, self.max_ngram)
+            X = c.fit_transform(amino_acid_strings).todense()
+            self.count_vectorizer.vocabulary_ = c.vocabulary_
+        else:
+            c = self.count_vectorizer
+            X = c.fit_transform(amino_acid_strings).todense()
+
+        if self.normalize_row:
+            X = normalize(X, norm='l1')
+        return X
+
+    def fit(self, amino_acid_strings):
+        self.fit_transform(amino_acid_strings)
+
+    def transform(self, amino_acid_strings):
+        assert self.count_vectorizer, ""Must call 'fit' before 'transform'""
+        X = self.count_vectorizer.transform(amino_acid_strings).todense()
+        if self.normalize_row:
+            X = normalize(X, norm='l1')
+        return X
+","Python"
+"Hydrophilic","openvax/pepdata","pepdata/chou_fasman.py",".py","3279","75","# 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 __future__ import print_function, division, absolute_import
+
+from .amino_acid_alphabet import amino_acid_name_indices
+
+# Chou-Fasman of structural properties from
+# http://prowl.rockefeller.edu/aainfo/chou.htm
+chou_fasman_table = """"""
+Alanine        142     83       66      0.06    0.076   0.035   0.058
+Arginine        98     93       95      0.070   0.106   0.099   0.085
+Aspartic Acid  101     54      146      0.147   0.110   0.179   0.081
+Asparagine      67     89      156      0.161   0.083   0.191   0.091
+Cysteine        70    119      119      0.149   0.050   0.117   0.128
+Glutamic Acid  151    037       74      0.056   0.060   0.077   0.064
+Glutamine      111    110       98      0.074   0.098   0.037   0.098
+Glycine         57     75      156      0.102   0.085   0.190   0.152
+Histidine      100     87       95      0.140   0.047   0.093   0.054
+Isoleucine     108    160       47      0.043   0.034   0.013   0.056
+Leucine        121    130       59      0.061   0.025   0.036   0.070
+Lysine         114     74      101      0.055   0.115   0.072   0.095
+Methionine     145    105       60      0.068   0.082   0.014   0.055
+Phenylalanine  113    138       60      0.059   0.041   0.065   0.065
+Proline         57     55      152      0.102   0.301   0.034   0.068
+Serine          77     75      143      0.120   0.139   0.125   0.106
+Threonine       83    119       96      0.086   0.108   0.065   0.079
+Tryptophan     108    137       96      0.077   0.013   0.064   0.167
+Tyrosine        69    147      114      0.082   0.065   0.114   0.125
+Valine         106    170       50      0.062   0.048   0.028   0.053
+""""""
+
+
+def parse_chou_fasman(table):
+    alpha_helix_score_dict = {}
+    beta_sheet_score_dict = {}
+    turn_score_dict = {}
+
+    for line in table.split(""\n""):
+        fields = [field for field in line.split("" "") if len(field.strip()) > 0]
+        if len(fields) == 0:
+            continue
+
+        if fields[1] == 'Acid':
+            name = fields[0] + "" "" + fields[1]
+            fields = fields[1:]
+        else:
+            name = fields[0]
+
+        assert name in amino_acid_name_indices, ""Invalid amino acid name %s"" % name
+        letter = amino_acid_name_indices[name]
+        alpha = int(fields[1])
+        beta = int(fields[2])
+        turn = int(fields[3])
+        alpha_helix_score_dict[letter] = alpha
+        beta_sheet_score_dict[letter] = beta
+        turn_score_dict[letter] = turn
+
+    assert len(alpha_helix_score_dict) == 20
+    assert len(beta_sheet_score_dict) == 20
+    assert len(turn_score_dict) == 20
+    return alpha_helix_score_dict, beta_sheet_score_dict, turn_score_dict
+
+alpha_helix_score, beta_sheet_score, turn_score = \
+    parse_chou_fasman(chou_fasman_table)
+","Python"
+"Hydrophilic","openvax/pepdata","pepdata/pmbec.py",".py","3019","89","# Copyright (c) 2014-2016. Mount Sinai School of Medicine
+#
+# 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 __future__ import print_function, division, absolute_import
+from os.path import join
+
+from .static_data import MATRIX_DIR
+
+from .amino_acid_alphabet import dict_to_amino_acid_matrix
+
+def read_pmbec_coefficients(
+        key_type='row',
+        verbose=True,
+        filename=join(MATRIX_DIR, 'pmbec.mat')):
+    """"""
+    Parameters
+    ------------
+
+    filename : str
+        Location of PMBEC coefficient matrix
+
+    key_type : str
+        'row' : every key is a single amino acid,
+           which maps to a dictionary for that row
+        'pair' : every key is a tuple of amino acids
+        'pair_string' : every key is a string of two amino acid characters
+
+    verbose : bool
+        Print rows of matrix as we read them
+    """"""
+    d = {}
+    if key_type == 'row':
+        def add_pair(row_letter, col_letter, value):
+            if row_letter not in d:
+                d[row_letter] = {}
+            d[row_letter][col_letter] = value
+    elif key_type == 'pair':
+        def add_pair(row_letter, col_letter, value):
+            d[(row_letter, col_letter)] = value
+
+    else:
+        assert key_type == 'pair_string', \
+            ""Invalid dictionary key type: %s"" % key_type
+
+        def add_pair(row_letter, col_letter, value):
+            d[""%s%s"" % (row_letter, col_letter)] = value
+
+    with open(filename, 'r') as f:
+        lines = [line for line in f.read().split('\n') if len(line) > 0]
+        header = lines[0]
+        if verbose:
+            print(header)
+        residues = [
+            x for x in header.split()
+            if len(x) == 1 and x != ' ' and x != '\t'
+        ]
+        assert len(residues) == 20
+        if verbose:
+            print(residues)
+        for line in lines[1:]:
+            cols = [
+                x
+                for x in line.split(' ')
+                if len(x) > 0 and x != ' ' and x != '\t'
+            ]
+            assert len(cols) == 21, ""Expected 20 values + letter, got %s"" % cols
+            row_letter = cols[0]
+            for i, col in enumerate(cols[1:]):
+                col_letter = residues[i]
+                assert col_letter != ' ' and col_letter != '\t'
+                value = float(col)
+                add_pair(row_letter, col_letter, value)
+    return d
+
+# dictionary of PMBEC coefficient accessed like pmbec_dict[""V""][""R""]
+pmbec_dict = read_pmbec_coefficients(key_type=""row"")
+pmbec_matrix = dict_to_amino_acid_matrix(pmbec_dict)
+","Python"
+"Hydrophilic","openvax/pepdata","pepdata/residue_contact_energies.py",".py","2937","77","# 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 __future__ import print_function, division, absolute_import
+
+from os.path import join
+
+from .amino_acid_alphabet import canonical_amino_acid_letters, dict_to_amino_acid_matrix
+from .static_data import MATRIX_DIR
+
+
+def parse_interaction_table(table, amino_acid_order=""ARNDCQEGHILKMFPSTWYV""):
+    table = table.strip()
+    while ""  "" in table:
+        table = table.replace(""  "", "" "")
+
+    lines = [l.strip() for l in table.split(""\n"")]
+    lines = [l for l in lines if len(l) > 0 and not l.startswith(""#"")]
+    assert len(lines) == 20, ""Malformed amino acid interaction table""
+    d = {}
+    for i, line in enumerate(lines):
+        coeff_strings = line.split("" "")
+        assert len(coeff_strings) == 20, \
+            ""Malformed row in amino acid interaction table""
+        x = amino_acid_order[i]
+        d[x] = {}
+        for j, coeff_str in enumerate(coeff_strings):
+            value = float(coeff_str)
+            y = amino_acid_order[j]
+            d[x][y] = value
+    return d
+
+def transpose_interaction_dict(d):
+    transposed = {}
+    for x in canonical_amino_acid_letters:
+        transposed[x] = {}
+        for y in canonical_amino_acid_letters:
+            transposed[x][y] = d[y][x]
+    return transposed
+
+
+with open(join(MATRIX_DIR, 'strand_vs_coil.txt'), 'r') as f:
+    # Strand vs. Coil
+    strand_vs_coil_dict = parse_interaction_table(f.read())
+    strand_vs_coil_array = dict_to_amino_acid_matrix(strand_vs_coil_dict)
+
+    # Coil vs. Strand
+    coil_vs_strand_dict = transpose_interaction_dict(strand_vs_coil_dict)
+    coil_vs_strand_array = dict_to_amino_acid_matrix(coil_vs_strand_dict)
+
+with open(join(MATRIX_DIR, 'helix_vs_strand.txt'), 'r') as f:
+    # Helix vs. Strand
+    helix_vs_strand_dict = parse_interaction_table(f.read())
+    helix_vs_strand_array = dict_to_amino_acid_matrix(helix_vs_strand_dict)
+
+    # Strand vs. Helix
+    strand_vs_helix_dict = transpose_interaction_dict(helix_vs_strand_dict)
+    strand_vs_helix_array = dict_to_amino_acid_matrix(strand_vs_helix_dict)
+
+with open(join(MATRIX_DIR, 'helix_vs_coil.txt'), 'r') as f:
+    # Helix vs. Coil
+    helix_vs_coil_dict = parse_interaction_table(f.read())
+    helix_vs_coil_array = dict_to_amino_acid_matrix(helix_vs_coil_dict)
+
+    # Coil vs. Helix
+    coil_vs_helix_dict = transpose_interaction_dict(helix_vs_coil_dict)
+    coil_vs_helix_array = dict_to_amino_acid_matrix(coil_vs_helix_dict)
+","Python"
+"Hydrophilic","openvax/pepdata","pepdata/blosum.py",".py","2600","76","# 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 __future__ import print_function, division, absolute_import
+
+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)
+
+","Python"
+"Hydrophilic","openvax/pepdata","pepdata/matrices/__init__.py",".py","0","0","","Python"
+"Hydrophilic","openvax/pepdata","pepdata/iedb/columns.py",".py","6767","177","# 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 __future__ import annotations
+
+
+import pandas as pd
+
+def find(df : pd.DataFrame, group_candidates : list[str], column_candidates : list[str]) -> pd.Series | None: 
+    """"""
+    Try to find a column that contains a combination of the two candidate lists. 
+
+    Motivation: format for MHC ligand CSV used to have:
+        epitope_key = (""Epitope"", ""Description"")
+        mhc_allele_key = (""MHC"", ""Allele Name"")
+        mhc_class_key = (""MHC"", ""MHC allele class"")
+        mhc_assay_key = (""Assay"", ""Method/Technique"")
+
+    Now it's:
+        epitope_key = (""Epitope"", ""Name"")
+        mhc_allele_key = (""MHC Restriction"", ""Name"")
+        mhc_class_key = (""MHC Restriction"", ""Class"")
+        mhc_assay_key = (""Assay"", ""Method"")
+
+    ...who knows what it will be next!
+    """"""
+    group_candidates = [s.lower() for s in group_candidates]
+    column_candidates = [s.lower() for s in column_candidates]
+
+    possible_matches = []
+    for a in group_candidates:
+        for b in column_candidates:
+            for pair in df.columns:
+                assert type(pair) is tuple and len(pair) == 2
+                group, col = pair
+                if a in group.lower() and b in col.lower():
+                    possible_matches.append(pair)
+    
+    if len(possible_matches) == 0:
+        return None
+    # get the shortest matches
+    
+
+
+MHC_GROUP_CANDIDATES : list[str] = [""MHC"", ""MHC Restriction""]
+EPITOPE_GROUP_CANDIDATES : list[str] = [""Epitope""] 
+ASSAY_GROUP_CANDIDATES : list[str] = [""Assay""]
+HOST_GROUP_CANDIDATES : list[str] = [""Host""]
+
+def get_mhc_allele(
+        df : pd.DataFrame, 
+        group_candidates : list[str] = MHC_GROUP_CANDIDATES,
+        column_candidates : list[str] = [""Allele"", ""Allele name"", ""Name""]) -> pd.Series | None:
+    return find(df, group_candidates, column_candidates)
+
+
+def get_mhc_class(
+        df : pd.DataFrame, 
+        group_candidates : list[str] = MHC_GROUP_CANDIDATES, 
+        column_candidates : list[str] =[""Class"", ""MHC allele class""]) -> pd.Series | None:
+    return find(df, group_candidates, column_candidates)
+
+
+def get_mhc_assay(
+        df : pd.Series, 
+        group_candidates : list[str] = ASSAY_GROUP_CANDIDATES, 
+        column_candidates : list[str] =[""method""]) -> pd.Series | None:
+    return find(df, group_candidates, column_candidates)
+
+
+def get_epitope_name(
+        df : pd.DataFrame, 
+        group_candidates : list[str] = EPITOPE_GROUP_CANDIDATES, 
+        column_candidates : list[str] =[""name""]) -> pd.Series | None:
+    return find(df, group_candidates, column_candidates)
+
+
+def get_epitope_type(
+        df : pd.DataFrame, 
+        group_candidates : list[str] = EPITOPE_GROUP_CANDIDATES, 
+        column_candidates : list[str] =[""Object Type"", ""Type""]) -> pd.Series | None:
+    return find(df, group_candidates, column_candidates)
+
+def get_epitope_modifications(
+         df : pd.DataFrame,
+        group_candidates : list[str] = EPITOPE_GROUP_CANDIDATES,
+        column_candidates : list[str]  = [""Modified Residue(s)""]) -> pd.Series | None:
+    return find(df, group_candidates, column_candidates)
+
+
+def get_epitope_IRI(
+        df : pd.DataFrame,
+        group_candidates : list[str] = EPITOPE_GROUP_CANDIDATES, 
+        column_candidates : list[str] =[""Epitope IRI""]) -> pd.Series | None:
+    return find(df, group_candidates, column_candidates)
+
+
+def get_epitope_source_molecule(
+        df : pd.DataFrame, 
+        group_candidates : list[str] = EPITOPE_GROUP_CANDIDATES, 
+        column_candidates=[""Source Molecule""]) -> pd.Series | None:
+    return find(df, group_candidates, column_candidates)
+
+def get_epitope_source_molecule_iri(
+        df : pd.DataFrame, 
+        group_candidates : list[str] = EPITOPE_GROUP_CANDIDATES, 
+        column_candidates : list[str] = [""Source Molecule IRI""]) -> pd.Series | None:
+    return find(df, group_candidates, column_candidates)
+
+
+def get_epitope_source_organism(
+        df : pd.DataFrame, 
+        group_candidates : list[str] = EPITOPE_GROUP_CANDIDATES, 
+        column_candidates : list[str] = [""Source Organism""]) -> pd.Series | None:
+    return find(df, group_candidates, column_candidates)
+
+
+def get_epitope_source_organism_iri(
+        df : pd.DataFrame, 
+        group_candidates : list[str] = EPITOPE_GROUP_CANDIDATES, 
+        column_candidates : list[str] = [""Source Organism IRI""]) -> pd.Series | None:
+    return find(df, group_candidates, column_candidates)
+
+def get_assay_method(
+        df : pd.DataFrame, 
+        group_candidates : list[str] = ASSAY_GROUP_CANDIDATES, 
+        column_candidates : list[str] = [""Method"", ""Method/Technique""]) -> pd.Series | None:
+    return find(df, group_candidates, column_candidates)
+
+def get_assay_response_measured(
+        df : pd.DataFrame, 
+        group_candidates : list[str] = ASSAY_GROUP_CANDIDATES, 
+        column_candidates : list[str] = [""Response measured""]) -> pd.Series | None:
+    return find(df, group_candidates, column_candidates)
+
+
+def get_assay_units(
+        df : pd.DataFrame, 
+        group_candidates : list[str] = ASSAY_GROUP_CANDIDATES, 
+        column_candidates : list[str] = [""Units""]) -> pd.Series | None:
+    return find(df, group_candidates, column_candidates)
+
+
+def get_assay_qualitative(
+        df : pd.DataFrame, 
+        group_candidates : list[str] = ASSAY_GROUP_CANDIDATES, 
+        column_candidates : list[str] = [""Qualitative Measurement""]) -> pd.Series | None:
+    return find(df, group_candidates, column_candidates)
+
+def get_assay_num_tested(
+        df : pd.DataFrame, 
+        group_candidates : list[str] = ASSAY_GROUP_CANDIDATES, 
+        column_candidates : list[str] = [""Number of Subjects Tested""]) -> pd.Series | None:
+    return find(df, group_candidates, column_candidates)
+
+def get_assay_num_responded(
+        df : pd.DataFrame, 
+        group_candidates : list[str] = ASSAY_GROUP_CANDIDATES, 
+        column_candidates : list[str] = [""Number of Subjects Responded""]) -> pd.Series | None:
+    return find(df, group_candidates, column_candidates)
+
+
+def get_host_name(
+        df : pd.DataFrame, 
+        group_candidates : list[str] = HOST_GROUP_CANDIDATES, 
+        column_candidates : list[str] = [""Name""]) -> pd.Series | None:
+    return find(df, group_candidates, column_candidates)
+","Python"
+"Hydrophilic","openvax/pepdata","pepdata/iedb/mhc.py",".py","5123","165","# 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 __future__ import print_function, division, absolute_import
+import logging
+import os
+
+import pandas as pd
+
+from .memoize import  memoize
+from .common import bad_amino_acids, cache
+
+
+MHC_URL = ""https://www.iedb.org/downloader.php?file_name=doc/mhc_ligand_full_single_file.zip""
+MHC_LOCAL_FILENAME = ""mhc_ligand_full.csv""
+MHC_DECOMPRESS = True
+
+def download(force=False):
+    return cache.fetch(
+        filename=MHC_LOCAL_FILENAME,
+        url=MHC_URL,
+        decompress=MHC_DECOMPRESS,
+        force=force)
+
+def local_path(auto_download=True):
+    path = cache.local_path(
+        filename=MHC_LOCAL_FILENAME,
+        url=MHC_URL,
+        decompress=MHC_DECOMPRESS)
+    if not os.path.exists(path):
+        if auto_download:
+            return download()
+        raise ValueError(
+            (""MHC data file %s does not exist locally,""
+             "" call pepdata.mhc.download() to get a copy from IEDB"") % path)
+    return path
+
+def delete():
+    os.remove(local_path())
+
+@memoize
+def load_dataframe(
+        mhc_class : int | None = None,  # 1, 2, or None for neither
+        hla : str | None = None,
+        exclude_hla : str | None = None,
+        human_only : bool  = False,
+        peptide_length : int | None = None,
+        assay_method : str | None = None,
+        only_standard_amino_acids : bool = True,
+        warn_bad_lines : bool  = True,
+        nrows : int | None = None):
+    """"""
+    Load IEDB MHC data without aggregating multiple entries for the same epitope
+
+    Parameters
+    ----------
+    mhc_class 
+        Restrict to MHC Class I or Class II (or None for neither)
+
+    hla 
+        Restrict results to specific HLA type used in assay (regex pattern)
+
+    exclude_hla 
+        Regex pattern to exclude certain HLA types
+
+    human_only
+        Restrict to human samples (default False)
+
+    peptide_length
+        Restrict epitopes to amino acid strings of given length
+
+    assay_method 
+        Limit to assay methods which contain the given string
+
+    only_standard_amino_acids
+        Drop sequences which use non-standard amino acids, anything outside
+        the core 20, such as X or U (default = True)
+
+    warn_bad_lines 
+        The full MHC ligand dataset seems to contain several dozen lines with
+        too many fields. This currently results in a lot of warning messages
+        from Pandas, which you can turn off with this option (default = True)
+
+    nrows
+        Don't load the full IEDB dataset but instead read only the first nrows
+    """"""
+    df = pd.read_csv(
+            local_path(),
+            header=[0, 1],
+            skipinitialspace=True,
+            nrows=nrows,
+            low_memory=False,
+            on_bad_lines='warn' if warn_bad_lines else 'skip',
+            encoding=""latin-1"")
+
+    # Sometimes the IEDB seems to put in an extra comma in the
+    # header line, which creates an unnamed column of NaNs.
+    # To deal with this, drop any columns which are all NaN
+    df = df.dropna(axis=1, how=""all"")
+
+    print(df.head())
+
+    n = len(df)
+
+    mhc_group_key = ""MHC Restriction""
+    epitope_group_key = ""Epitope""
+    epitope_column_key = (epitope_group_key, ""Name"")
+
+    mhc_allele_column_key = (mhc_group_key, ""Name"")
+
+    epitopes = df[epitope_column_key] = df[epitope_column_key].str.upper()
+
+    null_epitope_seq = epitopes.isnull()
+    n_null = null_epitope_seq.sum()
+    if n_null > 0:
+        logging.info(""Dropping %d null sequences"", n_null)
+
+    mask = ~null_epitope_seq
+
+    if only_standard_amino_acids:
+        # if have rare or unknown amino acids, drop the sequence
+        bad_epitope_seq = \
+            epitopes.str.contains(bad_amino_acids, na=False).astype(""bool"")
+        n_bad = bad_epitope_seq.sum()
+        if n_bad > 0:
+            logging.info(""Dropping %d bad sequences"", n_bad)
+
+        mask &= ~bad_epitope_seq
+
+    if human_only:
+        mask &= df[mhc_allele_column_key].str.startswith(""HLA"").astype(""bool"")
+
+    if mhc_class == 1:
+        mask &= df[mhc_group_key][""Class""] == ""I""
+    elif mhc_class == 2:
+        mask &= df[mhc_group_key][""Class""] == ""II""
+
+    if hla:
+        mask &= df[mhc_allele_column_key].str.contains(hla, na=False)
+
+    if exclude_hla:
+        mask &= ~(df[mhc_allele_column_key].str.contains(exclude_hla, na=False))
+
+    if assay_method:
+        mask &= df[""Assay""][""Method""].str.contains(assay_method)
+
+    if peptide_length:
+        assert peptide_length > 0
+        mask &= df[epitope_column_key].str.len() == peptide_length
+
+    df = df[mask].copy()
+
+    logging.info(""Returning %d / %d entries after filtering"", len(df), n)
+
+    return df
+","Python"
+"Hydrophilic","openvax/pepdata","pepdata/iedb/alleles.py",".py","3257","104","# 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 __future__ import print_function, division, absolute_import
+from collections import namedtuple
+import os
+import xml
+
+from .common import cache
+from .memoize import memoize
+
+ALLELE_XML_FILENAME = ""MhcAlleleNames.xml""
+ALLELE_XML_URL = ""http://www.iedb.org/doc/MhcAlleleNameList.zip""
+ALLELE_XML_DECOMPRESS = True
+
+def local_path(force_download=False):
+    """"""Downloads allele database from IEDB, returns local path to XML file.""""""
+    return cache.fetch(
+        filename=ALLELE_XML_FILENAME,
+        url=ALLELE_XML_URL,
+        decompress=ALLELE_XML_DECOMPRESS,
+        force=force_download)
+
+def delete():
+    """"""Deletes local XML file""""""
+    path = cache.local_path(
+        filename=ALLELE_XML_FILENAME,
+        url=ALLELE_XML_URL,
+        decompress=ALLELE_XML_DECOMPRESS)
+    os.remove(path)
+
+Allele = namedtuple(""Allele"", [
+    ""name"",
+    ""mhc_class"",
+    ""locus"",
+    ""organism"",
+    ""synonyms""
+])
+
+@memoize
+def load_alleles():
+    """"""Parses the IEDB MhcAlleleName XML file and returns a list of Allele
+    namedtuple objects containing information about that each allele's HLA
+    class and source organism.
+    """"""
+    result = []
+    path = local_path()
+    etree = xml.etree.ElementTree.parse(path)
+    for allele in etree.iterfind(""MhcAlleleName""):
+        name_element = allele.find(""DisplayedRestriction"")
+        mhc_class_element = allele.find(""Class"")
+        # need at least a name and an HLA class
+        if name_element is None or mhc_class_element is None:
+            continue
+        name = name_element.text
+
+        synonyms = set([])
+        for synonym_element in allele.iterfind(""Synonyms""):
+            for synonym in synonym_element.text.split("",""):
+                synonyms.add(synonym.strip())
+        mhc_class = mhc_class_element.text
+        organism_element = allele.find(""Organsim"")
+        if organism_element is None:
+            organism = None
+        else:
+            organism = organism_element.text
+
+        locus_element = allele.find(""Locus"")
+
+        if locus_element is None:
+            locus = None
+        else:
+            locus = locus_element.text
+
+        allele_object = Allele(
+            name=name,
+            mhc_class=mhc_class,
+            locus=locus,
+            organism=organism,
+            synonyms=synonyms)
+        result.append(allele_object)
+    return result
+
+@memoize
+def load_alleles_dict():
+    """"""Create a dictionary mapping each unique allele name to a namedtuple
+    containing information about that alleles class, locus, species, &c.
+    """"""
+    alleles = load_alleles()
+    result = {}
+    for allele in alleles:
+        for name in {allele.name}.union(allele.synonyms):
+            result[name] = allele
+    return result
+","Python"
+"Hydrophilic","openvax/pepdata","pepdata/iedb/common.py",".py","665","20","# 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 __future__ import annotations
+
+import datacache
+
+cache = datacache.Cache(""pepdata"")
+
+bad_amino_acids = 'U|X|J|B|Z'
+","Python"
+"Hydrophilic","openvax/pepdata","pepdata/iedb/__init__.py",".py","103","11","from . import (
+    alleles,
+    mhc,
+    tcell
+)
+
+__all__ = [
+    ""alleles"",
+    ""mhc"",
+    ""tcell"",
+]","Python"
+"Hydrophilic","openvax/pepdata","pepdata/iedb/memoize.py",".py","1534","50","# 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 __future__ import print_function, division, absolute_import
+
+from functools import wraps
+
+def _prepare_memoization_key(args, kwargs):
+    """"""
+    Make a tuple of arguments which can be used as a key
+    for a memoized function's lookup_table. If some object can't be hashed
+    then used its __repr__ instead.
+    """"""
+    key_list = []
+    for arg in args:
+        try:
+            hash(arg)
+            key_list.append(arg)
+        except:
+            key_list.append(repr(arg))
+    for (k, v) in kwargs.items():
+        try:
+            hash(k)
+            hash(v)
+            key_list.append((k, v))
+        except:
+            key_list.append((repr(k), repr(v)))
+    return tuple(key_list)
+
+def memoize(fn):
+    lookup_table = {}
+
+    @wraps(fn)
+    def wrapped_fn(*args, **kwargs):
+        key = _prepare_memoization_key(args, kwargs)
+        if key not in lookup_table:
+            lookup_table[key] = fn(*args, **kwargs)
+        return lookup_table[key]
+
+    return wrapped_fn
+","Python"
+"Hydrophilic","openvax/pepdata","pepdata/iedb/tcell.py",".py","6303","202","# 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 __future__ import print_function, division, absolute_import
+import logging
+import os
+
+import numpy as np
+import pandas as pd
+
+
+from .alleles import load_alleles_dict
+from .memoize import  memoize
+from .common import  bad_amino_acids, cache
+from .columns import (
+    get_assay_method,
+    get_assay_num_tested,
+    get_assay_response_measured,
+    get_assay_units,
+    get_host_name,
+    get_mhc_allele,
+    get_mhc_assay,
+    get_mhc_class,
+    get_epitope_source_organism,
+    get_epitope_type,
+    get_epitope_name,
+    
+)
+
+TCELL_COMPACT_FILENAME = ""tcell_full.csv""
+TCELL_COMPACT_URL = ""http://www.iedb.org/downloader.php?file_name=doc/tcell_full_v3.zip""
+TCELL_COMPACT_DECOMPRESS = True
+
+def download(force=False):
+    return cache.fetch(
+        filename=TCELL_COMPACT_FILENAME,
+        url=TCELL_COMPACT_URL,
+        decompress=TCELL_COMPACT_DECOMPRESS,
+        force=force)
+
+def local_path(auto_download=True):
+    path = cache.local_path(
+        filename=TCELL_COMPACT_FILENAME,
+        url=TCELL_COMPACT_URL,
+        decompress=TCELL_COMPACT_DECOMPRESS)
+    if not os.path.exists(path):
+        if auto_download:
+            return download()
+        raise ValueError(
+            (""Local file %s does not exist, call""
+            "" pepdata.iedb.tcell.download()"") % path)
+    return path
+
+def delete():
+    os.remove(local_path())
+
+@memoize
+def load_dataframe(
+        mhc_class : str | None = None,  # 1, 2, or None for neither
+        mhc_pattern : str | None  = None,
+        exclude_mhc : str | None  = None,
+        human_only : bool =False,
+        peptide_length : int | None = None,
+        assay_method : str | None = None,
+        only_standard_amino_acids : bool = True,
+        reduced_alphabet : dict | None = None,  # 20 letter AA strings -> simpler alphabet
+        nrows : int | None = None):
+    """"""
+    Load IEDB T-cell data without aggregating multiple entries for same epitope
+
+    Parameters
+    ----------
+    mhc_class: {None, 1, 2}
+        Restrict to MHC Class I or Class II (or None for neither)
+
+    mhc_pattern: regex pattern, optional
+        Restrict results to specific MHC used in assay
+
+    exclude_mhc: regex pattern, optional
+        Exclude certain MHC allele patterns 
+
+    human_only: bool
+        Restrict to human samples (default False)
+
+    peptide_length: int, optional
+        Restrict epitopes to amino acid strings of given length
+
+    assay_method string, optional
+        Only collect results with assay methods containing the given string
+
+    only_standard_amino_acids : bool, optional
+        Drop sequences which use non-standard amino acids, anything outside
+        the core 20, such as X or U (default = True)
+
+    reduced_alphabet: dictionary, optional
+        Remap amino acid letters to some other alphabet
+
+    nrows: int, optional
+        Don't load the full IEDB dataset but instead read only the first nrows
+    """"""
+    path = local_path()
+    df = pd.read_csv(
+            path,
+            header=[0, 1],
+            skipinitialspace=True,
+            nrows=nrows,
+            low_memory=False,
+            on_bad_lines='warn',
+            encoding=""latin-1"")
+    
+    mhc = get_mhc_allele(df)
+    mhc_class = get_mhc_class(df)
+    epitopes = get_epitope_name(df)
+    organism = get_host_name(df)
+    assay_method = get_assay_method(df)
+
+
+    # Sometimes the IEDB seems to put in an extra comma in the
+    # header line, which creates an unnamed column of NaNs.
+    # To deal with this, drop any columns which are all NaN
+    df = df.dropna(axis=1, how=""all"")
+
+    n = len(df)
+    
+    null_epitope_seq = epitopes.isnull()
+    n_null = null_epitope_seq.sum()
+
+    if n_null > 0:
+        logging.info(""Dropping %d null sequences"", n_null)
+
+    mask = ~null_epitope_seq
+
+    if only_standard_amino_acids:
+        # if have rare or unknown amino acids, drop the sequence
+        bad_epitope_seq = \
+            epitopes.str.contains(bad_amino_acids, na=False).astype(""bool"")
+        n_bad = bad_epitope_seq.sum()
+        if n_bad > 0:
+            logging.info(""Dropping %d bad sequences"", n_bad)
+
+        mask &= ~bad_epitope_seq
+
+    if human_only:
+        mask &= organism.str.startswith('Homo sapiens', na=False).astype('bool')
+
+
+    if mhc_class is not None:
+        # since MHC classes can be specified as either strings (""I"") or integers
+        # standard them to be strings
+        if mhc_class == 1:
+            mhc_class = ""I""
+        elif mhc_class == 2:
+            mhc_class = ""II""
+        if mhc_class not in {""I"", ""II""}:
+            raise ValueError(""Invalid MHC class: %s"" % mhc_class)
+        allele_dict = load_alleles_dict()
+        mhc_class_mask = [False] * len(df)
+        for i, allele_name in enumerate(mhc):
+            allele_object = allele_dict.get(allele_name)
+            if allele_object and allele_object.mhc_class == mhc_class:
+                mhc_class_mask[i] = True
+        mask &= np.array(mhc_class_mask)
+
+    # Match known alleles such as ""HLA-A*02:01"",
+    # broader groupings such as ""HLA-A2""
+    # and unknown alleles of the MHC-1 listed either as
+    #  ""HLA-Class I,allele undetermined""
+    #  or
+    #  ""Class I,allele undetermined""
+]
+
+    if hla:
+        mask &= df[mhc_allele_column_key].str.contains(hla, na=False)
+
+    if exclude_hla:
+        mask &= ~(df[mhc_allele_column_key].str.contains(exclude_hla, na=False))
+
+    if assay_group:
+        mask &= df[assay_group_column_key].str.contains(assay_group)
+
+    if assay_method:
+        mask &= df[assay_method_column_key].str.contains(assay_method)
+
+    if peptide_length:
+        assert peptide_length > 0
+        mask &= df[epitope_column_key].str.len() == peptide_length
+
+    df = df[mask]
+
+    logging.info(""Returning %d / %d entries after filtering"", len(df), n)
+    return df
+","Python"
+"Hydrophilic","openvax/pepdata","tests/test_iedb_tcell.py",".py","1918","50","# 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 pepdata import iedb
+
+def test_tcell_hla_restrict_a24():
+    """"""
+    IEDB T-cell: Test that HLA restriction actually decreases
+    number of results and that regular expression patterns
+    are being used correctly
+    """"""
+    df_all = iedb.tcell.load_dataframe(nrows=1000)
+    df_a24_1 = iedb.tcell.load_dataframe(hla='HLA-A24', nrows=1000)
+    df_a24_2 = iedb.tcell.load_dataframe(hla=r'HLA-A\*24', nrows=1000)
+    df_a24_combined = \
+        iedb.tcell.load_dataframe(hla=r'HLA-A24|HLA-A\*24', nrows=1000)
+    assert len(df_a24_1) < len(df_all)
+    assert len(df_a24_2) < len(df_all)
+    assert len(df_a24_combined) <= \
+        len(df_a24_1) + len(df_a24_2), \
+        ""Expected %d <= %d + %d"" % \
+        (len(df_a24_combined), len(df_a24_1), len(df_a24_2))
+
+def test_tcell_hla_exclude_a0201():
+    """"""
+    Test that excluding HLA allele A*02:01
+    actually returns a DataFrame not containing
+    that allele
+    """"""
+    df_all = iedb.tcell.load_dataframe(nrows=1000)
+    assert (df_all['MHC']['Allele Name'] == ""HLA-A*02:01"").any()
+
+    df_exclude = iedb.tcell.load_dataframe(
+        nrows=1000,
+        exclude_hla=""HLA-A\*02:01"")
+
+    n_A0201_entries = (df_exclude['MHC']['Allele Name'] == ""HLA-A*02:01"").sum()
+    assert n_A0201_entries == 0, \
+        (""Not supposed to contain HLA-A*02:01, ""
+         "" but found %d rows of that allele"") % n_A0201_entries
+","Python"
+"Hydrophilic","openvax/pepdata","tests/test_blosum.py",".py","242","17","from pepdata.blosum import (
+    blosum30_dict,
+    blosum30_matrix,
+    blosum50_dict,
+    blosum50_matrix,
+    blosum62_dict,
+    blosum62_matrix
+)
+
+def test_blosum30():
+    pass
+
+def test_blosum50():
+    pass
+
+def test_blosum62():
+    pass","Python"
+"Hydrophilic","openvax/pepdata","tests/test_pmbec.py",".py","92","8","from pepdata.pmbec import (
+    pmbec_dict,
+    pmbec_matrix,
+)
+
+def test_pmbec():
+    pass
+","Python"
+"Hydrophilic","openvax/pepdata","tests/test_iedb_alleles.py",".py","1422","44","# 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 __future__ import print_function, division, absolute_import
+
+from nose.tools import eq_
+
+from pepdata import iedb
+
+def test_iedb_human_class1_allele():
+    allele_dict = iedb.alleles.load_alleles_dict()
+    allele = allele_dict[""HLA-C*07:02""]
+    eq_(allele.mhc_class, ""I"")
+    eq_(allele.locus, ""C"")
+
+def test_iedb_human_class2_allele():
+    allele_dict = iedb.alleles.load_alleles_dict()
+    allele = allele_dict[""HLA-DRA*01:01/DRB1*04:04""]
+    eq_(allele.mhc_class, ""II"")
+    eq_(allele.locus, ""DR"")
+
+
+def test_iedb_mouse_class1_allele():
+    allele_dict = iedb.alleles.load_alleles_dict()
+    allele = allele_dict[""H-2-Ds""]
+    eq_(allele.mhc_class, ""I"")
+    eq_(allele.locus, ""D"")
+
+def test_iedb_mouse_class2_allele():
+    allele_dict = iedb.alleles.load_alleles_dict()
+    allele = allele_dict[""H-2-IAq""]
+    eq_(allele.mhc_class, ""II"")
+    eq_(allele.locus, ""IA"")
+","Python"
+"Hydrophilic","openvax/pepdata","tests/test_ngram.py",".py","2411","63","# Copyright (c) 2014. Mount Sinai School of Medicine
+#
+# 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 __future__ import print_function, division, absolute_import
+from six.moves import cPickle
+
+from pepdata import PeptideVectorizer
+
+# isoforms of two different proteins a, b
+
+a1 = (
+    ""MSPHPTALLGLVLCLAQTIHTQEEDLPRPSISAEPGTVIPLGSHVTFVCRGPVGVQTFRLERESRSTYND""
+    ""TEDVSQASPSESEARFRIDSVSEGNAGPYRCIYYKPPKWSEQSDYLELLVKETSGGPDSPDTEPGSSAGPT""
+    ""QRPSDNSHNEHAPASQGLKAEHLYILIGVSVVFLFCLLLLVLFCLHRQNQIKQGPPRSKDEEQKPQQRPDL""
+    ""AVDVLERTADKATVNGLPEKDRETDTSALAAGSSQEVTYAQLDHWALTQRTARAVSPQSTKPMAESITYAA""
+    ""VARH""
+)
+
+a2 = (
+    ""MSLMVVSMACVGFFLLQGAWPHEGVHRKPSLLAHPGPLVKSEETVILQCWSDVRFEHFLLHREGKYKDTLH""
+    ""LIGEHHDGVSKANFSIGPMMQDLAGTYRCYGSVTHSPYQLSAPSDPLDIVITGLYEKPSLSAQPGPTVLAG""
+    ""ESVTLSCSSRSSYDMYHLSREGEAHERRFSAGPKVNGTFQADFPLGPATHGGTYRCFGSFRDSPYEWSNSS""
+    ""DPLLVSVTGNPSNSWPSPTEPSSKTGNPRHLHVLIGTSVVKIPFTILLFFLLHRWCSNKKNAAVMDQEPAG""
+    ""NRTVNSEDSDEQDHQEVSYA""
+)
+
+a3 = (
+    ""MSLMVVSMACVGFFLLEGPWPHVGGQDKPFLSAWPGTVVSEGQHVTLQCRSRLGFNEFSLSKEDGMPVPEL""
+    ""YNRIFRNSFLMGPVTPAHAGTYRCCSSHPHSPTGWSAPSNPVVIMVTGVHRKPSLLAHPGPLVKSEETVIL""
+    ""QCWSDVRFEHFLLHREGKYKDTLHLIGEHHDGVSKANFSIGPMMQDLAGTYRCYGSVTHSPYQLSAPSDPL""
+    ""DIVITGLYEKPSLSAQPGPTVLAGESVTLSCSSRSSYDMYHLSREGEAHERRFSAGPKVNGTFQADFPLGP""
+    ""ATHGGTYRCFGSFRDSPYEWSNSSDPLLVSVTAFLSVKSSGHKYIY""
+)
+
+A = [a1, a2, a3]
+
+b1 = (
+    ""MPKGRAGSLPTTSIGWRFQLWFLGLTCPERHLARRLKNNSFYPFVQQEPNVFVLEYYLDTLWKGMLLFII""
+    ""SVVLVSFSSLREVQKQETWVFLVYGVGVGLWLVISSLPRRRLVLNHTRGVYHFSIQGRTVCQGPLHLVYV""
+    ""RLALSSDAHGRCFFHLVLGGHRLEPLVLVQLSEHYEQMEYLGRYIARKLNINYFDYLATSYRHVVRHWPP""
+    ""PGAGTVMGKSPMGHKPSSSQSSLEV""
+)
+
+b2 = (
+    ""MPKGRAGSLPTTSIGWRFQLWFLGLTCPERHLARRLKNNSFYPFVQQEPNVFVLEYYLDTLWKGMLLFII""
+    ""SVVLVSFSSLREVQKQETWVFLVYGVGVGLWLVISSLPRRRLVLNHTRGVYHFSIQGRTVCQGPLHLVYV""
+    ""RLALSSDAHGRCFFHLVLGGHRLEPLVLVQLSEHYEQMEYLGRYIARKLNINYFDYLATSYRHVVRHWPPP""
+    ""GAGTVMGKSPMGHKPSSSQSSLEV""
+)
+
+B = [b1, b2]
+","Python"
+"Hydrophilic","openvax/pepdata","tests/test_iedb_mhc.py",".py","1373","33","# Copyright (c) 2014. Mount Sinai School of Medicine
+#
+# 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 __future__ import print_function, division, absolute_import
+
+from pepdata import iedb
+
+def test_mhc_hla_a2():
+    """"""
+    IEDB MHC: Test that HLA restriction actually decreases number of results and
+    that regular expression patterns are being used correctly
+    """"""
+    df_all = iedb.mhc.load_dataframe(nrows=1000)
+    df_a2_1 = iedb.mhc.load_dataframe(hla='HLA-A2', nrows=1000)
+    df_a2_2 = iedb.mhc.load_dataframe(hla=r'HLA-A\*02', nrows=1000)
+    df_a2_combined = iedb.mhc.load_dataframe(hla=r'HLA-A2|HLA-A\*02', nrows=1000)
+    assert len(df_a2_1) < len(df_all)
+    assert len(df_a2_2) < len(df_all)
+    assert len(df_a2_combined) <= len(df_a2_1) + len(df_a2_2), \
+        ""Expected %d <= %d + %d"" % \
+        (len(df_a2_combined), len(df_a2_1), len(df_a2_2))
+","Python"
+"Hydrophilic","openvax/pepdata","tests/test_amino_acids.py",".py","918","27","from nose.tools import eq_
+from pepdata.amino_acid_alphabet import (
+    canonical_amino_acids,
+    canonical_amino_acid_letters,
+    extended_amino_acids,
+    extended_amino_acid_letters,
+)
+
+def test_canonical_amino_acids():
+    assert len(canonical_amino_acids) == 20
+
+def test_canonical_amino_acids_letters():
+    assert len(canonical_amino_acid_letters) == 20
+    assert ""X"" not in canonical_amino_acid_letters
+    expected_letters = [aa.letter for aa in canonical_amino_acids]
+    eq_(expected_letters, canonical_amino_acid_letters)
+
+def test_extended_amino_acids():
+    assert len(extended_amino_acids) > 20
+
+def test_extended_amino_acids_letters():
+    assert len(extended_amino_acid_letters) > 20
+    assert ""X"" in extended_amino_acid_letters
+    assert ""J"" in extended_amino_acid_letters
+    expected_letters = [aa.letter for aa in extended_amino_acids]
+    eq_(expected_letters, extended_amino_acid_letters)
+","Python"