RNApolis 0.3.9__py3-none-any.whl → 0.3.10__py3-none-any.whl

{RNApolis-0.3.9.dist-info → RNApolis-0.3.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: RNApolis
-Version: 0.3.9
+Version: 0.3.10
 Summary: A Python library containing RNA-related bioinformatics functions and classes
 Home-page: https://github.com/tzok/rnapolis-py
 Author: Tomasz Zok

{RNApolis-0.3.9.dist-info → RNApolis-0.3.10.dist-info}/RECORD

@@ -1,17 +1,18 @@
 rnapolis/annotator.py,sha256=8AwrCKy_5CKU3HsRgqj5U2aQrAXiysoAnqjsDdvCAEA,21481
+rnapolis/annotator_ml.py,sha256=eZYDIaUcAVWvUHKvA0lx6lWEaATU1THNYbfVKvVa9mQ,8226
 rnapolis/clashfinder.py,sha256=jD3s_UovygWi01NUbQNeAeRRFkARTSRraLXUV43UbAA,8514
 rnapolis/common.py,sha256=DPmRpNkMaxuIai3vfLzSlP6IN0zpj6kmT3LoRjnJUWE,26440
 rnapolis/metareader.py,sha256=4qtMKRvww2sUStLeV8WVrLEt-ScydHUv4Gxx96tnf-M,1683
 rnapolis/molecule_filter.py,sha256=NhjuqdCRnXgPefWZPeTq77tifmnAzamQtA0ODqPPG9k,6918
 rnapolis/motif_extractor.py,sha256=duHvpi9Ulcny9K60E6VBpz5RpJZw-KdTB4_Ph0iP478,774
-rnapolis/parser.py,sha256=D2PwAFurTjZDP8WBV2AOxFHPLAFE8U1G_vC_5Y7BE4U,11948
+rnapolis/parser.py,sha256=0uNKPnKiv5uaFVFGIzP8xbGLokimBkjs1XdlV0JmKIw,12217
 rnapolis/rfam_folder.py,sha256=3rgXEJR16uPFy_BOo8qkdClOAOQDVOkidnLE-yoRbeI,11112
 rnapolis/tertiary.py,sha256=iWMPD9c21rjMPpEdBd7mPCQgds65IbOr4_Fy06s0NoU,18957
 rnapolis/transformer.py,sha256=V9nOQvdq4-p7yUWo0vQg0CDQMpmyxz9t4TMSRVEKHnw,1817
 rnapolis/util.py,sha256=IdquFO3PV1_KDqodjupzm0Rqvgy0CeSzxGHaGEHYXVU,543
-RNApolis-0.3.9.dist-info/LICENSE,sha256=ZGRu12MzCgbYA-Lt8MyBlmjvPZh7xfiD5u5wBx0enq4,1066
-RNApolis-0.3.9.dist-info/METADATA,sha256=E-6_MxMx9qQZK18G7EzHgwuxwYhchfkVXusFdBpG6nY,54300
-RNApolis-0.3.9.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-RNApolis-0.3.9.dist-info/entry_points.txt,sha256=foN2Pn5e-OzEz0fFmNoX6PnFSZFQntOlY8LbognP5F0,308
-RNApolis-0.3.9.dist-info/top_level.txt,sha256=LcO18koxZcWoJ21KDRRRo_tyIbmXL5z61dPitZpy8yc,9
-RNApolis-0.3.9.dist-info/RECORD,,
+RNApolis-0.3.10.dist-info/LICENSE,sha256=ZGRu12MzCgbYA-Lt8MyBlmjvPZh7xfiD5u5wBx0enq4,1066
+RNApolis-0.3.10.dist-info/METADATA,sha256=qfgkAg8MMlyGyOkWsl8y5JOffR_9AbsQgYOXE3L5XrA,54301
+RNApolis-0.3.10.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+RNApolis-0.3.10.dist-info/entry_points.txt,sha256=foN2Pn5e-OzEz0fFmNoX6PnFSZFQntOlY8LbognP5F0,308
+RNApolis-0.3.10.dist-info/top_level.txt,sha256=LcO18koxZcWoJ21KDRRRo_tyIbmXL5z61dPitZpy8yc,9
+RNApolis-0.3.10.dist-info/RECORD,,

rnapolis/annotator_ml.py

@@ -0,0 +1,278 @@
+#! /usr/bin/env python
+import argparse
+import csv
+import logging
+import math
+import os
+from collections import defaultdict
+from typing import Dict, List, Optional, Tuple
+
+import numpy
+import numpy.typing
+import orjson
+from ordered_set import OrderedSet
+from scipy.spatial import KDTree
+
+from rnapolis.common import (
+    BaseInteractions,
+    BasePair,
+    BpSeq,
+    LeontisWesthof,
+    Residue,
+    Saenger,
+    Stacking,
+    Structure2D,
+)
+from rnapolis.parser import read_3d_structure
+from rnapolis.tertiary import (
+    AVERAGE_OXYGEN_PHOSPHORUS_DISTANCE_COVALENT,
+    Atom,
+    Mapping2D3D,
+    Residue3D,
+    Structure3D,
+    torsion_angle,
+)
+from rnapolis.util import handle_input_file
+
+C1P_MAX_DISTANCE = 10.0
+
+logging.basicConfig(level=os.getenv("LOGLEVEL", "INFO").upper())
+
+
+# TODO: implement this function
+def is_base_pair(residue_i: Residue3D, residue_j: Residue3D) -> bool:
+    return False
+
+
+# TODO: implement this function
+def classify_lw(residue_i: Residue3D, residue_j: Residue3D) -> Optional[LeontisWesthof]:
+    return None
+
+
+# TODO: implement this function
+def classify_saenger(residue_i: Residue3D, residue_j: Residue3D) -> Optional[Saenger]:
+    return None
+
+
+# TODO: implement this function
+def is_stacking(residue_i: Residue3D, residue_j: Residue3D) -> bool:
+    return False
+
+
+def find_candidates(
+    structure: Structure3D, model: Optional[int] = None
+) -> List[Tuple[Residue3D, Residue3D]]:
+    residue_map = {}
+    coordinates = []
+
+    for residue in structure.residues:
+        if model is not None and residue.model != model:
+            continue
+
+        atom = residue.find_atom("C1'")
+
+        if atom is not None:
+            atom_xyz = (atom.x, atom.y, atom.z)
+            residue_map[atom_xyz] = residue
+            coordinates.append(atom_xyz)
+
+    kdtree = KDTree(coordinates)
+    candidates = []
+
+    for i, j in kdtree.query_pairs(C1P_MAX_DISTANCE):
+        residue_i = residue_map[coordinates[i]]
+        residue_j = residue_map[coordinates[j]]
+        candidates.append((residue_i, residue_j))
+
+    return candidates
+
+
+def find_pairs(structure: Structure3D, model: Optional[int] = None) -> List[BasePair]:
+    base_pairs = []
+
+    for residue_i, residue_j in find_candidates(structure, model):
+        if is_base_pair(residue_i, residue_j):
+            lw = classify_lw(residue_i, residue_j)
+            saenger = classify_saenger(residue_i, residue_j)
+            base_pairs.append(
+                BasePair(
+                    Residue(residue_i.label, residue_i.auth),
+                    Residue(residue_j.label, residue_j.auth),
+                    lw,
+                    saenger,
+                )
+            )
+
+    return base_pairs
+
+
+def find_stackings(
+    structure: Structure3D, model: Optional[int] = None
+) -> List[Stacking]:
+    stackings = []
+
+    for residue_i, residue_j in find_candidates(structure, model):
+        if is_stacking(residue_i, residue_j):
+            stackings.append(
+                Stacking(
+                    Residue(residue_i.label, residue_i.auth),
+                    Residue(residue_j.label, residue_j.auth),
+                    None,
+                )
+            )
+
+    return stackings
+
+
+def extract_base_interactions(
+    tertiary_structure: Structure3D, model: Optional[int] = None
+) -> BaseInteractions:
+    base_pairs = find_pairs(tertiary_structure, model)
+    stackings = find_stackings(tertiary_structure, model)
+    return BaseInteractions(base_pairs, stackings, [], [], [])
+
+
+def extract_secondary_structure(
+    tertiary_structure: Structure3D,
+    model: Optional[int] = None,
+    find_gaps: bool = False,
+) -> BaseInteractions:
+    base_interactions = extract_base_interactions(tertiary_structure, model)
+    mapping = Mapping2D3D(
+        tertiary_structure,
+        base_interactions.basePairs,
+        base_interactions.stackings,
+        find_gaps,
+    )
+    stems, single_strands, hairpins, loops = mapping.bpseq.elements
+    return Structure2D(
+        base_interactions,
+        str(mapping.bpseq),
+        mapping.dot_bracket,
+        mapping.extended_dot_bracket,
+        stems,
+        single_strands,
+        hairpins,
+        loops,
+    )
+
+
+def write_json(path: str, structure2d: BaseInteractions):
+    with open(path, "wb") as f:
+        f.write(orjson.dumps(structure2d))
+
+
+def write_csv(path: str, structure2d: Structure2D):
+    with open(path, "w") as f:
+        writer = csv.writer(f)
+        writer.writerow(["nt1", "nt2", "type", "classification-1", "classification-2"])
+        for base_pair in structure2d.baseInteractions.basePairs:
+            writer.writerow(
+                [
+                    base_pair.nt1.full_name,
+                    base_pair.nt2.full_name,
+                    "base pair",
+                    base_pair.lw.value,
+                    (
+                        base_pair.saenger.value or ""
+                        if base_pair.saenger is not None
+                        else ""
+                    ),
+                ]
+            )
+        for stacking in structure2d.baseInteractions.stackings:
+            writer.writerow(
+                [
+                    stacking.nt1.full_name,
+                    stacking.nt2.full_name,
+                    "stacking",
+                    stacking.topology.value if stacking.topology is not None else "",
+                    "",
+                ]
+            )
+        for base_phosphate in structure2d.baseInteractions.basePhosphateInteractions:
+            writer.writerow(
+                [
+                    base_phosphate.nt1.full_name,
+                    base_phosphate.nt2.full_name,
+                    "base-phosphate interaction",
+                    base_phosphate.bph.value if base_phosphate.bph is not None else "",
+                    "",
+                ]
+            )
+        for base_ribose in structure2d.baseInteractions.basePhosphateInteractions:
+            writer.writerow(
+                [
+                    base_ribose.nt1.full_name,
+                    base_ribose.nt2.full_name,
+                    "base-ribose interaction",
+                    base_ribose.bph.value if base_ribose.bph is not None else "",
+                    "",
+                ]
+            )
+        for other in structure2d.baseInteractions.otherInteractions:
+            writer.writerow(
+                [
+                    other.nt1.full_name,
+                    other.nt2.full_name,
+                    "other interaction",
+                    "",
+                    "",
+                ]
+            )
+
+
+def write_bpseq(path: str, bpseq: BpSeq):
+    with open(path, "w") as f:
+        f.write(str(bpseq))
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("input", help="Path to PDB or mmCIF file")
+    parser.add_argument("--bpseq", help="(optional) path to output BPSEQ file")
+    parser.add_argument("--csv", help="(optional) path to output CSV file")
+    parser.add_argument(
+        "--json",
+        help="(optional) path to output JSON file",
+    )
+    parser.add_argument(
+        "--extended",
+        action="store_true",
+        help="(optional) if set, the program will print extended secondary structure to the standard output",
+    )
+    parser.add_argument(
+        "--find-gaps",
+        action="store_true",
+        help="(optional) if set, the program will detect gaps and break the PDB chain into two or more strands; "
+        f"the gap is defined as O3'-P distance greater then {1.5 * AVERAGE_OXYGEN_PHOSPHORUS_DISTANCE_COVALENT}",
+    )
+    parser.add_argument("--dot", help="(optional) path to output DOT file")
+    args = parser.parse_args()
+
+    breakpoint()
+
+    file = handle_input_file(args.input)
+    structure3d = read_3d_structure(file, None)
+    structure2d = extract_secondary_structure(structure3d, None, args.find_gaps)
+
+    if args.csv:
+        write_csv(args.csv, structure2d)
+
+    if args.json:
+        write_json(args.json, structure2d)
+
+    if args.bpseq:
+        write_bpseq(args.bpseq, structure2d.bpseq)
+
+    if args.extended:
+        print(structure2d.extendedDotBracket)
+    else:
+        print(structure2d.dotBracket)
+
+    if args.dot:
+        print(BpSeq.from_string(structure2d.bpseq).graphviz)
+
+
+if __name__ == "__main__":
+    main()

rnapolis/parser.py

@@ -12,8 +12,15 @@ def read_3d_structure(
     atoms, modified, sequence = (
         parse_cif(cif_or_pdb) if is_cif(cif_or_pdb) else parse_pdb(cif_or_pdb)
     )
-    if model is not None:
-        atoms = list(filter(lambda atom: atom.model == model, atoms))
+    available_models = {atom.model: None for atom in atoms}
+    atoms_by_model = {
+        model: list(filter(lambda atom: atom.model == model, atoms))
+        for model in available_models
+    }
+    if model is not None and model in available_models:
+        atoms = atoms_by_model[model]
+    else:
+        atoms = atoms_by_model[list(available_models.keys())[0]]
     return group_atoms(atoms, modified, sequence, nucleic_acid_only)