gemmi-protools 0.1.16__py3-none-any.whl → 1.0.0__py3-none-any.whl

gemmi_protools/{utils → tools}/align.py

@@ -2,33 +2,25 @@
 @Author: Luo Jiejian
 """
 import os
-import pathlib
 import re
 import shutil
 import subprocess
 import tempfile
-import uuid
-from copy import deepcopy
-from typing import Union, Dict, Any, List, Optional
+from typing import Dict, Any, List, Optional
 
 import numpy as np
 from Bio.PDB import Superimposer
-from typeguard import typechecked
-
 from gemmi_protools.io.convert import gemmi2bio, bio2gemmi
 from gemmi_protools.io.reader import StructureParser
 
 
 class StructureAligner(object):
-    @typechecked
-    def __init__(self, query_path: Union[str, pathlib.Path], ref_path: Union[str, pathlib.Path]):
+    def __init__(self, query_path: str, ref_path: str):
         self._query_st = StructureParser()
         self._query_st.load_from_file(query_path)
-        self._query_st.set_default_model()
 
         self._ref_st = StructureParser()
         self._ref_st.load_from_file(ref_path)
-        self._ref_st.set_default_model()
 
         self.values = dict()
         self.rot_mat = None
@@ -49,8 +41,7 @@ class StructureAligner(object):
             return _path
 
     @staticmethod
-    @typechecked
-    def __parser_rotation_matrix(matrix_file: Union[str, pathlib.Path]):
+    def __parser_rotation_matrix(matrix_file: str):
         rotation_matrix = []
         translation_vector = []
 
@@ -66,7 +57,6 @@ class StructureAligner(object):
                     T=np.array(translation_vector).astype(np.float32))
 
     @staticmethod
-    @typechecked
     def __parse_terminal_outputs(output_string: str) -> Dict[str, Any]:
         lines = re.split(pattern=r"\n", string=output_string)
         # chain mapping
@@ -108,7 +98,6 @@ class StructureAligner(object):
                         del patterns[key]
         return values
 
-    @typechecked
     def make_alignment(self, query_chains: Optional[List[str]] = None,
                        ref_chains: Optional[List[str]] = None, timeout=300.0):
         """
@@ -122,56 +111,50 @@ class StructureAligner(object):
         program_path = self.__mmalign_path
 
         # clone
-        q_st = deepcopy(self._query_st)
-        r_st = deepcopy(self._ref_st)
-
-        tmp_dir = os.path.join(tempfile.gettempdir(), str(uuid.uuid4()))
-        os.makedirs(tmp_dir)
-
         if isinstance(query_chains, list):
-            q_st.pick_chains(query_chains)
+            q_st = self._query_st.pick_chains(query_chains)
+        else:
+            q_st = self._query_st
 
         if isinstance(ref_chains, list):
-            r_st.pick_chains(ref_chains)
+            r_st = self._ref_st.pick_chains(query_chains)
+        else:
+            r_st = self._ref_st
 
-        q_ch_mapper = q_st.make_chain_names_to_one_letter()
-        r_ch_mapper = r_st.make_chain_names_to_one_letter()
+        q_ch_mapper = q_st.make_one_letter_chain()
+        r_ch_mapper = r_st.make_one_letter_chain()
 
         q_ch_mapper_r = {v: k for k, v in q_ch_mapper.items()}
         r_ch_mapper_r = {v: k for k, v in r_ch_mapper.items()}
 
-        _tmp_a = os.path.join(tmp_dir, "a.pdb")
-        q_st.to_pdb(_tmp_a)
-
-        _tmp_b = os.path.join(tmp_dir, "b.pdb")
-        r_st.to_pdb(_tmp_b)
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            _tmp_a = os.path.join(tmp_dir, "a.pdb")
+            q_st.to_pdb(_tmp_a)
+
+            _tmp_b = os.path.join(tmp_dir, "b.pdb")
+            r_st.to_pdb(_tmp_b)
+
+            matrix_file = os.path.join(tmp_dir, "m.txt")
+            _command = "%s %s %s -m %s" % (program_path, _tmp_a, _tmp_b, matrix_file)
+
+            try:
+                result = subprocess.run(_command, shell=True, check=True,
+                                        stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+                                        timeout=timeout)
+            except Exception as e:
+                print("%s: between files %s and %s; between chains: %s and %s" % (
+                    str(e), self.query_path, self.ref_path,
+                    str(q_st.chain_ids), str(r_st.chain_ids))
+                      )
+            else:
+                self.values = self.__parse_terminal_outputs(result.stdout.decode())
+                self.rot_mat = self.__parser_rotation_matrix(matrix_file)
+                self.is_aligned = True
+                self.by_query = q_st.chain_ids if query_chains is None else query_chains
+                self.by_ref = r_st.chain_ids if ref_chains is None else ref_chains
+                self.values["query_chain_ids"] = [q_ch_mapper_r.get(ch, ch) for ch in self.values["query_chain_ids"]]
+                self.values["ref_chain_ids"] = [r_ch_mapper_r.get(ch, ch) for ch in self.values["ref_chain_ids"]]
 
-        matrix_file = os.path.join(tmp_dir, "m.txt")
-        _command = "%s %s %s -m %s" % (program_path, _tmp_a, _tmp_b, matrix_file)
-
-        try:
-            result = subprocess.run(_command, shell=True, check=True,
-                                    stdout=subprocess.PIPE, stderr=subprocess.PIPE,
-                                    timeout=timeout)
-        except Exception as e:
-            print("%s: between files %s and %s; between chains: %s and %s" % (
-                str(e), self.query_path, self.ref_path,
-                str(q_st.chain_ids), str(r_st.chain_ids))
-                  )
-        else:
-            self.values = self.__parse_terminal_outputs(result.stdout.decode())
-            self.rot_mat = self.__parser_rotation_matrix(matrix_file)
-            self.is_aligned = True
-            self.by_query = q_st.chain_ids if query_chains is None else query_chains
-            self.by_ref = r_st.chain_ids if ref_chains is None else ref_chains
-            self.values["query_chain_ids"] = [q_ch_mapper_r.get(ch, ch) for ch in self.values["query_chain_ids"]]
-            self.values["ref_chain_ids"] = [r_ch_mapper_r.get(ch, ch) for ch in self.values["ref_chain_ids"]]
-
-        finally:
-            if os.path.isdir(tmp_dir):
-                shutil.rmtree(tmp_dir)
-
-    @typechecked
     def save_aligned_query(self, out_file: str):
         """
 

gemmi_protools/tools/dockq.py

@@ -0,0 +1,127 @@
+"""
+@Author: Luo Jiejian
+"""
+import json
+import os
+import shutil
+import subprocess
+import tempfile
+from copy import deepcopy
+from typing import List, Tuple
+
+import gemmi
+import pandas as pd
+from gemmi_protools.io.reader import StructureParser
+
+
+def dockq_score_interface(query_model: str,
+                          native_model: str,
+                          partner_1_mapping: List[Tuple[str, str]],
+                          partner_2_mapping: List[Tuple[str, str]],
+                          ):
+    """
+    Calculate Dockq Score for an interface (partner 1 vs partner 2)
+
+    :param query_model: str or pathlib.Path
+        Path of query model, support .pdb, .pdb.gz, .cif, .cif.gz
+    :param native_model:
+    :param partner_1_mapping: a list of chain ID mapping between query and native for partner1 of the interface
+        e.g. [(q chain1, n chain1), (q chain2, n chain2)]
+    :param partner_2_mapping:
+    :return:
+    """
+    dockq_program = shutil.which("DockQ")
+    if dockq_program is None:
+        raise RuntimeError("DockQ is need")
+
+    assert len(partner_1_mapping) > 0, "partner_1_mapping must be a list of chain ID tuples, can't be empty"
+    assert len(partner_2_mapping) > 0, "partner_2_mapping must be a list of chain ID tuples, can't be empty"
+
+    def load_struct(path: str, partner_1: List[str], partner_2: List[str]):
+        st = StructureParser()
+        st.load_from_file(path)
+        st.clean_structure()
+
+        for ch in partner_1 + partner_2:
+            if ch not in st.chain_ids:
+                raise ValueError("Chain %s not found for %s (only [%s])" % (ch, path, " ".join(st.chain_ids)))
+
+        # merge chains in each each partner into on chain
+        # partner_1 with chain ID A
+        # partner_2 with chain ID B
+
+        chain_a = gemmi.Chain("A")
+        idx_a = 1
+        for ch in partner_1:
+            for res in st.get_chain(ch):
+                nr = deepcopy(res)
+                nr.seqid.icode = " "
+                nr.seqid.num = idx_a
+                chain_a.add_residue(nr)
+                idx_a += 1
+
+        chain_b = gemmi.Chain("B")
+        idx_b = 1
+        for ch in partner_2:
+            for res in st.get_chain(ch):
+                nr = deepcopy(res)
+                nr.seqid.icode = " "
+                nr.seqid.num = idx_b
+                chain_b.add_residue(nr)
+                idx_b += 1
+
+        model = gemmi.Model(1)
+        model.add_chain(chain_a)
+        model.add_chain(chain_b)
+
+        struct = gemmi.Structure()
+        struct.add_model(model)
+
+        output = StructureParser(struct)
+        return output
+
+    partner_1_query, partner_1_native = list(zip(*partner_1_mapping))
+    partner_2_query, partner_2_native = list(zip(*partner_2_mapping))
+
+    q_st = load_struct(query_model, list(partner_1_query), list(partner_2_query))
+    n_st = load_struct(native_model, list(partner_1_native), list(partner_2_native))
+
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        result_file = os.path.join(tmp_dir, "result.json")
+        q_file = os.path.join(tmp_dir, "q.pdb")
+        n_file = os.path.join(tmp_dir, "n.pdb")
+        q_st.to_pdb(q_file, write_minimal_pdb=True)
+        n_st.to_pdb(n_file, write_minimal_pdb=True)
+
+        mapping = "AB:AB"
+
+        _command = "%s --mapping %s --json %s %s %s" % (dockq_program, mapping, result_file, q_file, n_file)
+        metrics = ['DockQ', 'F1', 'chain1', 'chain2']
+
+        try:
+            _ = subprocess.run(_command, shell=True, check=True,
+                               stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+                               timeout=300.0)
+        except subprocess.CalledProcessError as e:
+            # Handle errors in the called executable
+            msg = e.stderr.decode()
+            outputs = pd.DataFrame(columns=metrics)
+        except Exception as e:
+            # Handle other exceptions such as file not found or permissions issues
+            msg = str(e)
+            outputs = pd.DataFrame(columns=metrics)
+        else:
+            with open(result_file, "r") as fin:
+                vals = json.load(fin)
+            msg = "Finished"
+            result = []
+            for v in vals["best_result"].values():
+                result.append(v)
+            outputs = pd.DataFrame(result)[metrics]
+
+        if len(outputs) > 0:
+            score = "%.4f" % outputs.iloc[0]["DockQ"]
+        else:
+            score = ""
+
+        return score

gemmi_protools/tools/mesh.py

@@ -0,0 +1,95 @@
+"""
+@Author: Luo Jiejian
+"""
+import os
+import subprocess
+import tempfile
+from typing import Optional, List
+
+import numpy as np
+import trimesh
+from Bio.PDB import Selection
+from Bio.PDB.ResidueDepth import _get_atom_radius, _read_vertex_array
+from gemmi_protools import StructureParser
+from gemmi_protools import gemmi2bio
+
+
+def _read_face_array(filename: str):
+    with open(filename) as fp:
+        face_list = []
+        for line in fp:
+            sl = line.split()
+            if len(sl) != 5:
+                # skip header
+                continue
+            vl = [int(x) for x in sl[0:3]]
+            face_list.append(vl)
+    return np.array(face_list)
+
+
+def get_mesh(struct_file: str, chains: Optional[List[str]] = None, MSMS: str = "msms"):
+    """
+
+    :param struct_file: str
+        .pdb, .cif, .pdb.gz, .cif.gz
+    :param chains: a list of chain names
+        default None to include all chains
+    :param MSMS: str
+        path of msms executable
+    :return:
+        https://ccsb.scripps.edu/msms/downloads/
+    """
+
+    try:
+        st = StructureParser()
+        st.load_from_file(struct_file)
+        st.clean_structure(remove_ligand=True)
+
+        bio_st = gemmi2bio(st.STRUCT)
+        model = bio_st[0]
+
+        # Replace pdb_to_xyzr
+        # Make x,y,z,radius file
+        atom_list = Selection.unfold_entities(model, "A")
+
+        xyz_tmp = tempfile.NamedTemporaryFile(delete=False).name
+        with open(xyz_tmp, "w") as pdb_to_xyzr:
+            for atom in atom_list:
+                x, y, z = atom.coord
+                radius = _get_atom_radius(atom, rtype="united")
+                pdb_to_xyzr.write(f"{x:6.3f}\t{y:6.3f}\t{z:6.3f}\t{radius:1.2f}\n")
+
+        # Make surface
+        surface_tmp = tempfile.NamedTemporaryFile(delete=False).name
+        msms_tmp = tempfile.NamedTemporaryFile(delete=False).name
+        MSMS = MSMS + " -no_header -probe_radius 1.5 -if %s -of %s > " + msms_tmp
+        make_surface = MSMS % (xyz_tmp, surface_tmp)
+        subprocess.call(make_surface, shell=True)
+        face_file = surface_tmp + ".face"
+        surface_file = surface_tmp + ".vert"
+        if not os.path.isfile(surface_file):
+            raise RuntimeError(
+                f"Failed to generate surface file using command:\n{make_surface}"
+            )
+
+    except Exception as e:
+        print(str(e))
+        mesh = None
+    else:
+        # Read surface vertices from vertex file
+        vertices = _read_vertex_array(surface_file)
+        faces = _read_face_array(face_file)
+        mesh = trimesh.Trimesh(vertices=vertices, faces=faces - 1)
+        mesh.merge_vertices()
+        mesh.update_faces(mesh.unique_faces())
+        mesh.update_faces(mesh.nondegenerate_faces())
+        mesh.remove_unreferenced_vertices()
+    finally:
+        # Remove temporary files
+        for fn in [xyz_tmp, surface_tmp, msms_tmp, face_file, surface_file]:
+            try:
+                os.remove(fn)
+            except OSError:
+                pass
+
+    return mesh

gemmi_protools/{utils → tools}/pdb_annot.py

@@ -2,25 +2,17 @@
 @Author: Luo Jiejian
 """
 import hashlib
-import itertools
 import os
 import re
 import shutil
 import subprocess
 import uuid
 from collections import defaultdict
-from dataclasses import asdict
 from importlib.resources import files
-from typing import List
 
-import numpy as np
 from anarci import run_anarci
 from anarci.germlines import all_germlines
-from joblib import Parallel, delayed
-from scipy.spatial import cKDTree
-
 from gemmi_protools import StructureParser
-from gemmi_protools.utils.ppi import _ppi_atoms
 
 
 def hash_sequence(seq: str) -> str:
@@ -207,125 +199,48 @@ def annotate_mhc(seq_dict: dict):
     return out
 
 
-def _interface_residues(struct: StructureParser,
-                        chains_x: List[str],
-                        chains_y: List[str],
-                        threshold: float = 4.5):
-    """
-    identify PPI among protein, DNA, RNA
-    :param struct: StructureParser
-    :param chains_x:
-    :param chains_y:
-    :param threshold:
-    :return:
-     PPI residues of chains_x, PPI residues of chains_y
-    """
-
-    x_coord, x_id = _ppi_atoms(struct, chains_x)
-    y_coord, y_id = _ppi_atoms(struct, chains_y)
-
-    kd_tree_x = cKDTree(x_coord)
-    kd_tree_y = cKDTree(y_coord)
-
-    pairs = kd_tree_x.sparse_distance_matrix(kd_tree_y, threshold, output_type='coo_matrix')
-
-    x_res = np.unique(x_id[pairs.row][["ch_name", 'res_num', 'res_icode', 'res_name']])
-    y_res = np.unique(y_id[pairs.col][["ch_name", 'res_num', 'res_icode', 'res_name']])
-
-    x_out = ["%s/%d/%s/%s" % (a, b, c.strip(), d) for a, b, c, d in x_res.tolist()]
-    y_out = ["%s/%d/%s/%s" % (a, b, c.strip(), d) for a, b, c, d in y_res.tolist()]
-    return x_out, y_out
-
-
-def polymer_interface_residues(struct: StructureParser,
-                               ppi_threshold: float = 4.5,
-                               n_cpus: int = 1,
-                               ):
-    """
-
-    Args:
-        struct:
-        ppi_threshold:
-
-    Returns:
-
-    """
-    chains = [ch for ch, ct in struct.chain_types.items() if ct in ["protein", "dna", "rna"]]
-    ch_pairs = list(itertools.combinations(chains, r=2))
-    ch_pairs.sort()
-
-    def _run(ch_1, ch_2):
-        key = "%s/%s" % (ch_1, ch_2)
-        res_x, res_y = _interface_residues(struct, chains_x=[ch_1], chains_y=[ch_2], threshold=ppi_threshold)
-        if len(res_x) > 0:
-            return {key: [res_x, res_y]}
-        else:
-            return dict()
-
-    cpu2use = max(min(n_cpus, len(ch_pairs)), 1)
-
-    outputs = dict()
-    if cpu2use == 1 or len(ch_pairs) < 100:
-        for ch_1, ch_2 in ch_pairs:
-            outputs.update(_run(ch_1, ch_2))
-    else:
-        results = Parallel(n_jobs=cpu2use)(delayed(_run)(c1, c2) for c1, c2 in ch_pairs)
-        for item in results:
-            outputs.update(item)
-    return outputs
-
-
-def annotate_pdb(struct_file: str, ppi_threshold: float = 4.5,
-                 n_cpus: int = 1, max_seqs: int = 100):
+def annotate_pdb(struct_file: str):
     st = StructureParser()
     st.load_from_file(struct_file)
-    st.set_default_model()
-    st.STRUCT.remove_alternative_conformations()
-    st.STRUCT.remove_ligands_and_waters()
-    st.STRUCT.remove_hydrogens()
-    st.STRUCT.remove_empty_chains()
-    st.update_entity()
+    st.clean_structure()
 
-    if len(st.chain_ids) > max_seqs:
-        raise RuntimeError("Too many chains: %d > %d" % (len(st.chain_ids), max_seqs))
+    subchain_id2entity_id = dict()
+    for ent in st.STRUCT.entities:
+        for ch in ent.subchains:
+            subchain_id2entity_id[ch] = ent.name
 
     # Merge sequences
     polymers = dict()
-    for ch, seq in st.polymer_sequences.items():
-        hash_id = hash_sequence(seq)
+    for ch, seq in st.polymer_sequences().items():
+        subchain_id = st.get_chain(ch).get_polymer().subchain_id()
+        entity_id = subchain_id2entity_id[subchain_id]
+
+        hash_id = hash_sequence(seq.upper())
         if hash_id not in polymers:
             val = dict(chain_ids=[ch],
-                       sequence=seq,
-                       type=st.chain_types[ch],
-                       description=st.ENTITY.eid2desc.get(st.ENTITY.polymer2eid[ch], "Unknown"),
-                       specie=st.ENTITY.eid2specie.get(st.ENTITY.polymer2eid[ch], "Unknown"),
-                       taxid=st.ENTITY.eid2taxid.get(st.ENTITY.polymer2eid[ch], "Unknown"),
+                       sequence=seq.upper(),
+                       type=st.polymer_types[ch].name,
+                       description=st.INFO["description"].get(entity_id, "Unknown"),
                        )
             polymers[hash_id] = val
         else:
             polymers[hash_id]["chain_ids"].append(ch)
 
-    sdict = {k: v["sequence"] for k, v in polymers.items()}
-
+    proteins = dict()
     results = dict()
-    for hasd_id, val in polymers.items():
+    for hash_id, val in polymers.items():
         val["chain_ids"].sort()
-        if val["type"] == "protein":
+        if val["type"] == "PeptideL":
+            proteins[hash_id] = val["sequence"]
             anarci_info = get_fv_region(val["sequence"])
             fvt = fv_region_type(anarci_info)
             if fvt != "not-Fv":
-                results[hasd_id] = dict(fv_type=fvt, annotations=anarci_info)
-
-    struct_info = asdict(st.INFO)
-    struct_info.update(resolution=st.STRUCT.resolution)
-    struct_info["pdb_id"] = struct_info["pdb_id"].lower()
-    struct_info["exp_method"] = struct_info["exp_method"].lower()
+                results[hash_id] = dict(fv_type=fvt, annotations=anarci_info)
 
+    struct_info = {k: st.INFO[k] for k in ["resolution", "pdb_id", "deposition_date", "method", "title"]}
     return dict(path=os.path.abspath(os.path.expanduser(struct_file)),
                 info=struct_info,
                 polymers=polymers,
                 anarci=results,
-                mhc=annotate_mhc(sdict) if len(sdict) > 0 else dict(),
-                interfaces=polymer_interface_residues(st, ppi_threshold,
-                                                      n_cpus=n_cpus)
+                mhc=annotate_mhc(proteins) if len(proteins) > 0 else dict(),
                 )

gemmi_protools-1.0.0.dist-info/METADATA

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: gemmi_protools
+Version: 1.0.0
+Summary: An Enhanced tool to process PDB structures based on Gemmi
+Author: Luo Jiejian
+Author-email: Luo Jiejian <luojiejian12@mails.ucas.ac.cn>
+License-Expression: MIT
+Requires-Python: <3.13,>=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: gemmi==0.7.3
+Requires-Dist: biopython==1.85
+Requires-Dist: dockq==2.1.3
+Requires-Dist: pandas
+Requires-Dist: typeguard
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: trimesh
+Requires-Dist: freesasa==2.2.1
+Dynamic: author
+Dynamic: license-file
+
+# An Enhanced tool to process PDB structures based on Gemmi
+
+# Install
+```commandline
+conda create -n gemmi_protools python=3.12
+conda install -n gemmi_protools anarci hmmer -c bioconda
+conda install -n gemmi_protools dockq trimesh -c conda-forge
+conda activate gemmi_protools
+pip install gemmi_protools
+```
+
+# Usage
+
+## read structures
+```commandline
+from gemmi_protools import StructureParser
+st=StructureParser()
+st.load_from_file("your.pdb")
+```

gemmi_protools-1.0.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+gemmi_protools/__init__.py,sha256=_q8gXGIxrg2-3N6gxA3aa-_DRWDt3HFCLHyIh2XNHz0,157
+gemmi_protools/data/MHC/MHC_combined.hmm,sha256=w0_vzPiEWne_d_kYmqR0OiSsCOpQioItKy3Zq-JMsH4,159451
+gemmi_protools/data/MHC/MHC_combined.hmm.h3f,sha256=QGG4l-v76RYtysJ5rybnz5v6VgJg2RjoQQHUVWL5jmg,45522
+gemmi_protools/data/MHC/MHC_combined.hmm.h3i,sha256=yn-700hoBSJB39Tj8Ia8UhSZWpYiCZFNcbnYAFNjReI,300
+gemmi_protools/data/MHC/MHC_combined.hmm.h3m,sha256=CvNMCsobQiX-wL7iB4CreNcbpnElE31NmmjmMR0iYVI,66174
+gemmi_protools/data/MHC/MHC_combined.hmm.h3p,sha256=-mK278pRedG3-KL-DtuVAQy7La9DgXg5FcP89D6X3Ck,78325
+gemmi_protools/io/__init__.py,sha256=F6e1xNT_7lZAWQgNIneH06o2qtWYrHNr_xPUPTwwx5E,29
+gemmi_protools/io/convert.py,sha256=A1i1vPgxG1LqMSUvWtegLl9LipgUQbfmKeGJ_f00UYo,3781
+gemmi_protools/io/reader.py,sha256=hUIY0YKBXDCyiWTNgfX7KsZRUxBOb-v6KYKxlWWtzEk,33238
+gemmi_protools/tools/__init__.py,sha256=F6e1xNT_7lZAWQgNIneH06o2qtWYrHNr_xPUPTwwx5E,29
+gemmi_protools/tools/align.py,sha256=tsn8Fp-Xc9CulVyVst4uFgL6gQKVOEvoUmdgcfF8dCg,7084
+gemmi_protools/tools/dockq.py,sha256=a6i4S0O7Z2jxqQMBQilbcxNEDm35i8hzm_anvJXB6uo,4419
+gemmi_protools/tools/mesh.py,sha256=YiHPZUS-Y0gtLTbwdUXO7jS07PS5PP452LxvPTfHFJE,2986
+gemmi_protools/tools/pdb_annot.py,sha256=MHl-2BAFr__eO1ohPPLfBR17G2wPZti7Lq9UlS7AEX4,8252
+gemmi_protools-1.0.0.dist-info/licenses/LICENSE,sha256=JuQvKcgj6n11y5y6nXr9rABv3gJSswc4eTCd5WZBtSY,1062
+gemmi_protools-1.0.0.dist-info/METADATA,sha256=bRuphRjLJsZz-CmSRKau3cxi8yCPnF-E9NDavUTS1DA,1038
+gemmi_protools-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gemmi_protools-1.0.0.dist-info/top_level.txt,sha256=P12mYJi5O5EKIn5u-RFaWxuix431CgLacSRD7rBid_U,15
+gemmi_protools-1.0.0.dist-info/RECORD,,