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

stcrpy/tcr_processing/annotate.py

@@ -38,18 +38,25 @@ 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
+    try:
+        from anarci import number as anarci_number
+    except ImportError as e:
+        f"""ANARCI import failed, is ANARCI installed and built? \nInstall ANARCI MHC with: \npip install anarci-mhc \n
+Once installed, build the HMMs with: \nANARCI --build_models. \nError raised was {e}"""
+        raise e
 
     numbering, chain_type, germline_info = anarci_number(
         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 +92,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 +115,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 +266,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 +331,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/tcr_processing/utils/region_definitions.py

@@ -10,6 +10,15 @@ IMGT_CDR_BOUNDARIES = {
     "3": {"imgt": (105, 117)},
 }
 
+IMGT_VARIABLE_DOMAIN: set[int] = set(range(1, 128 + 1))
+'''Variable domain range for IMGT numbered immunoglobulin structures.'''
+
+IMGT_MH1_ABD: set[int] = set(range(1, 92)) | set(range(1001, 1092))
+'''IMGT ranges of the antigen binding domain of MHC class I molecules.'''
+
+IMGT_MH2_ABD: set[int] = set(range(1, 92))
+'''IMGT ranges of the antigen binding domain of MHC class II molecules.'''
+
 # regions for TCR
 _regions = {"imgt": {}}
 _regions["imgt"]["A"] = _regions["imgt"]["B"] = (

stcrpy/tcr_processing/utils/symmetry_mates.py

@@ -0,0 +1,90 @@
+import warnings
+import tempfile
+import os
+
+from Bio.PDB import PDBParser, PDBIO
+from ..TCRParser import TCRParser
+
+
+def get_symmetry_mates(filename):
+    try:
+        from pymol import cmd
+    except ModuleNotFoundError:
+        warnings.warn(
+            "Pymol not installed - please install pymol to enabe symmetry mate TCR parsing. "
+        )
+        return []
+
+    cmd.load(filename)
+    obj_name = cmd.get_object_list()[0]
+    cmd.symexp(obj_name, obj_name, obj_name, cutoff=20.0, quiet=0)
+    if (
+        len(cmd.get_object_list()) == 1
+    ):  # No symmetry mates found, likely becuase file did not contain symmetry information
+        cmd.delete(obj_name)
+        cmd.fetch(
+            filename.split("/")[-1].split(".")[0]
+        )  # this will try to retrieve the file from the pdb directly, will not work if the filename is not the pdb code
+    if len(cmd.get_object_list()) == 0:
+        warnings.warn(f"No symmetry mates found for {filename}.")
+        return
+    obj_name = cmd.get_object_list()[0]
+    cmd.symexp(obj_name, obj_name, obj_name, cutoff=10.0, quiet=0)
+    tcr_symmetry_mates = []
+
+    tcp = TCRParser()
+    pdp = PDBParser(QUIET=True)
+    pdbio = PDBIO()
+    with tempfile.TemporaryDirectory() as tmpdir:
+        for i, obj in enumerate(cmd.get_object_list()):
+            fn = os.path.join(tmpdir, f"{obj_name}_symmetry_mate_{i}.pdb")
+            cmd.save(fn, obj)
+            symmetry_mate = pdp.get_structure("tmp", fn)
+            if i == 0:
+                chain_ids = generate_chain_id_list(
+                    len(list(symmetry_mate.get_chains()) * len(cmd.get_object_list()))
+                )
+                for c in symmetry_mate.get_chains():
+                    chain_ids.remove(
+                        c.id
+                    )  # remove all chain ids of the original structure
+            if i > 0:  # Skip the original structure
+                # rename chain ids, this cannot be done directly to TCR structure without breaking the TCR and MHC chain assignments.
+                for chain in reversed(list(symmetry_mate.get_chains())):
+                    symmetry_mate[0].detach_child(chain.id)
+                    new_id = chain_ids.pop(0)
+                    chain.id = new_id
+                    symmetry_mate[0].add(chain)
+                pdbio.set_structure(symmetry_mate)
+                pdbio.save(fn)
+
+                symmetry_mate = tcp.get_tcr_structure(
+                    f"{obj_name}_symmetry_{i}", fn, include_symmetry_mates=False
+                )
+                tcr_symmetry_mates.append(symmetry_mate)
+
+    # clean up the pymol cmd space
+    for obj in cmd.get_object_list():
+        cmd.delete(obj)
+    del cmd
+    return tcr_symmetry_mates
+
+
+def generate_chain_id_list(N):
+    """Generates a set of chain ids starting from A, B, C, ..., Z, AA, AB, ..., AZ, BA
+
+    Args:
+        N (int): The number of chain IDs to generate.
+
+    Returns:
+        set: A set of generated chain IDs.
+    """
+    chain_ids = []
+    for i in range(N):
+        ch1 = chr(65 + (i // 26) - 1) if i >= 26 else ""
+        ch2 = chr(65 + (i % 26))
+        chain_ids.append(ch1 + ch2)
+    import string
+
+    chain_ids = string.ascii_uppercase + string.ascii_lowercase + string.digits
+    return list(chain_ids)[:N]

stcrpy-1.0.5.dist-info/METADATA

@@ -0,0 +1,285 @@
+Metadata-Version: 2.4
+Name: stcrpy
+Version: 1.0.5
+Summary: Set of methods to parse, annotate, and calculate features of TCR structures
+Maintainer-email: Nele Quast <quast@stats.ox.ac.uk>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENCE
+License-File: stcrpy/tcr_geometry/TCRCoM_LICENCE
+Requires-Dist: biopython
+Requires-Dist: numpy==1.26.4
+Requires-Dist: lxml
+Requires-Dist: openbabel-wheel==3.1.1.21
+Requires-Dist: rdkit
+Requires-Dist: anarci-mhc
+Requires-Dist: pandas
+Requires-Dist: matplotlib
+Requires-Dist: scipy
+Requires-Dist: requests
+Requires-Dist: scikit-learn
+Requires-Dist: DockQ
+Provides-Extra: ml-datasets
+Requires-Dist: einops; extra == "ml-datasets"
+Requires-Dist: torch; extra == "ml-datasets"
+Requires-Dist: torch_geometric; extra == "ml-datasets"
+Dynamic: license-file
+
+
+
+<img src="./stcrpy_logo.png" alt="drawing" width="300"/>
+
+
+# STCRpy 
+[![stcrpy installation](https://github.com/npqst/STCRpy/actions/workflows/conda-workflow.yml/badge.svg)](https://github.com/npqst/STCRpy/actions/workflows/conda-workflow.yml)
+[![stcrpy unittests](https://github.com/npqst/STCRpy/actions/workflows/unittest-workflow.yml/badge.svg)](https://github.com/npqst/STCRpy/actions/workflows/unittest-workflow.yml)
+[![stcrpy_docs](https://readthedocs.org/projects/stcrpy/badge/?version=latest)](https://stcrpy.readthedocs.io/en/latest/)
+
+
+Structural TCR python (STCRpy) is a software suite for analysing and processing T-cell receptor structures. 
+
+Please feel free to reach out with any comments or feedback.
+
+Under review, please cite: 
+
+**Quast, N. , Deane, C., & Raybould, M. (2025). STCRpy: a software suite for TCR:pMHC structure parsing, interaction profiling, and machine learning dataset preparation. BioRxiv. https://doi.org/10.1101/2025.04.25.650667**
+
+<img src="./stcrpy_main_fig.png" alt="drawing" width="1500"/>
+
+
+
+# Installation
+
+## TL;DR installation
+```
+pip install stcrpy
+pip install plip
+conda install pymol-open-source -y
+ANARCI --build_models           # this step will take a few minutes
+```
+
+## Step by step installation
+We recommend installing STCRpy in a [conda](https://www.anaconda.com/docs/getting-started/miniconda/install#macos-linux-installation) (or [mamba](https://mamba.readthedocs.io/en/latest/installation/mamba-installation.html)) environment using python 3.9 to 3.12. You can also use a python virtual environment if you do not need pymol visualisations. 
+
+<details> <summary>conda</summary>
+
+```
+conda create -n stcrpy_env python==3.12 -y
+conda activate stcrpy_env
+```
+
+</details>
+<details> <summary>mamba</summary>
+
+```
+mamba create -n stcrpy_env python==3.12 -y
+mamba activate stcrpy_env
+```
+
+</details>
+<details> <summary>venv</summary>
+
+```
+python -m venv stcrpy_env
+source stcrpy_env/bin/activate
+```
+
+</details>
+
+
+The core functionality of STCRpy can be installed as follows:
+```
+pip install stcrpy
+```
+
+After installing stcrpy, the anarci HMM models must be built to enable annotation.
+```
+ANARCI --build_models           # this step will take a few minutes
+```
+
+To enable interaction profiling, install PLIP (Adasme et. al., 2021):
+```
+pip install plip
+```
+
+To enable pymol visualisations, install pymol open source locally within the environment. Unfortunately, pymol currently needs to be installed even if you already have a pymol version. Be sure to install pymol within a managed conda (or mamba) environment to prevent interference with any existing versions. 
+```
+conda install pymol-open-source -y
+```
+
+To generate pytorch and pytorch-geometric compatible datasets (see the [pytorch docs](https://pytorch.org/get-started/locally/) for hardware specific instructions): 
+```
+pip install stcrpy[ml_datasets]
+```
+
+> Note that the installs for pytorch can be platform specific.
+> If errors are ecountered here it is best to manually install the depedencies following the [pytorch installation docs](https://pytorch.org/get-started/locally/).
+> For example:
+> ```
+> pip install torch --index-url https://download.pytorch.org/whl/cpu
+> pip install torch_geometric
+> ```
+> This installs the CPU version of pytorch (for GPU / CUDA versions follow the install [pytorch installation docs](https://pytorch.org/get-started/locally/)).
+>
+> The EGNN example also uses `einops`. Which can be manually installed as follows:
+> ```
+> pip install einops
+> ```
+
+# Documentation
+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()`. ([See TCR object docs here](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)
+
+First import STCRpy:
+```
+import stcrpy
+```
+
+### To fetch a TCR structure from STCRDab or the PDB: 
+```
+multiple_tcrs = stcrpy.fetch_TCRs("8gvb")
+```
+This will return a list of all of the TCR structures found in the PDB file, represented as TCR structure objects.
+
+### To load a TCR structure from a PDB or MMCIF file:
+```
+tcr = stcrpy.load_TCR("filename.{pdb, cif}")
+```
+
+### To load multiple TCR structures from a list of files at once:
+```
+multiple_tcrs = stcrpy.load_TCRs([file_1, file_2, file_3])
+```
+
+### To save a TCR object to PDB or MMCIF files: 
+```
+tcr.save(filename.{pdb, cif})           # save the TCR and it's associated MHC and antigen
+tcr.save(filename.{pdb, cif}, TCR_only=True)           # save the TCR only
+```
+
+### To calculate the TCR to pMHC geometry:
+```
+tcr.calculate_geometry()            # change the 'mode' keyword argument to change the geometry calculation method. See paper / documentation for details.
+```
+
+### To score the TCR to pMHC geometry:
+```
+tcr.score_docking_geometry()
+```
+
+### To profile interactions: 
+```
+tcr.profile_peptide_interactions()          # interaction profiling parameters can be adjusted, see documentation for details
+```
+
+### To visualise interactions:
+```
+tcr.visualise_interactions()
+```
+
+### To run full analysis on a set of TCR structures: 
+```
+from stcrpy.tcr_methods.tcr_batch_operations import analyse_tcrs
+germlines_and_alleles_df, geometries_df, interactions_df = analyse_tcrs(list_or_dict_of_files)
+```
+
+### To generate graph datasets:
+```
+dataset = TCRGraphDataset(
+            root=PATH_TO_DATASET,
+            data_paths=PATH_TO_TCR_FILES
+        )
+```
+
+### To calculate TCR prediction metrics such as RMSD, interface RMSD (of the TCR:pMHC interface) or DockQ scores:
+
+```
+# RMSD
+from stcrpy.tcr_metrics import RMSD
+
+rmsd_calculator = RMSD()
+rmsd = rmsd_calculator.calculate_rmsd(pred_tcr, reference_tcr, save_alignment=False)      # Calculates the RMSD of each region of the TCR. To check the alignment set save_alignment to True.
+
+# To calculate RMSD for a set of predictions against a set of reference structures from files: 
+files = list(zip(prediction_files, reference_files))
+rmsd_df = rmsd_calculator.rmsd_from_files(files)
+
+
+
+# Interface RMSD of TCR:pMHC interface
+from stcrpy.tcr_metrics import InterfaceRMSD
+
+interface_rmsd_calculator = InterfaceRMSD()
+irmsds = interface_rmsd_calculator.get_interface_rmsd(tcr, reference_tcr)
+
+# DockQ
+from stcrpy.tcr_metrics.tcr_dockq import TCRDockQ
+
+dockq_calculator = TCRDockQ()               # by default this will merge the TCR and pMHC chains and calculate DockQ of the complete TCR:pMHC interface. To calculate DockQ scores per chain, use TCR_pMHC_interface=False
+dockq_results = dockq_calculator.tcr_dockq(tcr, reference_tcr, save_merged_complex=False)           # to investigate the merged TCR:pMHC structure set save_merged_complex=True 
+
+```
+
+### Torsion angles and internal coordinates
+STCRpy builds upon the Biopython PDB module, and you can calculate the internal coordinates, such as backbone torsion angles, using the [`internal_coordinates` function](https://biopython.org/docs/dev/api/Bio.PDB.internal_coords.html).
+
+```
+# internal coordinate calculations should be made per chain
+for c in tcr.get_chains():
+    c.atom_to_internal_coordinates()            # calculate the internal coordinates 
+
+# internal coordinates can be accessed per residue: 
+res = next(tcr.get_residues())
+res.internal_coord.get_angle("psi")         # retrieve angles via angle keys
+```
+
+### Domain angles between TCR chains
+STCRpy can be used to calculate the geometry and angles between the TCR variable domains of abTCRs and gdTCRs. This follows the ABangle implementation [(Dunbar et al. 2013)](https://academic.oup.com/peds/article/26/10/611/1509255).
+```
+tcr.get_TCR_angles()
+
+# returns dictionary of TCR domain angles and measurements.
+# For example: 
+# {
+#    'BA': -56.72234454750631,
+#    'BC1': 122.55277240895967,
+#    'AC1': 73.96532018128327,
+#    'BC2': 82.63524566165464,
+#    'AC2': 99.60327202896609,
+#    'dc': np.float64(15.606353954437227)
+# }
+
+```
+
+
+# Symmetry mate handling
+Some TCR:pMHC crystals are formed of repeating cell units in which the TCR and the antigen do not directly contact. 
+STCRpy generates symmetry mates in these cases to pair pMHC with TCRs in the structure. 
+Note that symmetry mate generation requires pymol to be installed. By default, symmetry mate generation is enabled, however, it can be toggled by setting: 
+`include_symmetry_mates=False` in `get_tcr_structure`. 
+
+## Example: 
+```
+tcr_6ulr_paired_antigen = stcrpy.fetch_TCRs("6ulr")
+tcr_6ulr_no_antigen = stcrpy.fetch_TCRs("6ulr", include_symmetry_mates=False)       # does not generate symmetry mates
+
+```
+
+
+
+# Limitations
+
+## Connected peptide chains
+STCRpy is currently not configured to handle cases where the antigen peptide is connected to the TCR or MHC chain - this is primarily because the parsing pipeline operates on chain objects and it can be tricky to consistently separate the peptide segment from the remainder of the TCR chain. A known case is PDB code 6MNO. 
+
+## Gamma-Delta TCR geometry
+STCRpy supports gamma-delta TCR parsing, interaction profiling and visusalisation, but is not currently configured to calculate gd-TCR geometry.
+
+## MHC Class II geometry scoring
+STCRpy can be used to calculate and characterise the geometries of TCRs to MHC class II antigen, however, due to the smaller number of complexes we have not fit parametric distributions to the geometry features, which means it is not possible to calculate a geometry score.
+
+

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

@@ -1,68 +1,79 @@
 examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 examples/egnn.py,sha256=ab9OMeJ--a1XkTa5nF7y8-B0XNpS5LCuK1x5lEnyz3o,13812
-stcrpy/__init__.py,sha256=D5Ela4G19FPIFzO5CpyzJMnrvvoTNQUwz1s-qb0waDo,252
+stcrpy/__init__.py,sha256=ULJpFjOVfuUjI5F1DuWlMxNI5t6Fsrvf8IVCqVJ9OxI,253
 stcrpy/tcr_datasets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 stcrpy/tcr_datasets/tcr_graph_dataset.py,sha256=q8Di7sxgO-Rtzn7eVi_UMx4Sk9A31nvIxO7n_Nie-d0,19614
 stcrpy/tcr_datasets/tcr_selector.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 stcrpy/tcr_datasets/tcr_structure_dataset.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 stcrpy/tcr_datasets/utils.py,sha256=t_ogJu4hoI-ywr5-MnepuB-3L5-YXFoKQzyaONsDMFM,4888
 stcrpy/tcr_formats/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-stcrpy/tcr_formats/tcr_formats.py,sha256=ZLouBdpY1K8xOA7tORkfljE9iUsbn_oay4DRHvP5Wbc,3812
+stcrpy/tcr_formats/tcr_formats.py,sha256=RG6P7oDZSzsTDobngv0K9qHhJM7-tmSjwQSDP3CpN3A,4342
 stcrpy/tcr_formats/tcr_haddock.py,sha256=ejGs1DsOMKE-CDK5k9M4J-9y-7bLq_BbNLAkBNhpjjQ,21913
+stcrpy/tcr_geometry/TCRAngle.py,sha256=1tIoJ2RIxQPH2_ne9w-UlUKGsBlfsc2oarJVIkt9VHQ,6330
 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
+stcrpy/tcr_geometry/reference_data/Acoreset.txt,sha256=VDcDb_Uf5D_wNEwVtRZM9kcehodwIhl5fQ9Jfh0ncw0,125
+stcrpy/tcr_geometry/reference_data/Bcoreset.txt,sha256=zZw-eZIflcAy9k8z1t869g75lU4ZRj75VtH5ztLA50k,121
 stcrpy/tcr_geometry/reference_data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+stcrpy/tcr_geometry/reference_data/consensus_A.pdb,sha256=sA75dr5KcpND-pvQ5jFEkmWTUbJTwkOoSWLEMWp4nNo,2433
+stcrpy/tcr_geometry/reference_data/consensus_B.pdb,sha256=gXBhVfKKLbNRP3gyq7K7ofLMgEXKWeVdYJQI0Ws_NKg,2434
+stcrpy/tcr_geometry/reference_data/consensus_D.pdb,sha256=O9LHeh3bWxeEWwuTcp1HwzxzEfPfGOSAUHe4nMI-Okc,2434
+stcrpy/tcr_geometry/reference_data/consensus_G.pdb,sha256=Fs8e_UDb6dI1qqhNSttWaHrzkjgzjFpMpC38_W9OXTg,2434
 stcrpy/tcr_geometry/reference_data/dock_reference_1_imgt_numbered.pdb,sha256=wjzvP6_fhMoUp4b1Q18_-JXHpl8kKbqjFvLiglW2Yek,530400
 stcrpy/tcr_geometry/reference_data/dock_reference_2_imgt_numbered.pdb,sha256=sXUJ7CKGnA9FevyocJj30VA2EqgYM0s0ejRgBP6R9Gk,526026
+stcrpy/tcr_geometry/reference_data/pcA.txt,sha256=SNqBtyHeeL9dSJHzMUhjfO9zhH61Qn8fCORpsPnkH8w,99
+stcrpy/tcr_geometry/reference_data/pcB.txt,sha256=IEHoYprUz56JnV3sNOMApNKmapnk18WtelCGwok5YgU,100
 stcrpy/tcr_geometry/reference_data/reference_A.pdb,sha256=sA75dr5KcpND-pvQ5jFEkmWTUbJTwkOoSWLEMWp4nNo,2433
 stcrpy/tcr_geometry/reference_data/reference_B.pdb,sha256=gXBhVfKKLbNRP3gyq7K7ofLMgEXKWeVdYJQI0Ws_NKg,2434
 stcrpy/tcr_geometry/reference_data/reference_D.pdb,sha256=O9LHeh3bWxeEWwuTcp1HwzxzEfPfGOSAUHe4nMI-Okc,2434
 stcrpy/tcr_geometry/reference_data/reference_G.pdb,sha256=Fs8e_UDb6dI1qqhNSttWaHrzkjgzjFpMpC38_W9OXTg,2434
 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/TCRInteractionProfiler.py,sha256=56NeZZVIAjEqbbsM_qepjJQjoaR-RFt5OhhtcebiunI,17772
+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
-stcrpy/tcr_methods/tcr_batch_operations.py,sha256=YtRgui5H8MyR0zyGDGk1pwaydhQBYbepkRB1XspzpuQ,8363
-stcrpy/tcr_methods/tcr_methods.py,sha256=ghWO-F4sOCv1BOxMLC-nSbGxpY4B6L88v-IF13cV2FM,5553
+stcrpy/tcr_methods/tcr_batch_operations.py,sha256=-nh4EqgEYE8rx5-1iiVBJucc-r0nGizqj1S9S9LlNb0,8539
+stcrpy/tcr_methods/tcr_methods.py,sha256=k1DoZYVSnNLkikpP5bFAZaSa4DS41vwiHtXVIz_9vCQ,5569
 stcrpy/tcr_methods/tcr_reformatting.py,sha256=lgWyYOrk30fCY0IoDBI6IuIqeXdH0ukKX_x9LAdLVfk,625
 stcrpy/tcr_metrics/__init__.py,sha256=vy80DujN4kMr_rlFPWtLY48mIbsXK_SfTwzzgfQIY_E,73
 stcrpy/tcr_metrics/constants.py,sha256=uocAA2RM1JSE6n0gq1RDnZIcd3JROi9wDvJ-J4yc_IY,406
+stcrpy/tcr_metrics/tcr_dockq.py,sha256=G4Px1lT5OjSirdIgMQ0X7G2Nj_1DJCD0Dkjclv0QMlQ,17320
 stcrpy/tcr_metrics/tcr_interface_rmsd.py,sha256=Gsv6XDO6r4N9dCo--CyOkneni1gVf2X1Ws2y6vXuj2M,9605
 stcrpy/tcr_metrics/tcr_rmsd.py,sha256=cbK20z1ELjeEecPxZF3vQ4uDlorrAAb5C8D8YtTpwz4,6811
 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=bKNs_dOiTUpqBZnTDlvGjWHH8TaVQrRo-ieYYPULXFY,26299
 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=dcMdw2WEGa-BUZUqAAe0Dw4U2Qyh1xYUaS4N7E7J2AQ,33220
 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=Raz2W9tygpK3knzjIVCfqUyCGSFA7yhh4UBT5wuWLM4,56134
 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=MGk4UzLGtGL_J_ySPYoUTszOfzQjsWCpeeaXrza7Bfo,17438
 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/region_definitions.py,sha256=pWE3xJAhnGtLHWxvJOHaU5Y5spcHuZwPzcIDCsH920I,18806
+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=t3HT6FHFlGqS_DdV2xWLdTxhIUEjWHsf_0_f-06w94E,19198
+stcrpy/tcr_processing/utils/symmetry_mates.py,sha256=9U29IHs63llBzV9xBNCmv4BKTIachwO7T3orHywDn48,3262
 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.5.dist-info/licenses/LICENCE,sha256=G1FnVDsfeYoveKTu9Xaqukcm-4xZ4mzakjLpFMnNfJ0,1507
+stcrpy-1.0.5.dist-info/licenses/stcrpy/tcr_geometry/TCRCoM_LICENCE,sha256=93k_qqF0rgpyWEmxpcl2sbZS3CK1dkGrIuvJtKsBlCA,7844
+stcrpy-1.0.5.dist-info/METADATA,sha256=6rbC0l_TnXd9UMykkNKAlQCsy4VuBBud4DPQEXh-FtY,10512
+stcrpy-1.0.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+stcrpy-1.0.5.dist-info/top_level.txt,sha256=kAkgyHyGW-_YswJpcuA3pSqzuQVbUggFUmZg2OTx_B8,16
+stcrpy-1.0.5.dist-info/RECORD,,

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

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