add recursive automaton annotations

Author: bygu4

pyformlang/rsa/box.py

@@ -1,10 +1,11 @@
 """
 Representation of a box for recursive automaton
 """
-from typing import Union, Any
+
+from typing import Set, Hashable, Any
 
 from pyformlang.finite_automaton import DeterministicFiniteAutomaton
-from pyformlang.finite_automaton.symbol import Symbol
+from pyformlang.finite_automaton import State, Symbol
 from pyformlang.finite_automaton.utils import to_symbol
 
 
@@ -24,58 +25,27 @@ class Box:
 
     def __init__(self,
                  dfa: DeterministicFiniteAutomaton,
-                 nonterminal: Union[Symbol, str]):
+                 nonterminal: Hashable) -> None:
         self._dfa = dfa
-
-        nonterminal = to_symbol(nonterminal)
-        self._nonterminal = nonterminal
-
-    def to_subgraph_dot(self):
-        """Creates a named subgraph representing a box"""
-        graph = self._dfa.to_networkx()
-        strange_nodes = []
-        nonterminal = self.nonterminal.value.replace('"', '').replace("'", "").replace(".", "")
-        dot_string = (f'subgraph cluster_{nonterminal}\n{{ label="{nonterminal}"\n'
-                      f'fontname="Helvetica,Arial,sans-serif"\n'
-                      f'node [fontname="Helvetica,Arial,sans-serif"]\n'
-                      f'edge [fontname="Helvetica,Arial,sans-serif"]\nrankdir=LR;\n'
-                      f'node [shape = circle style=filled fillcolor=white]')
-        for node, data in graph.nodes(data=True):
-            node = node.replace('"', '').replace("'", "")
-            if 'is_start' not in data.keys() or 'is_final' not in data.keys():
-                strange_nodes.append(node)
-                continue
-            if data['is_start']:
-                dot_string += f'\n"{node}" [fillcolor = green];'
-            if data['is_final']:
-                dot_string += f'\n"{node}" [shape = doublecircle];'
-        for strange_node in strange_nodes:
-            graph.remove_node(strange_node)
-        for node_from, node_to, data in graph.edges(data=True):
-            node_from = node_from.replace('"', '').replace("'", "")
-            node_to = node_to.replace('"', '').replace("'", "")
-            label = data['label'].replace('"', '').replace("'", "")
-            dot_string += f'\n"{node_from}" -> "{node_to}" [label = "{label}"];'
-        dot_string += "\n}"
-        return dot_string
+        self._nonterminal = to_symbol(nonterminal)
 
     @property
-    def dfa(self):
+    def dfa(self) -> DeterministicFiniteAutomaton:
         """ Box's dfa """
         return self._dfa
 
     @property
-    def nonterminal(self):
+    def nonterminal(self) -> Symbol:
         """ Box's nonterminal """
         return self._nonterminal
 
     @property
-    def start_states(self):
+    def start_states(self) -> Set[State]:
         """ The start states """
         return self._dfa.start_states
 
     @property
-    def final_states(self):
+    def final_states(self) -> Set[State]:
         """ The final states """
         return self._dfa.final_states
 
@@ -100,5 +70,36 @@ def __eq__(self, other: Any) -> bool:
             return False
         return self.is_equivalent_to(other)
 
-    def __hash__(self):
-        return self._nonterminal.__hash__()
+    def __hash__(self) -> int:
+        return hash(self.nonterminal)
+
+    def to_subgraph_dot(self) -> str:
+        """Creates a named subgraph representing a box"""
+        graph = self._dfa.to_networkx()
+        strange_nodes = []
+        nonterminal = str(self.nonterminal) \
+            .replace('"', '').replace("'", "").replace(".", "")
+        dot_string = \
+            (f'subgraph cluster_{nonterminal}\n{{ label="{nonterminal}"\n'
+             f'fontname="Helvetica,Arial,sans-serif"\n'
+             f'node [fontname="Helvetica,Arial,sans-serif"]\n'
+             f'edge [fontname="Helvetica,Arial,sans-serif"]\nrankdir=LR;\n'
+             f'node [shape = circle style=filled fillcolor=white]')
+        for node, data in graph.nodes(data=True):
+            node = node.replace('"', '').replace("'", "")
+            if 'is_start' not in data.keys() or 'is_final' not in data.keys():
+                strange_nodes.append(node)
+                continue
+            if data['is_start']:
+                dot_string += f'\n"{node}" [fillcolor = green];'
+            if data['is_final']:
+                dot_string += f'\n"{node}" [shape = doublecircle];'
+        for strange_node in strange_nodes:
+            graph.remove_node(strange_node)
+        for node_from, node_to, data in graph.edges(data=True):
+            node_from = node_from.replace('"', '').replace("'", "")
+            node_to = node_to.replace('"', '').replace("'", "")
+            label = data['label'].replace('"', '').replace("'", "")
+            dot_string += f'\n"{node_from}" -> "{node_to}" [label = "{label}"];'
+        dot_string += "\n}"
+        return dot_string

pyformlang/rsa/recursive_automaton.py

@@ -2,15 +2,14 @@
 Representation of a recursive automaton
 """
 
-from typing import AbstractSet, Union
+from typing import Dict, Set, AbstractSet, Optional, Hashable, Any
 
-from pyformlang.finite_automaton import DeterministicFiniteAutomaton
-from pyformlang.finite_automaton.symbol import Symbol
+from pyformlang.finite_automaton import Symbol
 from pyformlang.finite_automaton.utils import to_symbol
 from pyformlang.regular_expression import Regex
 from pyformlang.cfg import Epsilon
 
-from pyformlang.rsa.box import Box
+from .box import Box
 
 
 class RecursiveAutomaton:
@@ -29,15 +28,15 @@ class RecursiveAutomaton:
 
     def __init__(self,
                  start_box: Box,
-                 boxes: AbstractSet[Box]):
-        self._nonterminal_to_box = {}
+                 boxes: AbstractSet[Box]) -> None:
+        self._nonterminal_to_box: Dict[Symbol, Box] = {}
+        self._start_nonterminal = start_box.nonterminal
         if start_box not in boxes:
-            self._nonterminal_to_box[to_symbol(start_box.nonterminal)] = start_box
-        self._start_nonterminal = to_symbol(start_box.nonterminal)
+            self._nonterminal_to_box[start_box.nonterminal] = start_box
         for box in boxes:
-            self._nonterminal_to_box[to_symbol(box.nonterminal)] = box
+            self._nonterminal_to_box[box.nonterminal] = box
 
-    def get_box_by_nonterminal(self, nonterminal: Union[Symbol, str]):
+    def get_box_by_nonterminal(self, nonterminal: Hashable) -> Optional[Box]:
         """
         Box by nonterminal
 
@@ -53,50 +52,35 @@ def get_box_by_nonterminal(self, nonterminal: Union[Symbol, str]):
         """
 
         nonterminal = to_symbol(nonterminal)
-        if nonterminal in self._nonterminal_to_box:
-            return self._nonterminal_to_box[nonterminal]
+        return self._nonterminal_to_box.get(nonterminal, None)
 
-        return None
-
-    def get_number_boxes(self):
+    def get_number_boxes(self) -> int:
         """ Size of set of boxes """
-
         return len(self._nonterminal_to_box)
 
-    def to_dot(self):
-        """ Create dot representation of recursive automaton """
-        dot_string = 'digraph "" {'
-        for box in self._nonterminal_to_box.values():
-            dot_string += f'\n{box.to_subgraph_dot()}'
-        dot_string += "\n}"
-        return dot_string
-
     @property
-    def nonterminals(self) -> set:
+    def nonterminals(self) -> Set[Symbol]:
         """ The set of nonterminals """
-
         return set(self._nonterminal_to_box.keys())
 
     @property
-    def boxes(self) -> dict:
+    def boxes(self) -> Set[Box]:
         """ The set of boxes """
-
-        return self._nonterminal_to_box
+        return set(self._nonterminal_to_box.values())
 
     @property
     def start_nonterminal(self) -> Symbol:
         """ The start nonterminal """
-
         return self._start_nonterminal
 
     @property
-    def start_box(self):
+    def start_box(self) -> Box:
         """ The start box """
-
-        return self.boxes[self.start_nonterminal]
+        return self._nonterminal_to_box[self.start_nonterminal]
 
     @classmethod
-    def from_regex(cls, regex: Regex, start_nonterminal: Union[Symbol, str]):
+    def from_regex(cls, regex: Regex, start_nonterminal: Hashable) \
+            -> "RecursiveAutomaton":
         """ Create a recursive automaton from regular expression
 
         Parameters
@@ -116,14 +100,17 @@ def from_regex(cls, regex: Regex, start_nonterminal: Union[Symbol, str]):
         return RecursiveAutomaton(box, {box})
 
     @classmethod
-    def from_ebnf(cls, text, start_nonterminal: Union[Symbol, str] = Symbol("S")):
-        """ Create a recursive automaton from ebnf (ebnf = Extended Backus-Naur Form)
+    def from_ebnf(cls, text: str, start_nonterminal: Hashable = Symbol("S")) \
+            -> "RecursiveAutomaton":
+        """ Create a recursive automaton from ebnf \
+            (ebnf = Extended Backus-Naur Form)
 
         Parameters
         -----------
         text : str
             The text of transform
-        start_nonterminal : :class:`~pyformlang.finite_automaton.Symbol` | str, optional
+        start_nonterminal : \
+            :class:`~pyformlang.finite_automaton.Symbol` | str, optional
             The start nonterminal, S by default
 
         Returns
@@ -132,7 +119,7 @@ def from_ebnf(cls, text, start_nonterminal: Union[Symbol, str] = Symbol("S")):
             The new recursive automaton built from context-free grammar
         """
         start_nonterminal = to_symbol(start_nonterminal)
-        productions = {}
+        productions: Dict[Hashable, str] = {}
         boxes = set()
         nonterminals = set()
         for production in text.splitlines():
@@ -160,7 +147,7 @@ def from_ebnf(cls, text, start_nonterminal: Union[Symbol, str] = Symbol("S")):
         start_box = Box(start_box_dfa, start_nonterminal)
         return RecursiveAutomaton(start_box, boxes)
 
-    def is_equals_to(self, other):
+    def is_equal_to(self, other: "RecursiveAutomaton") -> bool:
         """
         Check whether two recursive automata are equals by boxes.
         Not equivalency in terms of formal languages theory, just mapping boxes
@@ -175,9 +162,17 @@ def is_equals_to(self, other):
         are_equivalent : bool
             Whether the two recursive automata are equals or not
         """
+        return self.boxes == other.boxes
+
+    def __eq__(self, other: Any) -> bool:
         if not isinstance(other, RecursiveAutomaton):
             return False
-        return self.boxes == other.boxes
+        return self.is_equal_to(other)
 
-    def __eq__(self, other):
-        return self.is_equals_to(other)
+    def to_dot(self) -> str:
+        """ Create dot representation of recursive automaton """
+        dot_string = 'digraph "" {'
+        for box in self._nonterminal_to_box.values():
+            dot_string += f'\n{box.to_subgraph_dot()}'
+        dot_string += "\n}"
+        return dot_string