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
+from typing import Set, Any
 
 from pyformlang.finite_automaton.epsilon_nfa import EpsilonNFA
 from pyformlang.finite_automaton.finite_automaton import to_symbol
+from pyformlang.finite_automaton.state import State
 from pyformlang.finite_automaton.symbol import Symbol
 
 
@@ -22,15 +23,13 @@ class Box:
 
     """
 
-    def __init__(self, enfa: EpsilonNFA, nonterminal: Union[Symbol, str]):
-        self._dfa = enfa
+    def __init__(self, enfa: EpsilonNFA, nonterminal: Any) -> None:
+        self._enfa: EpsilonNFA = enfa
+        self._nonterminal: Symbol = to_symbol(nonterminal)
 
-        nonterminal = to_symbol(nonterminal)
-        self._nonterminal = nonterminal
-
-    def to_subgraph_dot(self):
+    def to_subgraph_dot(self) -> str:
         """Creates a named subgraph representing a box"""
-        graph = self._dfa.to_networkx()
+        graph = self._enfa.to_networkx()
         strange_nodes = []
         nonterminal = self.nonterminal.value.replace('"', '').replace("'", "").replace(".", "")
         dot_string = (f'subgraph cluster_{nonterminal}\n{{ label="{nonterminal}"\n'
@@ -58,26 +57,26 @@ def to_subgraph_dot(self):
         return dot_string
 
     @property
-    def dfa(self):
-        """ Box's dfa """
-        return self._dfa
+    def enfa(self) -> EpsilonNFA:
+        """ Box's enfa """
+        return self._enfa
 
     @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
+        return self._enfa.start_states
 
     @property
-    def final_states(self):
+    def final_states(self) -> Set[State]:
         """ The final states """
-        return self._dfa.final_states
+        return self._enfa.final_states
 
-    def is_equivalent_to(self, other):
+    def is_equivalent_to(self, other: "Box") -> bool:
         """ Check whether two boxes are equivalent
 
         Parameters
@@ -91,13 +90,13 @@ def is_equivalent_to(self, other):
             Whether the two boxes are equivalent or not
         """
 
+        return self._enfa.is_equivalent_to(other.enfa) \
+            and self.nonterminal == other.nonterminal
+
+    def __eq__(self, other: Any) -> bool:
         if not isinstance(other, Box):
             return False
-
-        return self._dfa.is_equivalent_to(other.dfa) and self.nonterminal == other.nonterminal
-
-    def __eq__(self, other):
         return self.is_equivalent_to(other)
 
-    def __hash__(self):
+    def __hash__(self) -> int:
         return self._nonterminal.__hash__()

pyformlang/rsa/recursive_automaton.py

@@ -2,7 +2,7 @@
 Representation of a recursive automaton
 """
 
-from typing import AbstractSet, Union
+from typing import Dict, Set, AbstractSet, Optional, Any
 
 from pyformlang.finite_automaton.finite_automaton import to_symbol
 from pyformlang.finite_automaton.symbol import Symbol
@@ -28,15 +28,16 @@ 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] = {}
         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[
+                to_symbol(start_box.nonterminal)] = start_box
+        self._start_nonterminal: Symbol = to_symbol(start_box.nonterminal)
         for box in boxes:
             self._nonterminal_to_box[to_symbol(box.nonterminal)] = box
 
-    def get_box_by_nonterminal(self, nonterminal: Union[Symbol, str]):
+    def get_box_by_nonterminal(self, nonterminal: Any) -> Optional[Box]:
         """
         Box by nonterminal
 
@@ -54,15 +55,13 @@ 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 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):
+    def to_dot(self) -> str:
         """ Create dot representation of recursive automaton """
         dot_string = 'digraph "" {'
         for box in self._nonterminal_to_box.values():
@@ -71,31 +70,28 @@ def to_dot(self):
         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) -> Dict[Symbol, Box]:
         """ The set of boxes """
-
         return self._nonterminal_to_box
 
     @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]
 
     @classmethod
-    def from_regex(cls, regex: Regex, start_nonterminal: Union[Symbol, str]):
+    def from_regex(cls, regex: Regex, start_nonterminal: Any) \
+            -> "RecursiveAutomaton":
         """ Create a recursive automaton from regular expression
 
         Parameters
@@ -115,14 +111,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: Any = 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
@@ -155,10 +154,11 @@ def from_ebnf(cls, text, start_nonterminal: Union[Symbol, str] = Symbol("S")):
         for head, body in productions.items():
             boxes.add(Box(Regex(body).to_epsilon_nfa().minimize(),
                           to_symbol(head)))
-        start_box = Box(Regex(productions[start_nonterminal.value]).to_epsilon_nfa().minimize(), start_nonterminal)
+        start_box = Box(Regex(productions[start_nonterminal.value]) \
+            .to_epsilon_nfa().minimize(), 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
@@ -173,9 +173,9 @@ def is_equals_to(self, other):
         are_equivalent : bool
             Whether the two recursive automata are equals or not
         """
-        if not isinstance(other, RecursiveAutomaton):
-            return False
         return self.boxes == other.boxes
 
-    def __eq__(self, other):
-        return self.is_equals_to(other)
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, RecursiveAutomaton):
+            return False
+        return self.is_equal_to(other)