modelcraft 5.0.3__py3-none-any.whl → 6.0.0__py3-none-any.whl

modelcraft/scripts/contents.py

@@ -1,218 +1,8 @@
 import argparse
-import functools
-import math
-import os
-import re
 import sys
-import requests
-from ..contents import AsuContents, Carb, Ligand, Polymer, PolymerType
-from ..environ import setup_environ
-
-
-def _response_json(url, data=None):
-    print("Requesting:", url)
-    if data is None:
-        response = requests.get(url)
-    else:
-        response = requests.post(url, data=data)
-    if response.status_code != 200:
-        raise ConnectionError(response.text)
-    return response.json()
-
-
-def _add_smiles(contents: AsuContents) -> None:
-    codes = contents.monomer_codes()
-    codes = {code for code in codes if not _in_library(code)}
-    for code in sorted(codes):
-        path = os.path.join(os.environ["CLIBD_MON"], code[0].lower(), code + ".cif")
-        if not os.path.exists(path):
-            contents.smiles[code] = _smiles(code)
-
-
-@functools.lru_cache(maxsize=None)
-def _buffers() -> set:
-    path = os.path.join(os.environ["CCP4"], "share", "pisa", "agents.dat")
-    agents = set()
-    with open(path) as stream:
-        for line in stream:
-            if line[0] != "#" and "," in line:
-                code = line.split(",")[0]
-                agents.add(code)
-    return agents
-
-
-def _carb_codes(entry: str) -> dict:
-    url = "https://www.ebi.ac.uk/pdbe/search/pdb/select?"
-    query = "pdb_id:" + entry
-    filter_list = "carb_compound_id_entity"
-    request_data = {"q": query, "fl": filter_list, "wt": "json"}
-    json = _response_json(url, data=request_data)
-    docs = json["response"]["docs"]
-    codes = {}
-    for doc in docs:
-        for line in doc["carb_compound_id_entity"]:
-            match = re.match(r"(.+)\((\d+)\)_(\d+)", line)
-            code, copies, entity = match.groups()
-            codes.setdefault(int(entity), {})[code] = int(copies)
-    return codes
-
-
-def _carb_from_pdbe_molecule_dict(mol: dict) -> Carb:
-    codes = mol["carb_codes"]
-    length = sum(codes.values())
-    stoichiometry = mol["number_of_copies"] // length
-    return Carb(codes=codes, stoichiometry=stoichiometry)
-
-
-def _divide_stoichiometry(contents: AsuContents):
-    stoichiometry = []
-    for item in (
-        contents.proteins
-        + contents.rnas
-        + contents.dnas
-        + contents.carbs
-        + contents.ligands
-    ):
-        if item.stoichiometry is not None:
-            stoichiometry.append(item.stoichiometry)
-    divisor = stoichiometry[0]
-    if len(stoichiometry) > 1:
-        divisor = functools.reduce(math.gcd, stoichiometry)
-    contents.copies *= divisor
-    for item in (
-        contents.proteins
-        + contents.rnas
-        + contents.dnas
-        + contents.carbs
-        + contents.ligands
-    ):
-        item.stoichiometry //= divisor
-
-
-def _entry_contents(entry: str) -> AsuContents:
-    contents = AsuContents()
-    contents.copies = 1
-    for mol in _pdbe_molecules(entry):
-        if "sequence" in mol:
-            polymer = _polymer_from_pdbe_molecule_dict(mol)
-            contents.add_polymer(polymer)
-        if mol["molecule_type"] == "carbohydrate polymer":
-            carb = _carb_from_pdbe_molecule_dict(mol)
-            contents.carbs.append(carb)
-        if mol["molecule_type"] == "bound":
-            ligand = _ligand_from_pdbe_molecule_dict(mol)
-            if _is_buffer(ligand.code):
-                contents.buffers.append(ligand.code)
-            elif ligand.code not in ("UNL", "UNX"):
-                contents.ligands.append(ligand)
-    _divide_stoichiometry(contents)
-    _add_smiles(contents)
-    return contents
 
-
-@functools.lru_cache(maxsize=None)
-def _in_library(code: str) -> bool:
-    path = os.path.join(os.environ["CLIBD_MON"], code[0].lower(), code + ".cif")
-    return os.path.exists(path)
-
-
-@functools.lru_cache(maxsize=None)
-def _is_buffer(code: str) -> float:
-    return code.upper() in _buffers()
-
-
-def _ligand_from_pdbe_molecule_dict(mol: dict) -> Ligand:
-    return Ligand(code=mol["chem_comp_ids"][0], stoichiometry=mol["number_of_copies"])
-
-
-def _modifications_in_pdbe_molecule_dict(mol: dict) -> list:
-    indices = {}
-    for index, mod in mol["pdb_sequence_indices_with_multiple_residues"].items():
-        code1 = mod["one_letter_code"]
-        code3 = mod["three_letter_code"]
-        if code3 not in ("DA", "DC", "DG", "DT"):
-            key = code1, code3
-            indices.setdefault(key, []).append(index)
-    modifications = []
-    for key in indices:
-        code1, code3 = key
-        total = mol["sequence"].count(code1)
-        if code1 == "M" and mol["sequence"][0] == "M":
-            total -= 1
-        if len(indices[key]) >= total:
-            modifications.append(f"{code1}->{code3}")
-        else:
-            modifications.extend(f"{index}->{code3}" for index in indices[key])
-    return modifications
-
-
-def _pdbe_molecules(entry: str) -> list:
-    entry = entry.lower()
-    url = "https://www.ebi.ac.uk/pdbe/api/pdb/entry/status/" + entry
-    try:
-        json = _response_json(url)
-    except ConnectionError:
-        sys.exit(f"Cannot determine the status of entry {entry}")
-    superceded_by = json[entry][0].get("superceded_by", [])
-    if len(superceded_by) > 0:
-        entry = superceded_by[-1]
-    url = "https://www.ebi.ac.uk/pdbe/api/pdb/entry/molecules/" + entry
-    try:
-        json = _response_json(url)
-    except ConnectionError:
-        sys.exit(f"No molecule information found for entry {entry}")
-    mols = json[entry]
-    if any(mol["molecule_type"] == "carbohydrate polymer" for mol in mols):
-        codes = _carb_codes(entry)
-        for mol in mols:
-            mol["carb_codes"] = codes.get(mol["entity_id"])
-    return mols
-
-
-def _polymer_from_pdbe_molecule_dict(mol: dict) -> Polymer:
-    polymer_type = {
-        "polypeptide(l)": PolymerType.PROTEIN,
-        "polyribonucleotide": PolymerType.RNA,
-        "polydeoxyribonucleotide": PolymerType.DNA,
-    }.get(mol["molecule_type"].lower(), None)
-    return Polymer(
-        sequence=mol["sequence"],
-        stoichiometry=mol["number_of_copies"],
-        polymer_type=polymer_type,
-        modifications=_modifications_in_pdbe_molecule_dict(mol),
-    )
-
-
-@functools.lru_cache(maxsize=None)
-def _smiles(code: str) -> str:
-    query = (
-        "{\n"
-        '  chem_comp(comp_id: "%s") {\n'
-        "    pdbx_chem_comp_descriptor {\n"
-        "      comp_id\n"
-        "      descriptor\n"
-        "      program\n"
-        "      program_version\n"
-        "      type\n"
-        "    }\n"
-        "  }\n"
-        "}" % code
-    )
-    url = "https://data.rcsb.org/graphql?query=" + requests.utils.quote(query)
-    json = _response_json(url)
-    descriptors = json["data"]["chem_comp"]["pdbx_chem_comp_descriptor"]
-    canonical = None
-    smiles = None
-    for descriptor in descriptors:
-        if descriptor["type"] == "SMILES_CANONICAL":
-            if descriptor["program"] == "OpenEye OEToolkits":
-                return descriptor["descriptor"]
-            canonical = descriptor["descriptor"]
-        elif descriptor["type"] == "SMILES":
-            smiles = descriptor["descriptor"]
-    if canonical is None and smiles is None:
-        raise RuntimeError("Could not get SMILES from RCSB for " + code)
-    return canonical or smiles
+from ..contents import AsuContents
+from ..environ import setup_environ
 
 
 def main(argument_list=None):
@@ -221,10 +11,10 @@ def main(argument_list=None):
         argument_list = sys.argv[1:]
     description = "Create a contents JSON file for a PDB entry"
     parser = argparse.ArgumentParser(description=description)
-    parser.add_argument("entry", help="PDB entry ID")
-    parser.add_argument("contents", help="Path for the contents JSON")
+    parser.add_argument("entry_id", help="PDB entry ID")
+    parser.add_argument("contents", help="Path to write the contents JSON")
     args = parser.parse_args(argument_list)
-    contents = _entry_contents(entry=args.entry)
+    contents = AsuContents.from_pdbe(args.entry_id)
     contents.write_json_file(args.contents)
 
 

modelcraft/scripts/copies.py

@@ -1,9 +1,12 @@
 import argparse
 import sys
+
 import gemmi
+
 from ..contents import AsuContents
 from ..environ import setup_environ
-from ..solvent import _contents_volume, _copies_options, _volume_components
+from ..monlib import MonLib
+from ..solvent import copies_options
 
 
 def main(argument_list=None):
@@ -13,39 +16,44 @@ def main(argument_list=None):
     parser = argparse.ArgumentParser()
     parser.add_argument("contents", help="Path to contents file")
     parser.add_argument("mtz", help="Path to MTZ file")
+    parser.add_argument("--libin", help="Path to custom restraint dictionary")
     args = parser.parse_args(argument_list)
+
     contents = AsuContents.from_file(args.contents)
     mtz = gemmi.read_mtz_file(args.mtz)
+    monlib = MonLib(contents.monomer_codes(), args.libin, include_standard=True)
 
     cell = mtz.cell
     asu_volume = cell.volume / len(mtz.spacegroup.operations())
     print("## MTZ\n")
     print(
-        "Cell        %.3f  %.3f  %.3f  %.2f  %.2f  %.2f"
-        % (cell.a, cell.b, cell.c, cell.alpha, cell.beta, cell.gamma)
+        f"Cell        {cell.a:.3f}  {cell.b:.3f}  {cell.c:.3f}"
+        f"  {cell.alpha:.2f}  {cell.beta:.2f}  {cell.gamma:.2f}"
     )
-    print("Spacegroup ", mtz.spacegroup.hm)
-    print("ASU Volume  %.0f" % asu_volume)
-    print("Resolution  %.2f - %.2f" % (mtz.resolution_low(), mtz.resolution_high()))
+    print(f"Spacegroup  {mtz.spacegroup.hm}")
+    print(f"ASU Volume  {asu_volume:.0f}")
+    print(f"Resolution  {mtz.resolution_low():.2f} - {mtz.resolution_high():.2f}")
     print("")
 
     print("## Components\n")
     print("| Description                                  | Stoichiometry | Volume   |")
     print("|----------------------------------------------|---------------|----------|")
-    for component in _volume_components(contents):
-        description = component.description
-        stoichiometry = component.stoichiometry
-        assumed = "(assumed)" if component.stoichiometry_assumed else ""
-        volume = component.volume
+    for component in contents.components():
+        stoichiometry = component.stoichiometry or 1
+        assumed = "(assumed)" if component.stoichiometry is None else ""
+        volume = component.volume(monlib)
         print(
-            "| %44s | %9s %3d | %8.0f |"
-            % (description[:44], assumed, stoichiometry, volume)
+            f"| {str(component)[:44]:44s} "
+            f"| {assumed:9s} {stoichiometry:3d} "
+            f"| {volume:8.0f} |"
         )
     print("|----------------------------------------------|---------------|----------|")
-    print("| %44s |               | %8.0f |" % ("Total", _contents_volume(contents)))
+    print(f"| {'Total':44s} |               | {contents.volume(monlib):8.0f} |")
     print("")
 
-    options = _copies_options(contents, mtz)
+    options = copies_options(
+        contents, cell, mtz.spacegroup, mtz.resolution_high(), monlib
+    )
     print("## Copies\n")
     if len(options) == 0:
         print("Contents are too big to fit into the asymmetric unit")
@@ -54,8 +62,9 @@ def main(argument_list=None):
         print("|--------|------------------|-------------|")
         for option in options:
             print(
-                "| %6d | %16.3f | %11.3f |"
-                % (option.copies, option.solvent, option.probability)
+                f"| {option.copies:6d} "
+                f"| {option.solvent:16.3f} "
+                f"| {option.probability:11.3f} |"
             )
     print("")
 

modelcraft/scripts/modelcraft.py

@@ -1,4 +1,5 @@
 import sys
+
 from ..arguments import parse
 from ..environ import setup_environ
 from ..modelcraftem import ModelCraftEm

modelcraft/scripts/sidechains.py

@@ -0,0 +1,141 @@
+"Add missing side chains to a protein model"
+
+import argparse
+import sys
+from os import environ
+from pathlib import Path
+from shutil import rmtree
+
+import coot_headless_api
+import gemmi
+
+from ..environ import setup_environ
+
+
+def _parse_args(argument_list):
+    parser = argparse.ArgumentParser(
+        description=__doc__,
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    parser.add_argument(
+        "structure",
+        help="Input structure in PDB, mmCIF, mmJSON format",
+    )
+    parser.add_argument(
+        "mtz",
+        help="MTZ file amplitudes and phases (FWT and PHWT by default)",
+    )
+    parser.add_argument(
+        "output",
+        help="Path to write the output structure with added side chains",
+    )
+    parser.add_argument(
+        "--model-index",
+        type=int,
+        default=0,
+        metavar="N",
+        help="Index of the model to analyse (with 0 being the first model)",
+    )
+    parser.add_argument(
+        "--f_label",
+        default="FWT",
+        help="Column label for structure factor amplitudes",
+    )
+    parser.add_argument(
+        "--phi_label",
+        default="PHWT",
+        help="Column label for structure factor phases",
+    )
+    return parser.parse_args(argument_list or sys.argv[1:])
+
+
+SIDE_CHAIN_ATOMS = {
+    "ARG": {"CG", "CD", "NE", "CZ", "NH1", "NH2"},
+    "ASN": {"CG", "OD1", "ND2"},
+    "ASP": {"CG", "OD1", "OD2"},
+    "CYS": {"SG"},
+    "GLN": {"CG", "CD", "OE1", "NE2"},
+    "GLU": {"CG", "CD", "OE1", "OE2"},
+    "HIS": {"CG", "ND1", "CD2", "CE1", "NE2"},
+    "ILE": {"CG1", "CG2", "CD1"},
+    "LEU": {"CG", "CD1", "CD2"},
+    "LYS": {"CG", "CD", "CE", "NZ"},
+    "MET": {"CG", "SD", "CE"},
+    "MSE": {"CG", "SE", "CE"},
+    "PHE": {"CG", "CD1", "CD2", "CE1", "CE2", "CZ"},
+    "PRO": {"CG", "CD"},
+    "SER": {"OG"},
+    "THR": {"OG1", "CG2"},
+    "TRP": {"CG", "CD1", "CD2", "NE1", "CE2", "CE3", "CZ2", "CZ3", "CH2"},
+    "TYR": {"CG", "CD1", "CD2", "CE1", "CE2", "CZ", "OH"},
+    "VAL": {"CG1", "CG2"},
+}
+
+
+def has_full_side_chain(residue: gemmi.Residue) -> bool:
+    "Check if a residue has all side chain atoms from gamma onwards."
+    expected = SIDE_CHAIN_ATOMS.get(residue.name, set())
+    built = {atom.name for atom in residue}
+    return built > expected
+
+
+def any_missing_side_chains(structure: gemmi.Structure) -> bool:
+    "Check if any residue in a structure has missing side chain atoms."
+    for chain in structure[0]:
+        for residue in chain:
+            if not has_full_side_chain(residue):
+                return True
+    return False
+
+
+def cif_path(name: str):
+    directory = Path(environ["CLIBD_MON"]) / name[0].lower()
+    single_path = directory / f"{name}.cif"
+    double_path = directory / f"{name}_{name}.cif"
+    if single_path.exists():
+        return str(single_path)
+    if double_path.exists():
+        return str(double_path)
+    return None
+
+
+def main(argument_list=None):
+    backup_path = Path("coot-backup")
+    backup_existed_before = backup_path.exists()
+    setup_environ()
+    args = _parse_args(argument_list)
+    structure = gemmi.read_structure(args.structure)
+    if not any_missing_side_chains(structure):
+        print("No missing side chains detected, no action taken")
+        return
+    mc = coot_headless_api.molecules_container_t(True)
+    mc.set_use_gemmi(False)
+    mc.set_make_backups(False)
+    imol = mc.read_coordinates(args.structure)
+    non_standard = mc.non_standard_residue_types_in_model(imol)
+    for comp_id in non_standard:
+        if (path := cif_path(comp_id)) is None:
+            print("WARNING: No CIF file found for non-standard residue", comp_id)
+            continue
+        mc.import_cif_dictionary(path, imol)
+    imap = mc.read_mtz(args.mtz, args.f_label, args.phi_label, "", False, False)
+    mc.set_imol_refinement_map(imap)
+    mc.set_use_torsion_restraints(True)
+    mc.set_use_rama_plot_restraints(True)
+    for chain in structure[args.model_index]:
+        for residue in chain:
+            if not has_full_side_chain(residue):
+                num = residue.seqid.num
+                icode = residue.seqid.icode
+                icode = "" if icode == " " else icode
+                mc.refine_residues(imol, chain.name, num, icode, "", "TRIPLE", 1000)
+                mc.fill_partial_residue(imol, chain.name, num, icode)
+                mc.auto_fit_rotamer(imol, chain.name, num, icode, "", imap)
+                mc.refine_residues(imol, chain.name, num, icode, "", "TRIPLE", 1000)
+    mc.write_coordinates(imol, args.output)
+    if not backup_existed_before and backup_path.exists():
+        rmtree(backup_path, ignore_errors=True)
+
+
+if __name__ == "__main__":
+    main()

modelcraft/scripts/validate.py

@@ -0,0 +1,81 @@
+import argparse
+import sys
+
+import gemmi
+from tabulate import tabulate
+
+from ..environ import setup_environ
+from ..monlib import MonLib
+from ..reflections import DataItem
+from ..validation import validate
+
+
+def _parse_args(argument_list):
+    parser = argparse.ArgumentParser(
+        description=__doc__,
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    parser.add_argument(
+        "structure",
+        help="Input structure in PDB, mmCIF, mmJSON format",
+    )
+    parser.add_argument(
+        "mtz",
+        help=(
+            "MTZ file from Refmac with standard output column labels "
+            "(the output MTZ from ModelCraft meets this requirement)."
+        ),
+    )
+    parser.add_argument(
+        "--format",
+        default="table",
+        choices=["table", "csv"],
+        help="Print the results as a human-readable table or a CSV file",
+    )
+    parser.add_argument(
+        "--libin",
+        metavar="PATH",
+        help="Path to a custom restraint dictionary in CIF format",
+    )
+    parser.add_argument(
+        "--sort",
+        action="store_true",
+        help="Order the output with the worse scoring residues first",
+    )
+    parser.add_argument(
+        "--model-index",
+        type=int,
+        default=0,
+        metavar="N",
+        help="Index of the model to analyse (with 0 being the first model)",
+    )
+    return parser.parse_args(argument_list or sys.argv[1:])
+
+
+def main(argument_list=None):
+    setup_environ()
+    args = _parse_args(argument_list)
+
+    structure = gemmi.read_structure(args.structure, format=gemmi.CoorFormat.Detect)
+    mtz = gemmi.read_mtz_file(args.mtz)
+    fphi_best = DataItem(mtz, "FWT,PHWT")
+    fphi_diff = DataItem(mtz, "DELFWT,PHDELWT")
+    fphi_calc = DataItem(mtz, "FC_ALL,PHIC_ALL")
+
+    resnames = structure[args.model_index].get_all_residue_names()
+    monlib = MonLib(resnames, args.libin)
+    metrics = validate(
+        structure, fphi_best, fphi_diff, fphi_calc, monlib, args.model_index
+    )
+    if args.sort:
+        metrics.sort_values("Score", ascending=True, inplace=True)
+
+    if args.format == "table":
+        metrics["Sig"] = metrics["Score"].apply(lambda x: "+" * min(5, -int(x)))
+        print(tabulate(metrics, headers="keys", showindex=False, floatfmt=".1f"))
+    else:
+        print(metrics.to_csv(index=False))
+
+
+if __name__ == "__main__":
+    main()

modelcraft/sequence.py

@@ -0,0 +1,106 @@
+PROTEIN_CODES = {
+    "A": "ALA",
+    "B": "ASX",
+    "C": "CYS",
+    "D": "ASP",
+    "E": "GLU",
+    "F": "PHE",
+    "G": "GLY",
+    "H": "HIS",
+    "I": "ILE",
+    "K": "LYS",
+    "L": "LEU",
+    "M": "MET",
+    "N": "ASN",
+    "O": "PYL",
+    "P": "PRO",
+    "Q": "GLN",
+    "R": "ARG",
+    "S": "SER",
+    "T": "THR",
+    "U": "SEC",
+    "V": "VAL",
+    "W": "TRP",
+    "X": "UNK",
+    "Y": "TYR",
+    "Z": "GLX",
+}
+
+DNA_CODES = {
+    "A": "DA",
+    "C": "DC",
+    "G": "DG",
+    "I": "DI",
+    "N": "DN",
+    "T": "DT",
+    "U": "DU",
+    "X": "DN",
+}
+
+RNA_CODES = {
+    "A": "A",
+    "C": "C",
+    "G": "G",
+    "I": "I",
+    "N": "N",
+    "U": "U",
+    "X": "N",
+}
+
+
+class PolymerType:
+    PROTEIN = "PolymerType"
+    DNA = "PolymerType"
+    RNA = "PolymerType"
+
+    def __init__(self, name: str, codes: dict[str, str]):
+        self.name = name
+        self.codes = codes
+
+    def parse(self, sequence: str) -> list[str]:
+        return [self.codes.get(c, self.codes["X"]) for c in sequence]
+
+    @classmethod
+    def guess(cls, sequence: str):
+        codes = set(sequence)
+        if codes & set("DEFHKLMNPQRSVWY") or codes in ({"A"}, {"G"}):
+            return cls.PROTEIN
+        if "U" in codes:
+            return cls.RNA
+        if "T" in codes:
+            return cls.DNA
+        return cls.RNA
+
+
+PolymerType.PROTEIN = PolymerType("Protein", PROTEIN_CODES)
+PolymerType.DNA = PolymerType("DNA", DNA_CODES)
+PolymerType.RNA = PolymerType("RNA", RNA_CODES)
+
+
+PIR_CODES = {"D1", "DC", "DL", "F1", "N1", "N3", "P1", "RC", "RL", "XX"}
+
+
+def sequences_in_file(contents: str) -> list:
+    sequence = ""
+    sequences = []
+    skip_line = False
+    skip_lines = False
+    lines = contents.splitlines(keepends=False)
+    for line in lines:
+        if skip_line:
+            skip_line = False
+            continue
+        if line[:1] == ">":
+            if len(sequence) > 0:
+                sequences.append(sequence)
+            sequence = ""
+            if line[1:3] in PIR_CODES and line[3] == ";":
+                skip_line = True
+            skip_lines = False
+        elif line[:1] != ";" and not skip_lines:
+            sequence += "".join(c for c in line if c.isalpha())
+            if line[-1:] == "*":
+                skip_lines = True
+    if len(sequence) > 0:
+        sequences.append(sequence)
+    return sequences