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

gemmi_protools/io/cif_opts.py

@@ -1,173 +0,0 @@
-"""
-@Author: Luo Jiejian
-"""
-
-import pathlib
-from typing import Union, Dict, Any
-
-import gemmi
-import pandas as pd
-from typeguard import typechecked
-
-from gemmi_protools.io.struct_info import Entity
-
-
-@typechecked
-def _is_cif(path: Union[str, pathlib.Path]) -> bool:
-    if isinstance(path, str):
-        path = pathlib.Path(path)
-    if path.suffixes:
-        if path.suffixes[-1] == ".cif":
-            return True
-        elif "".join(path.suffixes[-2:]) == ".cif.gz":
-            return True
-        else:
-            return False
-    else:
-        return False
-
-
-@typechecked
-def _value_mapper_from_block(block: gemmi.cif.Block, category: str, column1: str, column2: str,
-                             expand_column1: bool = False) -> Dict[str, Any]:
-    """
-    mapper from column1 to column2
-    :param block:
-    :param category:
-    :param column1:
-    :param column2:
-    :param expand_column1: bool, if True, values joint by comma in column1 with be split
-    :return:
-    Only return a mapper when both column1 and column2 in category
-    """
-    loop = block.find_mmcif_category(category)
-    tags = list(loop.tags)
-
-    results = dict()
-    if column1 in tags:
-        values1 = loop.column(tags.index(column1))
-        v1 = [values1.str(i) for i in range(len(values1))]
-
-        if column2 in tags:
-            values2 = loop.column(tags.index(column2))
-            v2 = [values2.str(i) for i in range(len(values2))]
-        else:
-            v2 = ["?"] * len(v1)
-
-        outputs = dict(zip(v1, v2))
-
-        if expand_column1:
-            outputs_ex = dict()
-            for key, val in outputs.items():
-                tmp = key.split(",")
-                for sk in tmp:
-                    nk = sk.strip()
-                    if nk:
-                        outputs_ex[nk] = val
-            results = outputs_ex
-        else:
-            results = outputs
-    return results
-
-
-@typechecked
-def _get_cif_resolution(block: gemmi.cif.Block) -> float:
-    resolution = 0.0
-    for key in ["_reflns.d_resolution_high",
-                "_refine.ls_d_res_high",
-                "_refine_hist.d_res_high",
-                "_em_3d_reconstruction.resolution",
-                ]:
-        v = block.find_value(key)
-        try:
-            vf = float(v)
-        except (TypeError, ValueError):
-            continue
-        else:
-            resolution = vf
-            break
-    return resolution
-
-
-@typechecked
-def _cif_entity_info(block: gemmi.cif.Block) -> Entity:
-    entity2description = _value_mapper_from_block(block, category="_entity.",
-                                                  column1="_entity.id",
-                                                  column2="_entity.pdbx_description")
-
-    polymer2entity = _value_mapper_from_block(block, category="_entity_poly.",
-                                              column1="_entity_poly.pdbx_strand_id",
-                                              column2="_entity_poly.entity_id",
-                                              expand_column1=True)
-    entity2species = _value_mapper_from_block(block, category="_entity_src_gen.",
-                                              column1="_entity_src_gen.entity_id",
-                                              column2="_entity_src_gen.pdbx_gene_src_scientific_name")
-
-    entity2species.update(_value_mapper_from_block(block, category="_pdbx_entity_src_syn.",
-                                                   column1="_pdbx_entity_src_syn.entity_id",
-                                                   column2="_pdbx_entity_src_syn.organism_scientific")
-                          )
-    entity2species.update(_value_mapper_from_block(block, category="_entity_src_nat.",
-                                                   column1="_entity_src_nat.entity_id",
-                                                   column2="_entity_src_nat.pdbx_organism_scientific")
-                          )
-    entity2taxid = _value_mapper_from_block(block, category="_entity_src_gen.",
-                                            column1="_entity_src_gen.entity_id",
-                                            column2="_entity_src_gen.pdbx_gene_src_ncbi_taxonomy_id")
-    entity2taxid.update(_value_mapper_from_block(block, category="_pdbx_entity_src_syn.",
-                                                 column1="_pdbx_entity_src_syn.entity_id",
-                                                 column2="_pdbx_entity_src_syn.ncbi_taxonomy_id")
-                        )
-    entity2taxid.update(_value_mapper_from_block(block, category="_entity_src_nat.",
-                                                 column1="_entity_src_nat.entity_id",
-                                                 column2="_entity_src_nat.pdbx_ncbi_taxonomy_id")
-                        )
-
-    vals = dict(eid2desc=entity2description,
-                eid2specie=entity2species,
-                eid2taxid=entity2taxid,
-                polymer2eid=polymer2entity
-                )
-    return Entity(**vals)
-
-
-@typechecked
-def _cif_block_for_output(structure: gemmi.Structure, entity: Entity) -> gemmi.cif.Block:
-    block = structure.make_mmcif_block()
-
-    reflns = block.find_mmcif_category(category="_reflns.")
-    resolution = "%.2f" % structure.resolution
-    reflns.erase()
-    reflns_loop = block.init_loop(prefix="_reflns.", tags=["d_resolution_high", "d_resolution_low"])
-    reflns_loop.add_row([resolution, resolution])
-
-    ta = block.find_mmcif_category(category="_entity.")
-    da = pd.DataFrame(list(ta), columns=list(ta.tags))
-    if "_entity.id" in da.columns:
-        da["_entity.pdbx_description"] = da["_entity.id"].apply(
-            lambda i: entity["eid2desc"].get(i, "?").strip() or "?")
-
-        rows = []
-        for ar in da.to_numpy().tolist():
-            rows.append([gemmi.cif.quote(i) for i in ar])
-
-        if "_entity.pdbx_description" not in list(ta.tags):
-            ta.loop.add_columns(["_entity.pdbx_description"], "?")
-
-        ta = block.find_mmcif_category(category="_entity.")
-        for _ in range(len(ta)):
-            ta.remove_row(0)
-        for row in rows:
-            ta.append_row(row)
-
-    loop = block.init_loop("_entity_src_gen.", ["entity_id",
-                                                "pdbx_gene_src_scientific_name",
-                                                "pdbx_gene_src_ncbi_taxonomy_id"])
-
-    for k in entity["eid2specie"].keys():
-        loop.add_row([gemmi.cif.quote(k),
-                      gemmi.cif.quote(entity["eid2specie"].get(k, "?")),
-                      gemmi.cif.quote(entity["eid2taxid"].get(k, "?"))]
-                     )
-    block.move_item(-1, 16)
-    return block

gemmi_protools/io/parse_pdb_header.py

@@ -1,387 +0,0 @@
-#!/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