stcrpy 1.0.0__py3-none-any.whl

stcrpy/tcr_processing/TCRStructure.py

@@ -0,0 +1,148 @@
+"""
+Created on 10 May 2017
+@author: leem
+Based on the ABDB.AbPDB.AntibodyStructure class.
+"""
+
+from Bio import SeqUtils
+from .Entity import Entity
+from .TCR import TCR
+from .MHC import MHC
+
+
+class TCRStructure(Entity):
+    """
+    The TCRStructure class contains a collection of models
+    """
+
+    def __init__(self, identifier):
+        self.level = "TS"
+        Entity.__init__(self, identifier)
+        self.header = {}
+
+    def __repr__(self):
+        return "<Structure id=%s>" % self.get_id()
+
+    def _sort(self, m1, m2):
+        """Sort models.
+
+        This sorting function sorts the Model instances in the Structure instance.
+        The sorting is done based on the model id, which is a simple int that
+        reflects the order of the models in the PDB file.
+
+        Arguments:
+        o m1, m2 - Model instances
+        """
+        return (m1.get_id() > m2.get_id()) - (m1.get_id() < m2.get_id())
+
+    def _set_numbering_scheme(self, scheme=None):
+        """
+        Set the numbering scheme used.
+        """
+        self.numbering_scheme = scheme
+
+    # Public
+    def set_header(self, header):
+        """
+        Set the header as the parsed header dictionary from biopython
+        """
+        self.header = header
+
+    def get_header(self):
+        return self.header
+
+    def get_models(self):
+        for m in self:
+            yield m
+
+    def get_holders(self):
+        for m in self.get_models():
+            for h in m:
+                yield h
+
+    def get_TCRs(self):
+        """
+        Get any instance of the TCR object.
+        Hierarchy:
+            TCRStructure
+               |
+               |______ TCR
+               |
+               |______ MHC
+        """
+        for h in self.get_holders():
+            if isinstance(h, TCR):
+                yield h
+
+    def get_TCRchains(self):
+        """Gets all TCR chains"""
+        for h in self.get_holders():
+            if h.id == "TCRchain":
+                for c in h:
+                    yield c
+            elif isinstance(h, TCR):
+                for c in h:
+                    yield c
+
+    def get_MHCs(self):
+        """
+        Get any instance of the MHC object.
+        Hierarchy:
+            TCRStructure
+               |
+               |______ TCR
+               |
+               |______ MHC
+        """
+        for h in self.get_holders():
+            if isinstance(h, MHC):
+                yield h
+
+    def get_antigens(self):
+        """
+        This gets the 'antigen' chains in the structure,
+        that have been assigned to a TCR or an MHC.
+        """
+        antigens = set([])
+        for h in self.get_holders():
+            if isinstance(h, MHC) or isinstance(h, TCR) or h.id == "TCRchain":
+                for c in h.antigen:
+                    if c not in antigens:
+                        antigens = antigens.union(set([c]))
+                        yield c
+
+    def get_unpaired_TCRchains(self):
+        """
+        This gets the TCR chains that are not paired
+        """
+        for h in self.get_holders():
+            if h.id == "TCRchain":
+                for c in h:
+                    yield c
+
+    def get_chains(self):
+        for h in self.get_holders():
+            for c in h:
+                yield c
+
+    def get_residues(self):
+        for c in self.get_chains():
+            for r in c:
+                yield r
+
+    def get_atoms(self):
+        for r in self.get_residues():
+            for a in r:
+                yield a
+
+    def get_seq(self, model=0):
+        seq = ""
+        for c in self[model]:
+            for r in c.get_residues():
+                # Skip over water molecules
+                if r.resname == "HOH":
+                    continue
+                seq += SeqUtils.IUPACData.protein_letters_3to1[r.resname]
+            seq += "/"
+
+        return seq[:-1]

stcrpy/tcr_processing/TCRchain.py

@@ -0,0 +1,160 @@
+from Bio.PDB import Chain
+from Bio import SeqUtils
+from .utils.region_definitions import get_region
+from .Entity import Entity
+from .Fragment import Fragment
+
+regions = {
+    "B": ["fwb1", "cdrb1", "fwb2", "cdrb2", "fwb3", "cdrb3", "fwb4"],
+    "A": ["fwa1", "cdra1", "fwa2", "cdra2", "fwa3", "cdra3", "fwa4"],
+    "D": ["fwd1", "cdrd1", "fwd2", "cdrd2", "fwd3", "cdrd3", "fwd4"],
+    "G": ["fwg1", "cdrg1", "fwg2", "cdrg2", "fwg3", "cdrg3", "fwg4"],
+}
+
+
+class TCRchain(Chain.Chain, Entity):
+    """
+    A class to hold a TCR chain.
+    """
+
+    def __init__(self, identifier):
+        Chain.Chain.__init__(self, identifier)
+        Entity.__init__(self, identifier)
+        self.level = "C"
+        self.mhc = []
+        self.antigen = []
+        self.unnumbered = []
+        self.sequence = {}
+        self.residue_order = {}
+        self.engineered = False
+
+    def __repr__(self):
+        return "<TCRchain %s type: %s>" % (self.id, self.chain_type)
+
+    def _add_mhc(self, mhc=None):
+        self.mhc.append(mhc)
+
+    def _add_antigen(self, antigen=None):
+        if antigen not in self.antigen:
+            self.antigen.append(antigen)
+
+    def is_bound(self):
+        """
+        Check whether there is an antigen bound to the TCR
+        """
+        if self.get_antigen():
+            return True
+        else:
+            return False
+
+    def analyse(self, chain_type):
+        self.set_chain_type(chain_type)
+        self._init_fragments()
+        self.annotate_children()
+        self.set_sequence()
+
+    def set_chain_type(self, chain_type):
+        """
+        Set the chain type to B, A, D, or G
+        """
+        self.chain_type = chain_type
+
+    def set_sequence(self):
+        i = 0
+        for residue in self:
+            if (
+                residue.get_resname().capitalize()
+                in SeqUtils.IUPACData.protein_letters_3to1
+            ):
+                resname = SeqUtils.IUPACData.protein_letters_3to1[
+                    residue.get_resname().capitalize()
+                ]  # change this to use our chemical components.
+            else:
+                # skip the residue if the code is not recognised - e.g. UNK
+                continue
+            hetflag, resseq, icode = residue.get_id()
+            self.sequence[(self.chain_type + str(resseq) + str(icode)).strip()] = (
+                resname
+            )
+            self.residue_order[(self.chain_type + str(resseq) + str(icode)).strip()] = i
+            i += 1
+
+    def set_engineered(self, engineered):
+        if engineered:
+            self.engineered = True
+        else:
+            self.engineered = False
+
+    def add_unnumbered(self, residue):
+        self.unnumbered.append(residue.id)
+
+    def _get_region(self, residue):
+        region = ""
+        if hasattr(residue, "imgt_numbered") and residue.imgt_numbered:
+            region = get_region((residue.id[1], residue.id[2]), self.chain_type)
+            return region
+        return "?"
+
+    def annotate_children(self):
+        for residue in self:
+            residue.chain_type = self.chain_type
+            residue.region = self._get_region(residue)
+            for atom in residue:
+                atom.chain_type = self.chain_type
+                atom.region = residue.region
+
+            if residue.region != "?":
+                self.fragments.child_dict[residue.region].add(residue)
+
+    def _init_fragments(self):
+        self.fragments = Entity("Fragments")
+        self.fragments.set_parent(self)
+        for region in regions[self.chain_type]:
+            self.fragments.add(Fragment(region))
+
+    def is_engineered(self):
+        return self.engineered
+
+    def get_MHC(self):
+        return self.mhc
+
+    def get_antigen(self):
+        return self.antigen
+
+    def get_fragments(self):
+        for f in self.fragments:
+            yield f
+
+    def get_CDRs(self):
+        for f in self.fragments:
+            if f.id.lower()[:3] == "cdr":
+                yield f
+
+    def get_frameworks(self):
+        """
+        Obtain framework regions from a TCRChain object.
+        """
+        for f in self.get_fragments():
+            if "fw" in f.id:
+                yield f
+
+    def get_sequence(self, type=dict):
+        if not self.sequence:
+            self.set_sequence()
+        if type is dict:
+            return self.sequence
+        else:
+            ordered = sorted(
+                list(self.sequence.items()), key=lambda x: self.residue_order[x[0]]
+            )
+            if type is str:
+                return "".join([r[1] for r in ordered])
+            else:
+                return ordered
+
+    def get_unnumbered(self):
+        for r in self.unnumbered:
+            yield self.child_dict[r]
+
+    def get_germline_assignments(self):
+        return self.xtra["genetic_origin"]

stcrpy/tcr_processing/__init__.py

@@ -0,0 +1,3 @@
+from .TCR import TCR, abTCR, gdTCR, dbTCR
+from .MHC import MHC
+from .MHCchain import MHCchain