add indexed_grammar type annotations, rewrite rules in a stricter way

Author: bygu4

pyformlang/fst/fst.py

@@ -291,22 +291,22 @@ def _extract_indexed_grammar_rules_intersection(
             new_rules: List[ReducedRule]) \
                 -> None:
         for rule in rules.rules:
-            if rule.is_duplication():
+            if isinstance(rule, DuplicationRule):
                 for state_p in self._states:
                     for state_q in self._states:
                         for state_r in self._states:
                             new_rules.append(DuplicationRule(
                                 str((state_p, rule.left_term, state_q)),
                                 str((state_p, rule.right_terms[0], state_r)),
                                 str((state_r, rule.right_terms[1], state_q))))
-            elif rule.is_production():
+            elif isinstance(rule, ProductionRule):
                 for state_p in self._states:
                     for state_q in self._states:
                         new_rules.append(ProductionRule(
                             str((state_p, rule.left_term, state_q)),
                             str((state_p, rule.right_term, state_q)),
                             str(rule.production)))
-            elif rule.is_end_rule():
+            elif isinstance(rule, EndRule):
                 for state_p in self._states:
                     for state_q in self._states:
                         new_rules.append(DuplicationRule(
@@ -346,7 +346,7 @@ def _extract_consumption_rules_intersection(
                         new_rules.append(ConsumptionRule(
                             consumption.f_parameter,
                             str((state_r, consumption.left_term, state_s)),
-                            str((state_r, consumption.right, state_s))))
+                            str((state_r, consumption.right_term, state_s))))
 
     def __and__(self, other: IndexedGrammar) -> IndexedGrammar:
         return self.intersection(other)

pyformlang/indexed_grammar/consumption_rule.py

@@ -3,7 +3,11 @@
 the stack
 """
 
-from typing import Any, Iterable, AbstractSet
+from typing import List, Set, Any
+
+from pyformlang.cfg import Variable, Terminal
+from pyformlang.cfg.utils import to_variable, to_terminal
+from pyformlang.cfg.cfg_object import CFGObject
 
 from .reduced_rule import ReducedRule
 
@@ -24,30 +28,19 @@ class ConsumptionRule(ReducedRule):
     """
 
     @property
-    def right_term(self):
-        raise NotImplementedError
-
-    @property
-    def right_terms(self):
+    def production(self) -> Terminal:
         raise NotImplementedError
 
-    def __init__(self, f_param: Any, left: Any, right: Any):
-        self._f = f_param
-        self._right = right
-        self._left_term = left
-
-    def is_consumption(self) -> bool:
-        """Whether the rule is a consumption rule or not
-
-        Returns
-        ----------
-        is_consumption : bool
-            Whether the rule is a consumption rule or not
-        """
-        return True
+    def __init__(self,
+                 f_param: Any,
+                 left_term: Any,
+                 right_term: Any) -> None:
+        self._f = to_terminal(f_param)
+        self._left_term = to_variable(left_term)
+        self._right_term = to_variable(right_term)
 
     @property
-    def f_parameter(self) -> Any:
+    def f_parameter(self) -> Terminal:
         """Gets the symbol which is consumed
 
         Returns
@@ -58,49 +51,58 @@ def f_parameter(self) -> Any:
         return self._f
 
     @property
-    def production(self):
-        raise NotImplementedError
+    def left_term(self) -> Variable:
+        """Gets the symbol on the left of the rule
+
+        left : any
+            The left symbol of the rule
+        """
+        return self._left_term
 
     @property
-    def right(self) -> Any:
-        """Gets the symbole on the right of the rule
+    def right_term(self) -> Variable:
+        """Gets the symbol on the right of the rule
 
         right : any
             The right symbol
         """
-        return self._right
+        return self._right_term
 
     @property
-    def left_term(self) -> Any:
-        """Gets the symbol on the left of the rule
+    def right_terms(self) -> List[CFGObject]:
+        """Gives the non-terminals on the right of the rule
 
-        left : any
-            The left symbol of the rule
+        Returns
+        ---------
+        right_terms : iterable of any
+            The right terms of the rule
         """
-        return self._left_term
+        return [self._right_term]
 
     @property
-    def non_terminals(self) -> Iterable[Any]:
+    def non_terminals(self) -> Set[Variable]:
         """Gets the non-terminals used in the rule
 
         non_terminals : iterable of any
             The non_terminals used in the rule
         """
-        return [self._left_term, self._right]
+        return {self._left_term, self._right_term}
 
     @property
-    def terminals(self) -> AbstractSet[Any]:
+    def terminals(self) -> Set[Terminal]:
         """Gets the terminals used in the rule
 
         terminals : set of any
             The terminals used in the rule
         """
         return {self._f}
 
-    def __repr__(self):
-        return self._left_term + " [ " + self._f + " ] -> " + self._right
+    def __repr__(self) -> str:
+        return f"{self._left_term} [ {self._f} ] -> {self._right_term}"
 
-    def __eq__(self, other):
-        return other.is_consumption() and other.left_term == \
-               self.left_term and other.right == self.right and \
-               other.f_parameter() == self.f_parameter
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, ConsumptionRule):
+            return False
+        return other.left_term == self.left_term \
+            and other.right_term == self.right_term \
+            and other.f_parameter == self.f_parameter

pyformlang/indexed_grammar/duplication_rule.py

@@ -2,7 +2,11 @@
 A representation of a duplication rule, i.e. a rule that duplicates the stack
 """
 
-from typing import Any, Iterable, AbstractSet, Tuple
+from typing import List, Set, Any
+
+from pyformlang.cfg import Variable, Terminal
+from pyformlang.cfg.utils import to_variable
+from pyformlang.cfg.cfg_object import CFGObject
 
 from .reduced_rule import ReducedRule
 
@@ -22,66 +26,60 @@ class DuplicationRule(ReducedRule):
     """
 
     @property
-    def production(self):
+    def f_parameter(self) -> Terminal:
         raise NotImplementedError
 
     @property
-    def right_term(self):
+    def production(self) -> Terminal:
         raise NotImplementedError
 
     @property
-    def f_parameter(self):
+    def right_term(self) -> CFGObject:
         raise NotImplementedError
 
-    def __init__(self, left_term, right_term0, right_term1):
-        self._left_term = left_term
-        self._right_terms = (right_term0, right_term1)
+    def __init__(self,
+                 left_term: Any,
+                 right_term0: Any,
+                 right_term1: Any) -> None:
+        self._left_term = to_variable(left_term)
+        self._right_terms = (to_variable(right_term0),
+                             to_variable(right_term1))
 
-    def is_duplication(self) -> bool:
-        """Whether the rule is a duplication rule or not
+    @property
+    def left_term(self) -> Variable:
+        """Gives the non-terminal on the left of the rule
 
         Returns
-        ----------
-        is_duplication : bool
-            Whether the rule is a duplication rule or not
+        ---------
+        left_term : any
+            The left term of the rule
         """
-        return True
+        return self._left_term
 
     @property
-    def right_terms(self) -> Tuple[Any, Any]:
+    def right_terms(self) -> List[CFGObject]:
         """Gives the non-terminals on the right of the rule
 
         Returns
         ---------
         right_terms : iterable of any
             The right terms of the rule
         """
-        return self._right_terms
+        return list(self._right_terms)
 
     @property
-    def left_term(self) -> Any:
-        """Gives the non-terminal on the left of the rule
-
-        Returns
-        ---------
-        left_term : any
-            The left term of the rule
-        """
-        return self._left_term
-
-    @property
-    def non_terminals(self) -> Iterable[Any]:
+    def non_terminals(self) -> Set[Variable]:
         """Gives the set of non-terminals used in this rule
 
         Returns
         ---------
         non_terminals : iterable of any
             The non terminals used in this rule
         """
-        return [self._left_term, self._right_terms[0], self._right_terms[1]]
+        return {self._left_term, *self._right_terms}
 
     @property
-    def terminals(self) -> AbstractSet[Any]:
+    def terminals(self) -> Set[Terminal]:
         """Gets the terminals used in the rule
 
         Returns
@@ -91,11 +89,13 @@ def terminals(self) -> AbstractSet[Any]:
         """
         return set()
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         """Gives a string representation of the rule, ignoring the sigmas"""
-        return self._left_term + " -> " + self._right_terms[0] + \
-            " " + self._right_terms[1]
-
-    def __eq__(self, other):
-        return other.is_duplication() and other.left_term == \
-               self._left_term and other.right_terms == self.right_terms
+        return f"{self._left_term} -> \
+            {self._right_terms[0]} {self._right_terms[1]}"
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, DuplicationRule):
+            return False
+        return other.left_term == self._left_term \
+            and other.right_terms == self.right_terms