RNApolis 0.3.12__tar.gz → 0.3.13__tar.gz

{rnapolis-0.3.12/src/RNApolis.egg-info → rnapolis-0.3.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: RNApolis
-Version: 0.3.12
+Version: 0.3.13
 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 → rnapolis-0.3.13}/setup.py

@@ -5,7 +5,7 @@ with open("README.md") as f:
 
 setup(
     name="RNApolis",
-    version="0.3.12",
+    version="0.3.13",
     packages=["rnapolis"],
     package_dir={"": "src"},
     author="Tomasz Zok",

{rnapolis-0.3.12 → rnapolis-0.3.13/src/RNApolis.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: RNApolis
-Version: 0.3.12
+Version: 0.3.13
 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 → rnapolis-0.3.13}/src/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-0.3.12 → rnapolis-0.3.13}/src/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,78 @@ 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)
+
+        # find all connected components
+        vertices = list(graph.keys())
+        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 +969,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-0.3.12 → rnapolis-0.3.13}/src/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]}")