stcrpy 1.0.0__py3-none-any.whl → 1.0.3__py3-none-any.whl

stcrpy/tcr_geometry/TCRDock.py

@@ -21,7 +21,10 @@ class TCRDock(object):
     def __init__(self, tcr, QUIET=False):
         """
         Calculate the docking angle between TCR and pMHC.
-        @param TCR: input a TCR object (abTCR or gdTCR or dbTCR).
+
+        Args:
+            tcr (TCR): TCR input
+            QUIET (bool, optional): Verbosity of error stream. Defaults to False.
         """
         self.warnings = ErrorStream()
         self.QUIET = QUIET

stcrpy/tcr_interactions/TCRpMHC_PLIP_Model_Parser.py

@@ -38,9 +38,30 @@ class TCRpMHC_PLIP_Model_Parser:
         ligand = PDB.Model.Model(id=0)
 
         peptide_chain = tcr_pmhc_complex.antigen
+        if len(peptide_chain) != 1:
+            # try to identify correct antigen
+            # if a chain is longer than 25 residues reject it, this may happen if anarci has failed to label an MHC chain
+            peptide_chain = [
+                c
+                for c in peptide_chain
+                if (
+                    len(c) < 25
+                    and isinstance(c, PDB.Chain.Chain)
+                    or isinstance(c, PDB.Residue.Residue)
+                )
+            ]
+
         assert (
             len(peptide_chain) == 1
         ), f"More or less than one peptide chain found: {peptide_chain}"
+
+        if isinstance(
+            peptide_chain[0], PDB.Residue.Residue
+        ):  # wrap single residue antigen in chain
+            residue_as_chain = PDB.Chain.Chain(id="Z")
+            residue_as_chain.add(peptide_chain[0].copy())
+            peptide_chain = [residue_as_chain]
+
         ligand.add(peptide_chain[0].copy())
 
         tcr_and_mhc_chains = [

stcrpy/tcr_processing/Chemical_components.py

@@ -48761,10 +48761,10 @@ def is_common_buffer(residue):
     Is the residue a common buffer?
     If it occurs in the L{common buffers<common_buffers>} list it is considered a common buffer.
 
-    @param residue: A AbPDB residue object or residues identifier e.g. PO4
-
-    @return: Flag if the residue is a common buffer.
-    @rtype: C{bool}
+    Args:
+        residue: A AbPDB residue object or residues identifier e.g. PO4
+    Returns:
+        Flag if the residue is a common buffer.
     """
     if not isinstance(residue, str):
         residue = residue.get_resname()

stcrpy/tcr_processing/Entity.py

@@ -81,8 +81,9 @@ class Entity(Bio.PDB.Entity.Entity):
     def _get_output_string(self, selection, n):
         """
         Method to get the atom lines of the entity's children.
-        @param selection: Selector object from TcrPDB.Select or inherited class.
-        @param n: An integer value to number the current atom with.
+        Args:
+            selection: Selector object from TcrPDB.Select or inherited class.
+            n: An integer value to number the current atom with.
                   If this is False the original numbering is used from the pdb file.
         """
         output_string = ""
@@ -102,23 +103,24 @@ class Entity(Bio.PDB.Entity.Entity):
 
     def save(self, output=sys.stdout, renumber=True, selection=False, remarks=True):
         """
-        Save the coordinates of the entity
+        Save the coordinates of the entity.
+        Example:
+        entity.save("path/to/file/filename.pdb")
+        residue.save( "residue1.pdb" )
 
-        @param output: Where to write coordinates to. Should be an an open file, string or sys.stdout.
+        Args:
+            output: Where to write coordinates to. Should be an an open file, string or sys.stdout.
                        By default the output is written to stdout
-        @param renumber: Flag whether to renumber the atoms to IMGT scheme
+            renumber: Flag whether to renumber the atoms to IMGT scheme
                          Default is to renumber the atoms so that the first is 1 etc.
                          Use renumber = False to retain the original atom numbering from the pdb file
 
-        @param selection: Provide a selector object to select which children of the entity should be outputted.
+            selection: Provide a selector object to select which children of the entity should be outputted.
                           Selection should be a selector object from TcrPDB.Select.
                           Some basic selector classes are provided in the module. More complex classes can be created by inheriting from these.
                           If selection = False (default) all atoms in the entity are output
 
-        @param remarks: Flag to print out remarks generated by TcrPDB. Default TRUE
-        Example:
-        entity.save("path/to/file/filename.pdb")
-        residue.save( "residue1.pdb" )
+            remarks: Flag to print out remarks generated by TcrPDB. Default TRUE
         """
 
         def ag_chain_and_type(ags):
@@ -264,12 +266,9 @@ class Entity(Bio.PDB.Entity.Entity):
                 >>> rotation=rotmat(pi, Vector(1,0,0))
                 >>> translation=array((0,0,1), 'f')
                 >>> entity.transform(rotation, translation)
-
-        @param rot: A right multiplying rotation matrix
-        @type rot: 3x3 Numeric array
-
-        @param tran: the translation vector
-        @type tran: size 3 Numeric array
+        Args:
+            rot: A right multiplying rotation matrix (3x3 Numeric array)
+            tran: the translation vector (size 3 Numeric array)
         """
 
         for o in self.get_list():

stcrpy/tcr_processing/MHC.py

@@ -447,3 +447,70 @@ class scCD1(MHC):
 
     def get_B2M(self):
         return None
+
+
+class scMH2(MHC):
+    """
+    Single chain MHC class 2.
+    Holds single GA or GB chain.
+    Usually this will only occur if ANARCI has not been identified one of the two chains correctly.
+    """
+
+    def __init__(self, c1):
+        assert c1.chain_type in [
+            "GA",
+            "GB",
+        ], f"Chain {c1} with can not form a single chain MHC class I."
+        Entity.__init__(self, c1.id)
+
+        self.level = "H"
+        self._add_domain(c1)
+        self._set_MHC_type()
+        self.child_list = sorted(self.child_list, key=lambda x: x.id)
+        self.antigen = []
+        self.tcr = []
+        self.engineered = False
+
+    def __repr__(self):
+        if self.MHC_type == "MH2":
+            if hasattr(self, "GA"):
+                return "<%s %s GA=%s>" % (
+                    self.MHC_type,
+                    self.GA,
+                    self.GA,
+                )
+            elif hasattr(self, "GB"):
+                return "<%s %s GB=%s>" % (
+                    self.MHC_type,
+                    self.GB,
+                    self.GB,
+                )
+
+        else:
+            if hasattr(self, "GA"):
+                return "<GA %s GA=%s>" % (self.GA, self.GA)
+            elif hasattr(self, "GB"):
+                return "<GB %s GB=%s>" % (self.GB, self.GB)
+
+    def _set_MHC_type(self):
+        if hasattr(self, "GA") and hasattr(self, "GB"):
+            self.MHC_type = "MH2"
+        else:
+            self.MHC_type = ""
+
+    def _add_domain(self, chain):
+        if chain.chain_type == "GA":
+            self.GA = chain.id
+        elif chain.chain_type == "GB":
+            self.GB = chain.id
+
+        # Add the chain as a child of this entity.
+        self.add(chain)
+
+    def get_GA(self):
+        if hasattr(self, "GA"):
+            return self.child_dict[self.GA]
+
+    def get_GB(self):
+        if hasattr(self, "GB"):
+            return self.child_dict[self.GB]

stcrpy/tcr_processing/TCR.py

@@ -1,6 +1,6 @@
 """
 Created on 3rd April 2024
-@author: Nele Quast based on work by Dunbar and Leem 
+Nele Quast based on work by Dunbar and Leem
 The TCR class.
 """
 
@@ -20,15 +20,28 @@ except ImportError as e:
 
 class TCR(Entity):
     """
-    TCR class. This is generic which is inherited later.
-    Holds paired TCR chains.
+    TCR class. Inherits from PDB.Entity.
+    This is a base class for TCR strucutres, enabling antigen and MHC association.
+    abTCR and gdTCR are the instantiated subclasses of this class.
     """
 
     def _add_antigen(self, antigen=None):
+        """
+        Append associated antigen to TCR antigen field.
+
+        Args:
+            antigen (Antigen, optional): Antigen to associate with TCR. Defaults to None.
+        """
         if antigen not in self.antigen:
             self.antigen.append(antigen)
 
     def _add_mhc(self, mhc=None):
+        """
+        Append associated MHC to TCR MHC field. If antigen are associted with MHC but not TCR, add them to TCR antigen.
+
+        Args:
+            mhc (MHC, optional): MHC to associate with TCR. Defaults to None.
+        """
         if mhc not in self.MHC:
             self.MHC.append(mhc)
             # If there are any het antigens that are in the MHC but not in close proximity of the TCR
@@ -38,17 +51,21 @@ class TCR(Entity):
 
     def get_antigen(self):
         """
-        Return a list of bound antigens.
+        Return a list of TCR associated antigens.
         """
         return self.antigen
 
     def get_MHC(self):
-        """ """
+        """
+        Return a list of TCR associated MHCs.
+        """
         return self.MHC
 
     def is_bound(self):
-        """
-        Check whether this TCR is bound to an antigen
+        """True or False if the TCR is associated with an antigen.
+
+        Returns:
+            bool: Whether TCR is associated with an antigen.
         """
         if self.get_antigen():
             return True
@@ -56,22 +73,40 @@ class TCR(Entity):
             return False
 
     def get_chains(self):
+        """Returns generator of TCR chains.
+
+        Yields:
+            Chain: TCR chain
+        """
         for c in self:
             yield c
 
     def get_residues(self):
+        """Returns generator of TCR residues.
+
+        Yields:
+            Residue: TCR residue
+        """
         for c in self.get_chains():
             for r in c:
                 yield r
 
     def get_atoms(self):
+        """Returns generator of TCR atoms.
+
+        Yields:
+            Atom: TCR atoms
+        """
         for r in self.get_residues():
             for a in r:
                 yield a
 
     def get_frameworks(self):
         """
-        Obtain framework regions from a TCR structure object.
+        Obtain framework regions from a TCR structure object as generator.
+
+        Yields:
+            Fragment: TCR framework regions
         """
         for f in self.get_fragments():
             if "fw" in f.id:
@@ -79,15 +114,20 @@ class TCR(Entity):
 
     def get_CDRs(self):
         """
-        Obtain CDR loops from a TCR structure object
+        Obtain complementarity determining regions (CDRs) from a TCR structure object as generator.
+
+        Yields:
+            Fragment: TCR CDR regions
         """
         for f in self.get_fragments():
             if "cdr" in f.id:
                 yield f
 
     def get_TCR_type(self):
-        """
-        Get the TCR type
+        """Get TCR type according to variable region assignments.
+
+        Returns:
+            str: TCR type (abTCR, gdTCR, dbTCR)
         """
         if hasattr(self, "tcr_type"):
             return self.tcr_type
@@ -102,9 +142,22 @@ class TCR(Entity):
             return self.tcr_type
 
     def get_germline_assignments(self):
+        """Retrive germline assignments for all TCR chains.
+        This is a dictionary with the chain ID as key and the germline assignments as value.
+
+        Returns:
+            dict: dict with TCR chain ID as key and germline assignments as value
+        """
         return {c.id: c.get_germline_assignments() for c in self.get_chains()}
 
     def get_MHC_allele_assignments(self):
+        """
+        Retrieve MHC allele assignments for all TCR associated MHCs.
+        This is a list of dictionaries with the MHC ID as key and the allele assignments as value.
+
+        Returns:
+            dict: dict with MHC chain ID as key and allele assignments as value
+        """
         return [
             (
                 mhc.get_allele_assignments()
@@ -116,6 +169,11 @@ class TCR(Entity):
         ]
 
     def get_germlines_and_alleles(self):
+        """Get all germline and allele assignments for TCR and MHC chains as a dictionary with the chain ID as key and the germline assignments as value.
+
+        Returns:
+            dict: Dictionary of TCR germline and MHC allele assignemnts with amino acid sequences.
+        """
         from ..tcr_formats.tcr_formats import get_sequences
 
         germlines_and_alleles = {}
@@ -167,22 +225,59 @@ class TCR(Entity):
         return germlines_and_alleles
 
     def save(self, save_as=None, tcr_only: bool = False, format: str = "pdb"):
+        """Save TCR object as PDB or MMCIF file.
+
+        Args:
+            save_as (str, optional): File path to save TCR to. Defaults to None.
+            tcr_only (bool, optional): Whether to save TCR only or to include MHC and antigen. Defaults to False.
+            format (str, optional): Whether to save as PDB or MMCIF. Defaults to "pdb".
+        """
         from . import TCRIO
 
         tcrio = TCRIO.TCRIO()
         tcrio.save(self, save_as=save_as, tcr_only=tcr_only, format=format)
 
     def get_scanning_angle(self, mode="rudolph"):
+        """
+        Returns TCR:pMHC complex scanning (aka crossing, incident) angle of TCR to MHC.
+        See paper for details.
+
+        Args:
+            mode (str, optional): Mode for calculating the scanning angle. Options "rudolph", "cys", "com". Defaults to "rudolph".
+
+        Returns:
+            float: Scanning angle of TCR to MHC in degrees
+        """
         if not hasattr(self, "geometry") or self.geometry.mode != mode:
             self.calculate_docking_geometry(mode=mode)
         return self.geometry.get_scanning_angle()
 
-    def get_pitch_angle(self, mode="rudolph"):
+    def get_pitch_angle(self, mode="cys"):
+        """
+        Returns TCR:pMHC complex pitch angle of TCR to MHC.
+        See paper for details.
+
+        Args:
+            mode (str, optional): Mode for calculating the scanning angle. Options "rudolph", "cys", "com". Defaults to "cys".
+
+        Returns:
+            float: Pitch angle of TCR to MHC in degrees
+        """
         if not hasattr(self, "geometry") or self.geometry.mode != mode:
             self.calculate_docking_geometry(mode=mode)
         return self.geometry.get_pitch_angle()
 
     def calculate_docking_geometry(self, mode="rudolph", as_df=False):
+        """Calculate docking geometry of TCR to MHC.
+        This is a wrapper function for the TCRGeom class.
+
+        Args:
+            mode (str, optional): Mode for calculating the geometry. Options "rudolph", "cys", "com". Defaults to "rudolph".
+            as_df (bool, optional): Whether to return as dictionary or dataframe. Defaults to False.
+
+        Returns:
+            [dict, DataFrame]: TCR to MHC geometry.
+        """
         if len(self.get_MHC()) == 0:
             warnings.warn(
                 f"No MHC found for TCR {self}. Docking geometry cannot be calcuated"
@@ -203,20 +298,39 @@ class TCR(Entity):
         return self.geometry.to_dict()
 
     def score_docking_geometry(self, **kwargs):
+        """
+        Score docking geometry of TCR to MHC.
+        This is a wrapper function for the TCRGeomFiltering class.
+        The score is calculated as the negative log of the TCR:pMHC complex geometry feature probabilities based on the distributions fit by maximum likelihood estimation of TCR to Class I MHC strucutres from STCRDab.
+        Please see the paper methods for details.
+
+        Returns:
+            float: TCR:pMHC complex score as negative log of TCR:pMHC complex geometry feature probabilities
+        """
         from ..tcr_geometry.TCRGeomFiltering import DockingGeometryFilter
 
         geom_filter = DockingGeometryFilter()
         if not hasattr(self, "geometry"):
             self.calculate_docking_geometry(mode="com")
         return geom_filter.score_docking_geometry(
-            self.geometry.get_scanning_angle(),
-            self.geometry.get_pitch_angle(),
+            self.geometry.get_scanning_angle(mode="com"),
+            self.geometry.get_pitch_angle(mode="com"),
             self.geometry.tcr_com[-1],  # z component of TCR centre of mass
         )
 
     def profile_peptide_interactions(
         self, renumber: bool = True, save_to: str = None, **kwargs
     ) -> "pd.DataFrame":
+        """
+        Profile the interactions of the peptide to the TCR and the MHC.
+
+        Args:
+            renumber (bool, optional): Whether to renumber the interacting residues. Defaults to True.
+            save_to (str, optional): Path to save intraction data to as csv. Defaults to None.
+
+        Returns:
+            pd.DataFrame: Dataframe of peptide interactions
+        """
         if len(self.get_antigen()) == 0:
             warnings.warn(
                 f"No peptide antigen found for TCR {self}. Peptide interactions cannot be profiled"
@@ -238,6 +352,25 @@ class TCR(Entity):
         return interactions
 
     def get_interaction_heatmap(self, plotting_kwargs={}, **interaction_kwargs):
+        """
+        Get interaction heatmap of TCR to MHC and peptide.
+        Generates heatmap image.
+        Plotting kwargs are passed to heatmap function.
+
+        Args:
+            plotting_kwargs (dict, optional):
+                save_as: path to save heatmap image to
+                interaction_type: type of interaction (eg. saltbridge, h_bond) to plot. All interactions are plotted by default.
+                antigen_name: name of antigen for plot title
+                mutation_index: index of antigen residues to highlight in plot
+                Defaults to {
+                    save_as:None,
+                    interaction_type:None,
+                    antigen_name:None,
+                    mutation_index:None
+                    }.
+            interaction_kwargs: kwargs for TCRInteractionProfiler class. See TCRInteractionProfiler for details.
+        """
         from ..tcr_interactions import TCRInteractionProfiler
 
         interaction_profiler = TCRInteractionProfiler.TCRInteractionProfiler(
@@ -266,6 +399,15 @@ class TCR(Entity):
             def visualise_interactions(
                 save_as=None, antigen_residues_to_highlight=None, **interaction_kwargs
             ):
+                """Visualise peptide interactions in pymol.
+
+                Args:
+                    save_as (str, optional): path to save pymol session to. Defaults to None.
+                    antigen_residues_to_highlight (list[int], optional): antigen residues to highlight red in pymol session. Defaults to None.
+                    **interaction_kwargs: kwargs for TCRInteractionProfiler class. See TCRInteractionProfiler for details.
+                Returns:
+                    str: path to saved pymol session
+                """
                 from ..tcr_interactions import TCRInteractionProfiler
 
                 interaction_profiler = TCRInteractionProfiler.TCRInteractionProfiler(
@@ -306,7 +448,18 @@ class TCR(Entity):
 
 
 class abTCR(TCR):
+    """
+    abTCR class. Inherits from TCR.
+    This is a subclass of TCR for TCRs with alpha and beta chains.
+    """
     def __init__(self, c1, c2):
+        """
+        Initialise abTCR object. This is a subclass of TCR for TCRs with alpha and beta chains.
+
+        Args:
+            c1 (TCRchain): alpha or beta type TCR chain
+            c2 (TCRchain): alpha or beta type TCR chain
+        """
 
         if c1.chain_type == "B":
             Entity.__init__(self, c1.id + c2.id)
@@ -328,9 +481,22 @@ class abTCR(TCR):
         self.visualise_interactions = self._create_interaction_visualiser()
 
     def __repr__(self):
+        """
+        String representation of the abTCR object.
+
+        Returns:
+            str: String representation of the abTCR objec
+        """
         return "<TCR %s%s beta=%s; alpha=%s>" % (self.VB, self.VA, self.VB, self.VA)
 
     def _add_domain(self, chain):
+        """
+        Add a variable alpha or variable beta domain to the TCR object.
+        Links the domain to the chain ID.
+
+        Args:
+            chain (TCRchain): TCR chain whose domain is being added.
+        """
         if chain.chain_type == "B":
             self.VB = chain.id
         elif chain.chain_type == "A" or chain.chain_type == "D":
@@ -340,14 +506,32 @@ class abTCR(TCR):
         self.add(chain)
 
     def get_VB(self):
+        """
+        Retrieve the variable beta chain of the TCR
+
+        Returns:
+            TCRchain: VB chain
+        """
         if hasattr(self, "VB"):
             return self.child_dict[self.VB]
 
     def get_VA(self):
+        """
+        Retrieve the variable alpha chain of the TCR
+
+        Returns:
+            TCRchain: VA chain
+        """
         if hasattr(self, "VA"):
             return self.child_dict[self.VA]
 
     def get_domain_assignment(self):
+        """
+        Retrieve the domain assignment of the TCR as a dict with variable domain type as key and chain ID as value.
+
+        Returns:
+            dict: domain assignment from domain to chain ID, e.g. {"VA": "D", "VB": "E"}
+        """
         try:
             return {"VA": self.VA, "VB": self.VB}
         except AttributeError:
@@ -358,6 +542,12 @@ class abTCR(TCR):
         return None
 
     def is_engineered(self):
+        """
+        Flag for engineered TCRs.
+
+        Returns:
+            bool: Flag for engineered TCRs
+        """
         if self.engineered:
             return True
         else:
@@ -371,6 +561,12 @@ class abTCR(TCR):
             return False
 
     def get_fragments(self):
+        """
+        Retrieve the fragments, ie FW and CDR loops of the TCR as a generator.
+
+        Yields:
+            Fragment: fragment of TCR chain.
+        """
         vb, va = self.get_VB(), self.get_VA()
 
         # If a variable domain exists

stcrpy/tcr_processing/TCRParser.py

@@ -9,6 +9,7 @@ from itertools import combinations, product
 import sys
 import os
 from collections import defaultdict
+import warnings
 
 from Bio.PDB.PDBParser import PDBParser
 from Bio.PDB.MMCIFParser import MMCIFParser
@@ -22,7 +23,7 @@ from ..utils.error_stream import ErrorStream
 from .TCRStructure import TCRStructure
 from .Model import Model
 from .TCR import TCR, abTCR, gdTCR
-from .MHC import MHC, MH1, MH2, CD1, MR1, scMH1, scCD1
+from .MHC import MHC, MH1, MH2, CD1, MR1, scMH1, scCD1, scMH2
 from .Holder import Holder
 from .TCRchain import TCRchain
 from .MHCchain import MHCchain
@@ -461,6 +462,7 @@ class TCRParser(PDBParser, MMCIFParser):
                 newmodel.add(mhc)
 
             # allow instantiation of single chain MH1 type MH class if the alpha helices forming chain has been observed
+            # allow instantiation of single chain MH2 type MH class if one of the GA or GB chain has been observed
             ids_to_detach = []
             for mhc_chain in mhchains:
                 if mhc_chain.chain_type in ["MH1", "GA1", "GA2"]:
@@ -471,6 +473,13 @@ class TCRParser(PDBParser, MMCIFParser):
                     ids_to_detach.append(mhc_chain.id)
                     sc_mhc = scCD1(mhc_chain)
                     newmodel.add(sc_mhc)
+                elif mhc_chain.chain_type in ["GA", "GB"]:
+                    ids_to_detach.append(mhc_chain.id)
+                    sc_mhc = scMH2(mhc_chain)
+                    newmodel.add(sc_mhc)
+                    warnings.warn(
+                        f"Single chain MH class II instantiated with chain type {mhc_chain.chain_type}. It is possible the other MHC class II chain has not been identified."
+                    )
 
             for mhc_chain_id in ids_to_detach:
                 mhchains.detach_child(mhc_chain_id)
@@ -1005,9 +1014,11 @@ class TCRParser(PDBParser, MMCIFParser):
     ):
         """
         This is a generic method to process which proteins/peptides belong to a TCR or MHC. Needs testing.
-        @param complexes:       list of TCR/TCRchain objects or MHC/MHCchain objects
-        @param receptor_atoms:  list of atom subset that will likely contact the antigen (e.g. cdr_atoms)
-        @param antigen_atoms:   list of atoms in the antigen.
+
+        Args:
+            complexes:       list of TCR/TCRchain objects or MHC/MHCchain objects
+            receptor_atoms:  list of atom subset that will likely contact the antigen (e.g. cdr_atoms)
+            antigen_atoms:   list of atoms in the antigen.
         """
         ns = NeighborSearch(
             [atom for chain in receptor_atoms for atom in receptor_atoms[chain]]

stcrpy/tcr_processing/annotate.py

@@ -38,10 +38,12 @@ def call_anarci(
 ):
     """
     Use the ANARCI program to number the sequence.
-    @param seq: An amino acid sequence that you wish to number.
-    @type seq: C{str}
 
-    @return: numbering, chain type
+    Args:
+        seq: An amino acid sequence that you wish to number.
+
+    Returns:
+        numbering, chain type, germline information
     """
     from anarci import number as anarci_number
 
@@ -49,7 +51,7 @@ def call_anarci(
         seq, allow=allow, assign_germline=True
     )
 
-    if numbering and "MR" not in chain_type and chain_type in allow:
+    if numbering and chain_type in allow:
         return [(_, aa) for _, aa in numbering if aa != "-"], chain_type, germline_info
     elif numbering and chain_type in ["BA", "GD", "AB", "DG"]:
         return (
@@ -85,15 +87,15 @@ def annotate(chain):
         )
         # aligned_numbering = cleanup_scTCR_numbering(aligned_numbering, sequence_list)
         scTCR = True
-    elif chtype == "DC1" or chtype == "RM1":
-        # Use the scTCR numbering trick; since CD1/MR1 numbering only spans up to residue ~87 and
-        aligned_numbering = align_scTCR_numbering(
-            numbering, sequence_list, sequence_str
-        )
-        aligned_numbering[0].update(aligned_numbering[1])
-        aligned_numbering = aligned_numbering[0]  # combine the numbering
-        aligned_numbering = cleanup_scTCR_numbering(aligned_numbering, sequence_list)
-        scTCR = False
+    # elif chtype == "DC1" or chtype == "RM1":
+    #     # Use the scTCR numbering trick; since CD1/MR1 numbering only spans up to residue ~87 and
+    #     aligned_numbering = align_scTCR_numbering(
+    #         numbering, sequence_list, sequence_str
+    #     )
+    #     aligned_numbering[0].update(aligned_numbering[1])
+    #     aligned_numbering = aligned_numbering[0]  # combine the numbering
+    #     aligned_numbering = cleanup_scTCR_numbering(aligned_numbering, sequence_list)
+    #     scTCR = False
     else:
         # align the original residue id's to the numbering
         aligned_numbering = align_numbering(numbering, sequence_list)
@@ -108,16 +110,18 @@ def extract_sequence(
 ):
     """
     Get the amino acid sequence of the chain.
-    @change:    Residues containing HETATOMs are skipped -->  Residues containing HETATOMs are checked as an amino acid.
+    Residues containing HETATOMs are skipped -->  Residues containing HETATOMs are checked as an amino acid.
 
     Residues containing HETATOMs are checked  to be amino acids and the single letter returned.
 
     This works provided the residues in the chain are in the correct order.
 
-    @param selection: a selection object to select certain residues
-    @param return_warnings: Flag to return a list of warnings or not
-    @param backbone: Flag whether to only show residues with a complete backbone (in the structure) or not.
-    @return: The sequence in a resid:aa tuple list and the sequence as a string.
+    Args:
+        selection: a selection object to select certain residues
+        return_warnings: Flag to return a list of warnings or not
+        backbone: Flag whether to only show residues with a complete backbone (in the structure) or not.
+    Returns:
+        The sequence in a resid:aa tuple list and the sequence as a string.
 
     """
     sequence_list = []
@@ -257,9 +261,10 @@ def align_numbering(numbering, sequence_list, alignment_dict={}):
 def align_scTCR_numbering(numbering, sequence_list, sequence_str):
     """
     Align the sequence that has been numbered to a scTCR structure.
-    @param numbering:     numbered list of residues; this is usually a two-element list/tuple from TCRDB.anarci.number
-    @param sequence_list: list of residues (e.g. from a structure) in its original numbering
-    @param sequence_str:  string form of sequence_list
+    Args:
+        numbering:     numbered list of residues; this is usually a two-element list/tuple from TCRDB.anarci.number
+        sequence_list: list of residues (e.g. from a structure) in its original numbering
+        sequence_str:  string form of sequence_list
     """
     if numbering:
         numbered_sequence = ["".join([r[1] for r in n]) for n in numbering]
@@ -321,8 +326,9 @@ def cleanup_scTCR_numbering(numbering_dict, sequence_list):
     This is to close the gaps in the numbering so that residues that were unnumbered by anarci don't move around
     during structural parsing (when they're probably just connections between domains).
 
-    @param numbering_dict: numbered dictionary from align_scTCR_numbering
-    @param sequence_list : sequence list from the structure for alignment.
+    Args:
+        numbering_dict: numbered dictionary from align_scTCR_numbering
+        sequence_list : sequence list from the structure for alignment.
     """
     positions = [p[0] for p in sequence_list]
 

stcrpy/tcr_processing/utils/common.py

@@ -23,8 +23,9 @@ def identity(seq1, seq2, positions=[]):
     """
     Find the matched sequence identity between two aligned sequences.
     Can accept lists/strings, but this assumes that the two sequences are of the same length.
-    @param seq1: Dictionary with key as the position and value as the single letter amino acid code. or an aligned list or string
-    @param seq2: Dictionary with key as the position and value as the single letter amino acid code. or an aligned list or string
+    Args:
+        seq1: Dictionary with key as the position and value as the single letter amino acid code. or an aligned list or string
+        seq2: Dictionary with key as the position and value as the single letter amino acid code. or an aligned list or string
     """
     n = 0  # number
     m = 0  # match

stcrpy/tcr_processing/utils/constants.py

@@ -12,9 +12,10 @@ import re
 def tuplefy(x):
     """
     Interpretation for converting numbering (in string) into a tuple.
-
-    @param x: A string for the identifier of a numbered position. e.g "H100A".
-    @return : A tuple of the chain tupe followed by a tuple of residue id and insertion code. eg. ( H, (100, "A") )
+    Args:
+        x: A string for the identifier of a numbered position. e.g "H100A".
+    Returns:
+        A tuple of the chain tupe followed by a tuple of residue id and insertion code. eg. ( H, (100, "A") )
 
     """
     chain, resi, ins = re.split(r"(\d+)", x)

{stcrpy-1.0.0.dist-info → stcrpy-1.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stcrpy
-Version: 1.0.0
+Version: 1.0.3
 Summary: Set of methods to parse, annotate, and calculate features of TCR structures
 Maintainer: Nele Quast
 Maintainer-email: quast@stats.ox.ac.uk
@@ -102,7 +102,7 @@ pip install einops
 STCRpy [documentation](https://stcrpy.readthedocs.io/en/latest/) is hosted on ReadtheDocs.
 
 # Examples
-STCRpy generates and operates on TCR structure objects. The majority of the API can be accessed through functions of the format: `tcr.some_stcrpy_function()`. TCR objects are associated with their MHC and antigen if these are presented in the structure. 
+STCRpy generates and operates on TCR structure objects. The majority of the API can be accessed through functions of the format: [`tcr.some_stcrpy_function()`](https://stcrpy.readthedocs.io/en/latest/stcrpy.tcr_processing.html#stcrpy.tcr_processing.TCR.TCR). TCR objects are associated with their MHC and antigen if these are presented in the structure. 
 
 A notebook with examples can be found under [examples/STCRpy_examples.ipynb](./examples/STCRpy_examples.ipynb)
 

{stcrpy-1.0.0.dist-info → stcrpy-1.0.3.dist-info}/RECORD

@@ -11,7 +11,7 @@ stcrpy/tcr_formats/tcr_formats.py,sha256=ZLouBdpY1K8xOA7tORkfljE9iUsbn_oay4DRHvP
 stcrpy/tcr_formats/tcr_haddock.py,sha256=ejGs1DsOMKE-CDK5k9M4J-9y-7bLq_BbNLAkBNhpjjQ,21913
 stcrpy/tcr_geometry/TCRCoM.py,sha256=Mtq0ieQUTj2R_EN9BUFdUtSbT9AtI5OPi1TEdnMlxME,12883
 stcrpy/tcr_geometry/TCRCoM_LICENCE,sha256=93k_qqF0rgpyWEmxpcl2sbZS3CK1dkGrIuvJtKsBlCA,7844
-stcrpy/tcr_geometry/TCRDock.py,sha256=CEwcDbekOy5KvKw-_0DMMU4CwfK01km_NHg2lZaLquI,9911
+stcrpy/tcr_geometry/TCRDock.py,sha256=Uga1OV5owC-lVfzzKFn5dGEGnaeHJUHMpppdUxnK84k,9975
 stcrpy/tcr_geometry/TCRGeom.py,sha256=niol8kNMUufFkjxhOkFhBhonNIKpQwhl6V8qbVa7tLg,19041
 stcrpy/tcr_geometry/TCRGeomFiltering.py,sha256=JN02yyxeXy6XRH3oSKTskcUkxoqvxsvSRGpR-4H25kA,9666
 stcrpy/tcr_geometry/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -25,7 +25,7 @@ stcrpy/tcr_geometry/reference_data/reference_G.pdb,sha256=Fs8e_UDb6dI1qqhNSttWaH
 stcrpy/tcr_geometry/reference_data/reference_data.py,sha256=q3L-cQ1UQUfZxeIMKIiiase_6SEEuWlx7UsLndwNLAk,1658
 stcrpy/tcr_interactions/PLIPParser.py,sha256=zetY_LvH_8E-26xXc02c7_edoHWEwIWB9_XIu1szRcA,5785
 stcrpy/tcr_interactions/TCRInteractionProfiler.py,sha256=Q4OBQ3DooM592Sk5DnjeAJAAohVOkrbp8MAXNRTLnVg,17835
-stcrpy/tcr_interactions/TCRpMHC_PLIP_Model_Parser.py,sha256=wRY0gOoWMb5hDqPn6vKn5oLXCkMvoFgwuKSqYkB-MM8,4688
+stcrpy/tcr_interactions/TCRpMHC_PLIP_Model_Parser.py,sha256=-fm_rtPJhU-h3WuX1U5Cv3vjO0eAlzwbm1HTreQIDCI,5464
 stcrpy/tcr_interactions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 stcrpy/tcr_interactions/utils.py,sha256=KEGybd1ugZvFdj4Gqn9Xo4lnJbU1ivADmEDjkvuaNiw,5177
 stcrpy/tcr_methods/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -39,30 +39,30 @@ stcrpy/tcr_metrics/tcr_rmsd.py,sha256=cbK20z1ELjeEecPxZF3vQ4uDlorrAAb5C8D8YtTpwz
 stcrpy/tcr_ml/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 stcrpy/tcr_ml/geometry_predictor.py,sha256=D0w_Rx2PIwPQORyglvlugwI4wGg4xZyXUxRtIOEYyK0,38
 stcrpy/tcr_processing/AGchain.py,sha256=iVpiNMXOz3tnBIK0CYhq1EUdObMckGO6vkilwWQhjmU,2455
-stcrpy/tcr_processing/Chemical_components.py,sha256=8xcUg9HBya2_--hdAtMonECZeyl684wTvCUkrmUdPcE,2020304
-stcrpy/tcr_processing/Entity.py,sha256=5WZN5vcEFQfFxZCXcqr9exrA5vOlrH0I82LRNgPe3KY,11198
+stcrpy/tcr_processing/Chemical_components.py,sha256=KuJiV-SnATz1cWoZnZmamNaivOhPhrsIdjKK-VCtKgE,2020298
+stcrpy/tcr_processing/Entity.py,sha256=kY8oLVnmWOMMzj4Gj7ouE-IaxLHrlchX1Y2EAu8Sstw,11180
 stcrpy/tcr_processing/Fragment.py,sha256=QW_6sPWi2HX7mq5dLLwvA-7Q9oiBHCS0p02WgFLDisA,1908
 stcrpy/tcr_processing/Holder.py,sha256=y_q2NF0YiCf9CuXWlIm9-EWpD5CJj95o2wUCYDyEHOA,549
-stcrpy/tcr_processing/MHC.py,sha256=OfOb9aMKqcP9jM0TRFZo_ZQDB1idqCaJhn9rlBaAKA4,11736
+stcrpy/tcr_processing/MHC.py,sha256=71IiBc2t3_w4_BeA99SJV8RKwWxhEMYpZG3Q5akaV0A,13639
 stcrpy/tcr_processing/MHCchain.py,sha256=rT0FCkKD2pbZm-VTvcLwCdS5UOy-ibxnNcsgREIxgSs,4357
 stcrpy/tcr_processing/Model.py,sha256=K8wTrSCECHyqJX9811wU9MxgdGDVyCXraQ4-rOOa08U,1230
 stcrpy/tcr_processing/Select.py,sha256=VuVSgmqHBPD1DGRumM44HDzcQ-aQOwg_6zQHM3Ulm0U,3543
-stcrpy/tcr_processing/TCR.py,sha256=JR_CQovd7syVLd4k9tPYaFiwXpjP5dl51_-4hI2Phno,17206
+stcrpy/tcr_processing/TCR.py,sha256=DHkNZ309TTfn_Ou2XL0dACK5KVR3j4Sj5G-42cuELi4,24651
 stcrpy/tcr_processing/TCRIO.py,sha256=tSJLVN6MG6gyT26PreVJOz5DqD1e-VsBjBpu3mBBPKg,1501
-stcrpy/tcr_processing/TCRParser.py,sha256=D97-MTdbasEdtMR-mT6Up5tY2LK1LRgALVRrTearJJs,51162
+stcrpy/tcr_processing/TCRParser.py,sha256=DzRin1hQ6DfvRhPnt6pKiB6TJAzM5C7ivPwH39-m_hk,51738
 stcrpy/tcr_processing/TCRStructure.py,sha256=yFiUeo02KXIBBEljy0mebv5ol5uCQRTy-Sfs94Rt6Hc,3810
 stcrpy/tcr_processing/TCRchain.py,sha256=2CdP_JX5LG7nM8Lsuhcevf7SyRaQUZlizt3ntEYVPjg,4769
 stcrpy/tcr_processing/__init__.py,sha256=BefeJ0jefteeOzWrkOMvxLCvzd0aJDhXWrdTm7zlP94,94
-stcrpy/tcr_processing/annotate.py,sha256=aa3Bu_5UXC8H3C7jibBk0YapynhwPAP-Dx69cmGXRw8,17163
+stcrpy/tcr_processing/annotate.py,sha256=JDXsIooYewRzI8-Hh9sd84QJvPrc4GZ3MfN6A-jJPLU,17172
 stcrpy/tcr_processing/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-stcrpy/tcr_processing/utils/common.py,sha256=SmIbvf9-cH_T4ENBRNdAmhZ4buzRHDN-QY0csVB3pCo,1865
-stcrpy/tcr_processing/utils/constants.py,sha256=k16xeH8gMBdgdXy6h829kJ2qIHx2-sDnwv66zlf1aIA,8138
+stcrpy/tcr_processing/utils/common.py,sha256=5e-dP6jPlaFZEErusakdQYpyj79E3WvEGF5-sG0LitI,1869
+stcrpy/tcr_processing/utils/constants.py,sha256=AHReE1QkeqTnhjvQI7nrPqLF4XdtzHV9C1w1uHTiVcM,8151
 stcrpy/tcr_processing/utils/region_definitions.py,sha256=pWE3xJAhnGtLHWxvJOHaU5Y5spcHuZwPzcIDCsH920I,18806
 stcrpy/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 stcrpy/utils/error_stream.py,sha256=BLHJnf-tWU41MXh6sHSZgkTFOMiWZsCgwM2qIKBnwr4,247
-stcrpy-1.0.0.dist-info/licenses/LICENCE,sha256=G1FnVDsfeYoveKTu9Xaqukcm-4xZ4mzakjLpFMnNfJ0,1507
-stcrpy-1.0.0.dist-info/licenses/stcrpy/tcr_geometry/TCRCoM_LICENCE,sha256=93k_qqF0rgpyWEmxpcl2sbZS3CK1dkGrIuvJtKsBlCA,7844
-stcrpy-1.0.0.dist-info/METADATA,sha256=CEw0KlbcZz8peJ1s8nIrxet6yllG1XU0ZLx3cD0DD-Y,5785
-stcrpy-1.0.0.dist-info/WHEEL,sha256=ck4Vq1_RXyvS4Jt6SI0Vz6fyVs4GWg7AINwpsaGEgPE,91
-stcrpy-1.0.0.dist-info/top_level.txt,sha256=kAkgyHyGW-_YswJpcuA3pSqzuQVbUggFUmZg2OTx_B8,16
-stcrpy-1.0.0.dist-info/RECORD,,
+stcrpy-1.0.3.dist-info/licenses/LICENCE,sha256=G1FnVDsfeYoveKTu9Xaqukcm-4xZ4mzakjLpFMnNfJ0,1507
+stcrpy-1.0.3.dist-info/licenses/stcrpy/tcr_geometry/TCRCoM_LICENCE,sha256=93k_qqF0rgpyWEmxpcl2sbZS3CK1dkGrIuvJtKsBlCA,7844
+stcrpy-1.0.3.dist-info/METADATA,sha256=widJsCi2RfI9soEo0mPM1TUtgJopNRvPinR-n6Z3qYo,5885
+stcrpy-1.0.3.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
+stcrpy-1.0.3.dist-info/top_level.txt,sha256=kAkgyHyGW-_YswJpcuA3pSqzuQVbUggFUmZg2OTx_B8,16
+stcrpy-1.0.3.dist-info/RECORD,,

{stcrpy-1.0.0.dist-info → stcrpy-1.0.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.0.0)
+Generator: setuptools (80.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any