gemmi-protools 0.1.0__py3-none-any.whl

gemmi_protools/parse_pdb_header.py

@@ -0,0 +1,387 @@
+#!/usr/bin/env python
+# Copyright 2004 Kristian Rother.
+# Revisions copyright 2004 Thomas Hamelryck.
+# Revisions copyright 2024 James Krieger.
+#
+# This file is part of the Biopython distribution and governed by your
+# choice of the "Biopython License Agreement" or the "BSD 3-Clause License".
+# Please see the LICENSE file that should have been included as part of this
+# package.
+
+"""Parse header of PDB files into a python dictionary.
+
+Emerged from the Columba database project www.columba-db.de, original author
+Kristian Rother.
+
+Modify _parse_pdb_header_list
+Don't perform lower() to chain id
+By Luo Jiejian
+"""
+
+import re
+from collections import defaultdict
+
+from Bio import File
+
+
+def _get_biomoltrans(inl):
+    # REMARK 350
+    # REMARK 350 COORDINATES FOR A COMPLETE MULTIMER REPRESENTING THE KNOWN
+    # REMARK 350 BIOLOGICALLY SIGNIFICANT OLIGOMERIZATION STATE OF THE
+    # REMARK 350 MOLECULE CAN BE GENERATED BY APPLYING BIOMT TRANSFORMATIONS
+    # REMARK 350 GIVEN BELOW.  BOTH NON-CRYSTALLOGRAPHIC AND
+    # REMARK 350 CRYSTALLOGRAPHIC OPERATIONS ARE GIVEN.
+    # REMARK 350
+    # REMARK 350 BIOMOLECULE: 1
+    # REMARK 350 AUTHOR DETERMINED BIOLOGICAL UNIT: MONOMERIC
+    # REMARK 350 APPLY THE FOLLOWING TO CHAINS: A
+    # REMARK 350   BIOMT1   1  1.000000  0.000000  0.000000        0.00000
+    # REMARK 350   BIOMT2   1  0.000000  1.000000  0.000000        0.00000
+    # REMARK 350   BIOMT3   1  0.000000  0.000000  1.000000        0.00000
+    biomolecule = defaultdict(list)
+    for line in inl:
+        if line.startswith("REMARK 350"):
+            if line[11:23] == "BIOMOLECULE:":
+                currentBiomolecule = line.split()[-1]
+                applyToChains = []
+            elif (
+                    line[11:41] == "APPLY THE FOLLOWING TO CHAINS:"
+                    or line[30:41] == "AND CHAINS:"
+            ):
+                applyToChains.extend(
+                    line[41:].replace(" ", "").strip().strip(",").split(",")
+                )
+            elif line[13:18] == "BIOMT":
+                biomt = biomolecule[currentBiomolecule]
+                if line[13:19] == "BIOMT1":
+                    if applyToChains == []:
+                        applyToChains = biomt[0]
+                    biomt.append(applyToChains)
+                elif line[13:19]:
+                    applyToChains = []
+                biomt.append(line[23:])
+    return dict(biomolecule)
+
+
+def _get_journal(inl):
+    # JRNL        AUTH   L.CHEN,M.DOI,F.S.MATHEWS,A.Y.CHISTOSERDOV,           2BBK   7
+    journal = ""
+    for line in inl:
+        if re.search(r"\AJRNL", line):
+            journal += line[19:72].lower()
+    journal = re.sub(r"\s\s+", " ", journal)
+    return journal
+
+
+def _get_references(inl):
+    # REMARK   1 REFERENCE 1                                                  1CSE  11
+    # REMARK   1  AUTH   W.BODE,E.PAPAMOKOS,D.MUSIL                           1CSE  12
+    references = []
+    actref = ""
+    for line in inl:
+        if re.search(r"\AREMARK   1", line):
+            if re.search(r"\AREMARK   1 REFERENCE", line):
+                if actref != "":
+                    actref = re.sub(r"\s\s+", " ", actref)
+                    if actref != " ":
+                        references.append(actref)
+                    actref = ""
+            else:
+                actref += line[19:72].lower()
+
+    if actref != "":
+        actref = re.sub(r"\s\s+", " ", actref)
+        if actref != " ":
+            references.append(actref)
+    return references
+
+
+# bring dates to format: 1909-01-08
+def _format_date(pdb_date):
+    """Convert dates from DD-Mon-YY to YYYY-MM-DD format (PRIVATE)."""
+    date = ""
+    year = int(pdb_date[7:])
+    if year < 50:
+        century = 2000
+    else:
+        century = 1900
+    date = str(century + year) + "-"
+    all_months = [
+        "xxx",
+        "Jan",
+        "Feb",
+        "Mar",
+        "Apr",
+        "May",
+        "Jun",
+        "Jul",
+        "Aug",
+        "Sep",
+        "Oct",
+        "Nov",
+        "Dec",
+    ]
+    month = str(all_months.index(pdb_date[3:6]))
+    if len(month) == 1:
+        month = "0" + month
+    date = date + month + "-" + pdb_date[:2]
+    return date
+
+
+def _chop_end_codes(line):
+    """Chops lines ending with  '     1CSA  14' and the like (PRIVATE)."""
+    return re.sub(r"\s\s\s\s+[\w]{4}.\s+\d*\Z", "", line)
+
+
+def _chop_end_misc(line):
+    """Chops lines ending with  '     14-JUL-97  1CSA' and the like (PRIVATE)."""
+    return re.sub(r"\s+\d\d-\w\w\w-\d\d\s+[1-9][0-9A-Z]{3}\s*\Z", "", line)
+
+
+def _nice_case(line):
+    """Make A Lowercase String With Capitals (PRIVATE)."""
+    line_lower = line.lower()
+    s = ""
+    i = 0
+    nextCap = 1
+    while i < len(line_lower):
+        c = line_lower[i]
+        if c >= "a" and c <= "z" and nextCap:
+            c = c.upper()
+            nextCap = 0
+        elif c in " .,;:\t-_":
+            nextCap = 1
+        s += c
+        i += 1
+    return s
+
+
+def parse_pdb_header(infile):
+    """Return the header lines of a pdb file as a dictionary.
+
+    Dictionary keys are: head, deposition_date, release_date, structure_method,
+    resolution, structure_reference, journal_reference, author and
+    compound.
+    """
+    header = []
+    with File.as_handle(infile) as f:
+        for line in f:
+            record_type = line[0:6]
+            if record_type in ("ATOM  ", "HETATM", "MODEL "):
+                break
+            header.append(line)
+    return _parse_pdb_header_list(header)
+
+
+def _parse_remark_465(line):
+    """Parse missing residue remarks.
+
+    Returns a dictionary describing the missing residue.
+    The specification for REMARK 465 at
+    http://www.wwpdb.org/documentation/file-format-content/format33/remarks2.html#REMARK%20465
+    only gives templates, but does not say they have to be followed.
+    So we assume that not all pdb-files with a REMARK 465 can be understood.
+
+    Returns a dictionary with the following keys:
+    "model", "res_name", "chain", "ssseq", "insertion"
+    """
+    if line:
+        # Note that line has been stripped.
+        assert line[0] != " " and line[-1] not in "\n ", "line has to be stripped"
+    pattern = re.compile(
+        r"""
+        (\d+\s[\sA-Z][\sA-Z][A-Z] |   # Either model number + residue name
+            [A-Z]{1,3})               # Or only residue name with 1 (RNA) to 3 letters
+        \s ([A-Za-z0-9])              # A single character chain
+        \s+(-?\d+[A-Za-z]?)$          # Residue number: A digit followed by an optional
+                                      # insertion code (Hetero-flags make no sense in
+                                      # context with missing res)
+        """,
+        re.VERBOSE,
+    )
+    match = pattern.match(line)
+    if match is None:
+        return None
+    residue = {}
+    if " " in match.group(1):
+        model, residue["res_name"] = match.group(1).split()
+        residue["model"] = int(model)
+    else:
+        residue["model"] = None
+        residue["res_name"] = match.group(1)
+    residue["chain"] = match.group(2)
+    try:
+        residue["ssseq"] = int(match.group(3))
+    except ValueError:
+        residue["insertion"] = match.group(3)[-1]
+        residue["ssseq"] = int(match.group(3)[:-1])
+    else:
+        residue["insertion"] = None
+    return residue
+
+
+def _parse_pdb_header_list(header):
+    # database fields
+    pdbh_dict = {
+        "name": "",
+        "head": "",
+        "idcode": "",
+        "deposition_date": "1909-01-08",
+        "release_date": "1909-01-08",
+        "structure_method": "unknown",
+        "resolution": None,
+        "structure_reference": "unknown",
+        "journal_reference": "unknown",
+        "author": "",
+        "compound": {"1": {"misc": ""}},
+        "source": {"1": {"misc": ""}},
+        "has_missing_residues": False,
+        "missing_residues": [],
+        "biomoltrans": [],
+    }
+
+    pdbh_dict["structure_reference"] = _get_references(header)
+    pdbh_dict["journal_reference"] = _get_journal(header)
+    pdbh_dict["biomoltrans"] = _get_biomoltrans(header)
+    comp_molid = "1"
+    last_comp_key = "misc"
+    last_src_key = "misc"
+
+    for hh in header:
+        h = re.sub(r"[\s\n\r]*\Z", "", hh)  # chop linebreaks off
+        # key=re.sub("\s.+\s*","",h)
+        key = h[:6].strip()
+        # tail=re.sub("\A\w+\s+\d*\s*","",h)
+        tail = h[10:].strip()
+        # print("%s:%s" % (key, tail)
+
+        # From here, all the keys from the header are being parsed
+        if key == "TITLE":
+            name = _chop_end_codes(tail).lower()
+            pdbh_dict["name"] = " ".join([pdbh_dict["name"], name]).strip()
+        elif key == "HEADER":
+            rr = re.search(r"\d\d-\w\w\w-\d\d", tail)
+            if rr is not None:
+                pdbh_dict["deposition_date"] = _format_date(_nice_case(rr.group()))
+            rr = re.search(r"\s+([1-9][0-9A-Z]{3})\s*\Z", tail)
+            if rr is not None:
+                pdbh_dict["idcode"] = rr.group(1)
+            head = _chop_end_misc(tail).lower()
+            pdbh_dict["head"] = head
+        elif key == "COMPND":
+            # LJJ
+            # tt = re.sub(r"\;\s*\Z", "", _chop_end_codes(tail)).lower()
+            tt = re.sub(r"\;\s*\Z", "", _chop_end_codes(tail))
+            # look for E.C. numbers in COMPND lines
+            rec = re.search(r"\d+\.\d+\.\d+\.\d+", tt)
+            if rec:
+                pdbh_dict["compound"][comp_molid]["ec_number"] = rec.group()
+                tt = re.sub(r"\((e\.c\.)*\d+\.\d+\.\d+\.\d+\)", "", tt)
+            tok = tt.split(":")
+            if len(tok) >= 2:
+                # lower ckey LJJ
+                ckey = tok[0].lower()
+                # ckey = tok[0]
+                cval = re.sub(r"\A\s*", "", tok[1])
+                if ckey == "mol_id":
+                    # mol_id, keep original, usually digital string
+                    pdbh_dict["compound"][cval] = {"misc": ""}
+                    comp_molid = cval
+                    last_comp_key = "misc"
+                else:
+                    # add two lines, lower all except chain value LJJ
+                    if ckey != "chain":
+                        cval = cval.lower()
+
+                    pdbh_dict["compound"][comp_molid][ckey] = cval
+                    last_comp_key = ckey
+            else:
+                # pdbh_dict["compound"][comp_molid][last_comp_key] += tok[0] + " "
+                # concat and lower LJJ
+                pdbh_dict["compound"][comp_molid][last_comp_key] += tok[0].lower() + " "
+        elif key == "SOURCE":
+            tt = re.sub(r"\;\s*\Z", "", _chop_end_codes(tail)).lower()
+            tok = tt.split(":")
+            # print(tok)
+            if len(tok) >= 2:
+                ckey = tok[0]
+                cval = re.sub(r"\A\s*", "", tok[1])
+                if ckey == "mol_id":
+                    pdbh_dict["source"][cval] = {"misc": ""}
+                    comp_molid = cval
+                    last_src_key = "misc"
+                else:
+                    pdbh_dict["source"][comp_molid][ckey] = cval
+                    last_src_key = ckey
+            else:
+                pdbh_dict["source"][comp_molid][last_src_key] += tok[0] + " "
+        elif key == "KEYWDS":
+            kwd = _chop_end_codes(tail).lower()
+            if "keywords" in pdbh_dict:
+                pdbh_dict["keywords"] += " " + kwd
+            else:
+                pdbh_dict["keywords"] = kwd
+        elif key == "EXPDTA":
+            expd = _chop_end_codes(tail)
+            # chop junk at end of lines for some structures
+            expd = re.sub(r"\s\s\s\s\s\s\s.*\Z", "", expd)
+            # if re.search('\Anmr',expd,re.IGNORECASE): expd='nmr'
+            # if re.search('x-ray diffraction',expd,re.IGNORECASE): expd='x-ray diffraction'
+            pdbh_dict["structure_method"] = expd.lower()
+        elif key == "CAVEAT":
+            # make Annotation entries out of these!!!
+            pass
+        elif key == "REVDAT":
+            rr = re.search(r"\d\d-\w\w\w-\d\d", tail)
+            if rr is not None:
+                pdbh_dict["release_date"] = _format_date(_nice_case(rr.group()))
+        elif key == "JRNL":
+            # print("%s:%s" % (key, tail))
+            if "journal" in pdbh_dict:
+                pdbh_dict["journal"] += tail
+            else:
+                pdbh_dict["journal"] = tail
+        elif key == "AUTHOR":
+            auth = _nice_case(_chop_end_codes(tail))
+            if "author" in pdbh_dict:
+                pdbh_dict["author"] += auth
+            else:
+                pdbh_dict["author"] = auth
+        elif key == "REMARK":
+            if re.search("REMARK   2 RESOLUTION.", hh):
+                r = _chop_end_codes(re.sub("REMARK   2 RESOLUTION.", "", hh))
+                r = re.sub(r"\s+ANGSTROM.*", "", r)
+                try:
+                    pdbh_dict["resolution"] = float(r)
+                except ValueError:
+                    # print('nonstandard resolution %r' % r)
+                    pdbh_dict["resolution"] = None
+            elif hh.startswith("REMARK 465"):
+                if tail:
+                    pdbh_dict["has_missing_residues"] = True
+                    missing_res_info = _parse_remark_465(tail)
+                    if missing_res_info:
+                        pdbh_dict["missing_residues"].append(missing_res_info)
+            elif hh.startswith("REMARK  99 ASTRAL"):
+                if tail:
+                    remark_99_keyval = tail.replace("ASTRAL ", "").split(": ")
+                    if (
+                            isinstance(remark_99_keyval, list)
+                            and len(remark_99_keyval) == 2
+                    ):
+                        if "astral" not in pdbh_dict:
+                            pdbh_dict["astral"] = {
+                                remark_99_keyval[0]: remark_99_keyval[1]
+                            }
+                        else:
+                            pdbh_dict["astral"][remark_99_keyval[0]] = remark_99_keyval[
+                                1
+                            ]
+        else:
+            # print(key)
+            pass
+    if pdbh_dict["structure_method"] == "unknown":
+        res = pdbh_dict["resolution"]
+        if res is not None and res > 0.0:
+            pdbh_dict["structure_method"] = "x-ray diffraction"
+    return pdbh_dict

gemmi_protools/parser.py

@@ -0,0 +1,279 @@
+"""
+@Author: Luo Jiejian
+"""
+import pathlib
+from collections import defaultdict, Counter
+from typing import Union, Optional, Dict, List
+
+import gemmi
+from typeguard import typechecked
+
+from .cif_opts import _cif_entity_info, _is_cif, _get_cif_resolution
+from .pdb_opts import _pdb_entity_info, _is_pdb, _get_pdb_resolution
+from .struct_info import Entity
+
+
+@typechecked
+def _ent_from_structure(struct: gemmi.Structure) -> Entity:
+    """
+    Run .setup_entities() in advance
+    :param struct:
+    :return:
+    """
+    block = struct.make_mmcif_block()
+    ent_info = _cif_entity_info(block)
+    for ent in struct.entities:
+        if ent.name not in ent_info["eid2desc"]:
+            ent_info["eid2desc"][ent.name] = ent.name
+    return ent_info
+
+
+@typechecked
+def cif_parser(path: Union[str, pathlib.Path]):
+    """
+    Parse .cif or .cif.gz
+    :param path:
+    :return: (gemmi.Structure, entity)
+    """
+    if _is_cif(path):
+        doc = gemmi.cif.read(str(path))
+        block0 = doc.sole_block()
+        struct = gemmi.read_structure(str(path))
+        struct.setup_entities()
+        # sheet_id like 1' will get some strange errors
+        # result in sheets with 0 strands
+        # delete sheets with 0 strands
+        # check here
+
+        zero_sheet_ind = []
+        for i, sheet in enumerate(struct.sheets):
+            if len(sheet.strands) == 0:
+                zero_sheet_ind.append(i)
+
+        if zero_sheet_ind:
+            zero_sheet_ind.sort(reverse=True)
+            for i in zero_sheet_ind:
+                del struct.sheets[i]
+
+        # gemmi fail to parse right resolution, update here
+        struct.resolution = _get_cif_resolution(block0)
+
+        # ent information
+        # from doc
+        ent_0 = _cif_entity_info(block0)
+
+        # init from struct
+        ent_1 = _ent_from_structure(struct)
+
+        # update ent_0 with ent_1
+        for super_key in ["eid2desc", "polymer2eid"]:
+            for key, val in ent_1[super_key].items():
+                if key not in ent_0[super_key]:
+                    ent_0[super_key][key] = val
+        return struct, ent_0
+    else:
+        raise ValueError("Only support .cif or .cif.gz file, but got %s" % path)
+
+
+@typechecked
+def _assign_digital_entity_names(structure: gemmi.Structure) -> Optional[Dict[str, str]]:
+    """
+    Run .setup_entities() in advance
+    :param structure:
+    :return:
+    """
+    # rename entities' names to numbers if not
+    not_digit_name = False
+    for ent in structure.entities:
+        if not ent.name.isdigit():
+            not_digit_name = True
+            break
+
+    if not_digit_name:
+        mapper = dict()
+        for ix, ent in enumerate(structure.entities):
+            new_name = str(ix + 1)
+            mapper[ent.name] = new_name
+            ent.name = new_name
+        return mapper
+    else:
+        return None
+
+
+@typechecked
+def _update_entity_names(entity: Entity, mapper: Dict[str, str]):
+    """
+    Update entity names to new ones in eid2desc, eid2specie, eid2taxid in place.
+    :param entity:
+    :param mapper: {old_entity_name: new_entity_name}
+    :return:
+    """
+    for super_key in ['eid2desc', 'eid2specie', 'eid2taxid']:
+        tmp = dict()
+        for key in entity[super_key]:
+            tmp[mapper[key]] = entity[super_key][key]
+        entity.__setattr__(super_key, tmp)
+
+
+@typechecked
+def pdb_parser(path: Union[str, pathlib.Path]):
+    """
+    Parse .pdb or .pdb.gz
+    :param path: 
+    :return: (gemmi.Structure, entity)
+    """
+    if _is_pdb(path):
+        struct = gemmi.read_structure(str(path))
+        struct.resolution = _get_pdb_resolution(struct.raw_remarks)
+        ent_0 = _pdb_entity_info(path)
+
+        struct.setup_entities()
+
+        # pdb have "A,B,C" chains
+        # after setup, entities will merge
+        block = struct.make_mmcif_block()
+        ent_t = _cif_entity_info(block)
+        rec = defaultdict(list)
+        for cn, middle_eid in ent_t.polymer2eid.items():
+            rec[middle_eid].append(cn)
+
+        _mapper = _assign_digital_entity_names(struct)
+        _mapper_n = dict()
+        for middle_eid, new_eid in _mapper.items():
+            old_eid = str(",".join(rec[middle_eid]))
+            _mapper_n[old_eid] = new_eid
+
+        if _mapper_n:
+            _update_entity_names(ent_0, _mapper_n)
+
+        ent_1 = _ent_from_structure(struct)
+
+        # update ent_0 with ent_1
+        for super_key in ["eid2desc", "polymer2eid"]:
+            for key, val in ent_1[super_key].items():
+                if key not in ent_0[super_key]:
+                    ent_0[super_key][key] = val
+        return struct, ent_0
+    else:
+        raise ValueError("Only support .pdb or .pdb.gz file, but got %s" % path)
+
+
+@typechecked
+def _chain_type(structure: gemmi.Structure, chain_id: str) -> str:
+    out = None
+    values = {"PeptideL": "protein",
+              "Dna": "dna",
+              "Rna": "rna"}
+
+    for model in structure:
+        for cur_chain in model:
+            if cur_chain.name == chain_id:
+                sc_types = set()
+                for sc in cur_chain.subchains():
+                    t = sc.check_polymer_type().name
+                    if t != "Unknown":
+                        sc_types.update({t})
+
+                if len(sc_types) == 1:
+                    out = sc_types.pop()
+                else:
+                    out = "Unknown"
+    if out is None:
+        raise RuntimeError("chain_id %s not in structure" % chain_id)
+    else:
+        return values.get(out, "other")
+
+
+@typechecked
+def _get_model_chain_names(model: gemmi.Model) -> List[str]:
+    vals = []
+    for ch in model:
+        vals.append(ch.name)
+    return vals
+
+
+@typechecked
+def _assert_unique_chain_names_in_models(structure: gemmi.Structure):
+    for model in structure:
+        names = _get_model_chain_names(model)
+        nums = Counter(names)
+        dup_names = [k for k, v in nums.items() if v > 1]
+
+        if dup_names:
+            raise RuntimeError("Duplicate chain names in model %d: %s" % (model.num, ",".join(dup_names)))
+
+
+@typechecked
+def _chain_names2one_letter(structure: gemmi.Structure, only_uppercase: bool = True) -> Dict[str, str]:
+    """
+    Automatically generate one letter mapper when the length of chain name > 1 or chain name is not uppercase letters
+
+    (1) when only_uppercase is True, only supported when the number of chains of the one-model structure <= 26
+    (2) when only_uppercase is False, only supported when the number of chains of the one-model structure <= 62
+
+    If there are too many chains, make some splits or assemblies first,
+    or just keep the longer chain names in .cif format.
+    PDB only support the single letter chain name.
+    """
+
+    if len(structure) > 1:
+        raise RuntimeError("> 1 models in structure, do nothing")
+
+    _assert_unique_chain_names_in_models(structure)
+
+    n_chains = len(structure[0])
+    if only_uppercase:
+        l1 = ['Z', 'Y', 'X', 'W', 'V', 'U', 'T', 'S', 'R', 'Q', 'P', 'O', 'N', 'M',
+              'L', 'K', 'J', 'I', 'H', 'G', 'F', 'E', 'D', 'C', 'B', 'A']
+        mode = "UPPERCASE"
+    else:
+        l1 = ['9', '8', '7', '6', '5', '4', '3', '2', '1', '0',
+              'z', 'y', 'x', 'w', 'v', 'u', 't', 's', 'r', 'q',
+              'p', 'o', 'n', 'm', 'l', 'k', 'j', 'i', 'h', 'g',
+              'f', 'e', 'd', 'c', 'b', 'a', 'Z', 'Y', 'X', 'W',
+              'V', 'U', 'T', 'S', 'R', 'Q', 'P', 'O', 'N', 'M',
+              'L', 'K', 'J', 'I', 'H', 'G', 'F', 'E', 'D', 'C', 'B', 'A']
+        mode = "UPPERCASE + LOWERCASE + DIGITAL"
+
+    if n_chains > len(l1):
+        raise RuntimeError("Support max %d chains under %s mode, but got %d chains in structure"
+                           % (len(l1), mode, n_chains))
+
+    existed_one_letter_ids = []
+    for model in structure:
+        for chain in model:
+            if chain.name in l1 and chain.name not in existed_one_letter_ids:
+                existed_one_letter_ids.append(chain.name)
+
+    left_l1 = [i for i in l1 if i not in existed_one_letter_ids]
+
+    name_mapper = dict()
+    for model in structure:
+        for chain in model:
+            if chain.name not in l1:
+                new_name = left_l1.pop()
+                name_mapper[chain.name] = new_name
+    return name_mapper
+
+
+@typechecked
+def get_assembly(structure: gemmi.Structure, assembly_name: str,
+                 how: gemmi.HowToNameCopiedChain = gemmi.HowToNameCopiedChain.AddNumber):
+    struct = structure.clone()
+    struct.transform_to_assembly(assembly_name, how)
+
+    # update ENTITY.polymer2eid
+    scn2eid = dict()
+    for ent in struct.entities:
+        for scn in ent.subchains:
+            scn2eid[scn] = ent.name
+
+    polymer2eid = dict()
+    for model in struct:
+        for chain in model:
+            for sc in chain.subchains():
+                sc_t = sc.check_polymer_type().name
+                if sc_t in ["PeptideL", "Dna", "Rna"]:
+                    polymer2eid[chain.name] = scn2eid[sc.subchain_id()]
+                    break
+    return struct, polymer2eid