RNApolis 0.3.12__py3-none-any.whl → 0.3.14__py3-none-any.whl

{RNApolis-0.3.12.dist-info → RNApolis-0.3.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: RNApolis
-Version: 0.3.12
+Version: 0.3.14
 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.12.dist-info → RNApolis-0.3.14.dist-info}/RECORD

@@ -1,17 +1,17 @@
-rnapolis/annotator.py,sha256=bcyqmUSSRyl0ejA3548K4czSElBMX3EpCKAfJ2tYjsw,21476
+rnapolis/annotator.py,sha256=XnjFBeu3P_2UMdkD4Ao7m7K6JfeqYa-13xRzghrLvt8,22086
 rnapolis/clashfinder.py,sha256=jD3s_UovygWi01NUbQNeAeRRFkARTSRraLXUV43UbAA,8514
-rnapolis/common.py,sha256=QdmAGF8DvG1EHpefumU27LceGm7l9obgWLhL4FELGT4,27381
+rnapolis/common.py,sha256=mgn9psuBcgJVGPRxsxilVedPygqfwFz9wn5Z0vTU6SY,30107
 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=Cmjt7p8UkiSNhSQDjc6I7BRqtuIIHs23Fp-Glb8Zikw,12216
 rnapolis/rfam_folder.py,sha256=3rgXEJR16uPFy_BOo8qkdClOAOQDVOkidnLE-yoRbeI,11112
-rnapolis/tertiary.py,sha256=iWMPD9c21rjMPpEdBd7mPCQgds65IbOr4_Fy06s0NoU,18957
+rnapolis/tertiary.py,sha256=VuATTN2SD7lBL9iUgT-doDwuEYsLodgV2u-SwQsyQcU,19658
 rnapolis/transformer.py,sha256=V9nOQvdq4-p7yUWo0vQg0CDQMpmyxz9t4TMSRVEKHnw,1817
 rnapolis/util.py,sha256=IdquFO3PV1_KDqodjupzm0Rqvgy0CeSzxGHaGEHYXVU,543
-RNApolis-0.3.12.dist-info/LICENSE,sha256=ZGRu12MzCgbYA-Lt8MyBlmjvPZh7xfiD5u5wBx0enq4,1066
-RNApolis-0.3.12.dist-info/METADATA,sha256=PGjy4PTp1C5K1afBs6ZjeWz4pLJ5iFaiZfUSdgwusDk,54301
-RNApolis-0.3.12.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-RNApolis-0.3.12.dist-info/entry_points.txt,sha256=foN2Pn5e-OzEz0fFmNoX6PnFSZFQntOlY8LbognP5F0,308
-RNApolis-0.3.12.dist-info/top_level.txt,sha256=LcO18koxZcWoJ21KDRRRo_tyIbmXL5z61dPitZpy8yc,9
-RNApolis-0.3.12.dist-info/RECORD,,
+RNApolis-0.3.14.dist-info/LICENSE,sha256=ZGRu12MzCgbYA-Lt8MyBlmjvPZh7xfiD5u5wBx0enq4,1066
+RNApolis-0.3.14.dist-info/METADATA,sha256=Yrp600ac6KI9zfglV3wf4bY9-dOHO32YgWwwKzYzo94,54301
+RNApolis-0.3.14.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+RNApolis-0.3.14.dist-info/entry_points.txt,sha256=foN2Pn5e-OzEz0fFmNoX6PnFSZFQntOlY8LbognP5F0,308
+RNApolis-0.3.14.dist-info/top_level.txt,sha256=LcO18koxZcWoJ21KDRRRo_tyIbmXL5z61dPitZpy8yc,9
+RNApolis-0.3.14.dist-info/RECORD,,

rnapolis/annotator.py

@@ -9,7 +9,6 @@ from typing import Dict, List, Optional, Set, Tuple
 
 import numpy
 import numpy.typing
-import orjson
 from ordered_set import OrderedSet
 from scipy.spatial import KDTree
 
@@ -486,7 +485,8 @@ def extract_secondary_structure(
     tertiary_structure: Structure3D,
     model: Optional[int] = None,
     find_gaps: bool = False,
-) -> Structure2D:
+    all_dot_brackets: bool = False,
+) -> Tuple[Structure2D, List[str]]:
     base_interactions = extract_base_interactions(tertiary_structure, model)
     mapping = Mapping2D3D(
         tertiary_structure,
@@ -495,7 +495,7 @@ def extract_secondary_structure(
         find_gaps,
     )
     stems, single_strands, hairpins, loops = mapping.bpseq.elements
-    return Structure2D(
+    structure2d = Structure2D(
         base_interactions,
         str(mapping.bpseq),
         mapping.dot_bracket,
@@ -505,6 +505,10 @@ def extract_secondary_structure(
         hairpins,
         loops,
     )
+    if all_dot_brackets:
+        return structure2d, mapping.all_dot_brackets
+    else:
+        return structure2d, [structure2d.dotBracket]
 
 
 def write_json(path: str, structure2d: BaseInteractions):
@@ -580,29 +584,40 @@ def write_bpseq(path: str, bpseq: 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(
+        "-a",
+        "--all-dot-brackets",
+        action="store_true",
+        help=")optional) print all dot-brackets, not only optimal one (exclusive with -e/--extended)",
+    )
+    parser.add_argument("-b", "--bpseq", help="(optional) path to output BPSEQ file")
+    parser.add_argument("-c", "--csv", help="(optional) path to output CSV file")
+    parser.add_argument(
+        "-j",
         "--json",
         help="(optional) path to output JSON file",
     )
     parser.add_argument(
+        "-e",
         "--extended",
         action="store_true",
         help="(optional) if set, the program will print extended secondary structure to the standard output",
     )
     parser.add_argument(
+        "-f",
         "--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")
+    parser.add_argument("-d", "--dot", help="(optional) path to output DOT file")
     args = parser.parse_args()
 
     file = handle_input_file(args.input)
     structure3d = read_3d_structure(file, None)
-    structure2d = extract_secondary_structure(structure3d, None, args.find_gaps)
+    structure2d, dot_brackets = extract_secondary_structure(
+        structure3d, None, args.find_gaps, args.all_dot_brackets
+    )
 
     if args.csv:
         write_csv(args.csv, structure2d)
@@ -615,6 +630,9 @@ def main():
 
     if args.extended:
         print(structure2d.extendedDotBracket)
+    elif args.all_dot_brackets:
+        for dot_bracket in dot_brackets:
+            print(dot_bracket)
     else:
         print(structure2d.dotBracket)
 

rnapolis/common.py

@@ -8,6 +8,7 @@ from collections.abc import Sequence
 from dataclasses import dataclass
 from enum import Enum
 from functools import cache, cached_property, total_ordering
+from itertools import permutations
 from typing import Dict, List, Optional, Tuple
 
 import graphviz
@@ -852,6 +853,82 @@ class BpSeq:
 
         return self.__make_dot_bracket(regions, orders)
 
+    @cached_property
+    def all_dot_brackets(self):
+        # build conflict graph
+        regions = self.__regions
+        graph = defaultdict(set)
+
+        for i, j in itertools.combinations(range(len(regions)), 2):
+            ri, rj = regions[i], regions[j]
+            k, l, _ = ri
+            m, n, _ = rj
+
+            # is pseudoknot?
+            if (k < m < l < n) or (m < k < n < l):
+                graph[i].add(j)
+                graph[j].add(i)
+
+        # early exit for non-pseudoknotted structures
+        vertices = list(graph.keys())
+        if not vertices:
+            return [self.fcfs]
+
+        # find all connected components
+        visited = {vertex: False for vertex in vertices}
+        components = []
+
+        for vertex in vertices:
+            if not visited[vertex]:
+                visited[vertex] = True
+                stack = [vertex]
+                components.append([vertex])
+
+                while stack:
+                    current = stack[-1]
+                    next_vertex = None
+
+                    for neighbor in graph[current]:
+                        if not visited[neighbor]:
+                            next_vertex = neighbor
+                            break
+
+                    if next_vertex is not None:
+                        visited[next_vertex] = True
+                        stack.append(next_vertex)
+                        components[-1].append(next_vertex)
+                    else:
+                        stack.pop()
+
+        # permute order of every component
+        permutations = [
+            list(itertools.permutations(component)) for component in components
+        ]
+        solutions = set()
+
+        for permutation in itertools.product(*permutations):
+            orders = [0 for _ in range(len(regions))]
+
+            for component in permutation:
+                for i in range(1, len(component)):
+                    region_i = component[i]
+                    available = [True for _ in range(len(graph))]
+
+                    for j in range(i):
+                        region_j = component[j]
+
+                        if region_j in graph[region_i]:
+                            available[orders[region_j]] = False
+
+                    order = next(
+                        filter(lambda i: available[i] is True, range(len(available)))
+                    )
+                    orders[region_i] = order
+
+                solutions.add(self.__make_dot_bracket(regions, orders))
+
+        return list(solutions)
+
 
 @dataclass
 class DotBracket:
@@ -896,6 +973,12 @@ class DotBracket:
     def __str__(self):
         return f"{self.sequence}\n{self.structure}"
 
+    def __eq__(self, other):
+        return self.sequence == other.sequence and self.structure == other.structure
+
+    def __hash__(self) -> int:
+        return hash((self.sequence, self.structure))
+
 
 @dataclass
 class MultiStrandDotBracket(DotBracket):

rnapolis/tertiary.py

@@ -548,7 +548,7 @@ class Mapping2D3D:
 
     @cached_property
     def dot_bracket(self) -> str:
-        dbns = self.__generate_dot_bracket_per_strand(self.bpseq)
+        dbns = self.__generate_dot_bracket_per_strand(self.bpseq.dot_bracket.structure)
         i = 0
         result = []
 
@@ -560,8 +560,8 @@ class Mapping2D3D:
             i += len(sequence)
         return "\n".join(result)
 
-    def __generate_dot_bracket_per_strand(self, bpseq: BpSeq) -> List[str]:
-        dbn = bpseq.dot_bracket.structure
+    def __generate_dot_bracket_per_strand(self, dbn_structure: str) -> List[str]:
+        dbn = dbn_structure
         i = 0
         result = []
 
@@ -570,6 +570,25 @@ class Mapping2D3D:
             i += len(sequence)
         return result
 
+    @cached_property
+    def all_dot_brackets(self) -> List[str]:
+        dot_brackets = []
+
+        for dot_bracket in self.bpseq.all_dot_brackets:
+            dbns = self.__generate_dot_bracket_per_strand(dot_bracket.structure)
+            i = 0
+            result = []
+
+            for i, pair in enumerate(self.strands_sequences):
+                chain, sequence = pair
+                result.append(f">strand_{chain}")
+                result.append(sequence)
+                result.append(dbns[i])
+                i += len(sequence)
+            dot_brackets.append("\n".join(result))
+
+        return dot_brackets
+
     @cached_property
     def extended_dot_bracket(self) -> str:
         result = [
@@ -593,7 +612,9 @@ class Mapping2D3D:
             for row in [row1, row2]:
                 if row:
                     bpseq = self.__generate_bpseq(row)
-                    dbns = self.__generate_dot_bracket_per_strand(bpseq)
+                    dbns = self.__generate_dot_bracket_per_strand(
+                        bpseq.dot_bracket.structure
+                    )
 
                     for i in range(len(self.strands_sequences)):
                         result[i].append(f"{lw.value} {dbns[i]}")