correct indexed grammar annotations and imports

Author: bygu4

pyformlang/fst/fst.py

@@ -422,12 +422,12 @@ def _add_transitions_to(self,
                             idx: int) -> None:
         for head, transition in self._delta.items():
             s_from, input_symbol = head
-            for s_to, output_symbol in transition:
+            for s_to, output_symbols in transition:
                 union_fst.add_transition(
                     state_renaming.get_renamed_state(s_from, idx),
                     input_symbol,
                     state_renaming.get_renamed_state(s_to, idx),
-                    output_symbol)
+                    output_symbols)
 
     def _add_extremity_states_to(self,
                                  union_fst: "FST",

pyformlang/indexed_grammar/__init__.py

@@ -23,16 +23,23 @@
 """
 
 from .rules import Rules
+from .reduced_rule import ReducedRule
 from .consumption_rule import ConsumptionRule
 from .end_rule import EndRule
 from .production_rule import ProductionRule
 from .duplication_rule import DuplicationRule
 from .indexed_grammar import IndexedGrammar
+from ..objects.cfg_objects import CFGObject, Variable, Terminal, Epsilon
 
 
 __all__ = ["Rules",
+           "ReducedRule",
            "ConsumptionRule",
            "EndRule",
            "ProductionRule",
            "DuplicationRule",
-           "IndexedGrammar"]
+           "IndexedGrammar",
+           "CFGObject",
+           "Variable",
+           "Terminal",
+           "Epsilon"]

pyformlang/indexed_grammar/consumption_rule.py

@@ -3,13 +3,12 @@
 the stack
 """
 
-from typing import List, Set, Any
+from typing import List, Set, Hashable, Any
 
-from pyformlang.cfg import Variable, Terminal
-from pyformlang.cfg.utils import to_variable, to_terminal
-from pyformlang.cfg.cfg_object import CFGObject
+from pyformlang.cfg import CFGObject, Variable, Terminal
 
 from .reduced_rule import ReducedRule
+from ..objects.cfg_objects.utils import to_variable, to_terminal
 
 
 class ConsumptionRule(ReducedRule):
@@ -27,14 +26,10 @@ class ConsumptionRule(ReducedRule):
         The non terminal on the right (here B)
     """
 
-    @property
-    def production(self) -> Terminal:
-        raise NotImplementedError
-
     def __init__(self,
-                 f_param: Any,
-                 left_term: Any,
-                 right_term: Any) -> None:
+                 f_param: Hashable,
+                 left_term: Hashable,
+                 right_term: Hashable) -> None:
         self._f = to_terminal(f_param)
         self._left_term = to_variable(left_term)
         self._right_term = to_variable(right_term)
@@ -50,6 +45,10 @@ def f_parameter(self) -> Terminal:
         """
         return self._f
 
+    @property
+    def production(self) -> Terminal:
+        raise NotImplementedError
+
     @property
     def left_term(self) -> Variable:
         """Gets the symbol on the left of the rule
@@ -97,12 +96,12 @@ def terminals(self) -> Set[Terminal]:
         """
         return {self._f}
 
-    def __repr__(self) -> str:
-        return f"{self._left_term} [ {self._f} ] -> {self._right_term}"
-
     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
+
+    def __repr__(self) -> str:
+        return f"{self._left_term} [ {self._f} ] -> {self._right_term}"

pyformlang/indexed_grammar/duplication_rule.py

@@ -2,13 +2,12 @@
 A representation of a duplication rule, i.e. a rule that duplicates the stack
 """
 
-from typing import List, Set, Any
+from typing import List, Set, Hashable, Any
 
-from pyformlang.cfg import Variable, Terminal
-from pyformlang.cfg.utils import to_variable
-from pyformlang.cfg.cfg_object import CFGObject
+from pyformlang.cfg import CFGObject, Variable, Terminal
 
 from .reduced_rule import ReducedRule
+from ..objects.cfg_objects.utils import to_variable
 
 
 class DuplicationRule(ReducedRule):
@@ -25,6 +24,14 @@ class DuplicationRule(ReducedRule):
         The second non-terminal on the right of the rule (C here)
     """
 
+    def __init__(self,
+                 left_term: Hashable,
+                 right_term0: Hashable,
+                 right_term1: Hashable) -> None:
+        self._left_term = to_variable(left_term)
+        self._right_terms = (to_variable(right_term0),
+                             to_variable(right_term1))
+
     @property
     def f_parameter(self) -> Terminal:
         raise NotImplementedError
@@ -33,18 +40,6 @@ def f_parameter(self) -> Terminal:
     def production(self) -> Terminal:
         raise NotImplementedError
 
-    @property
-    def right_term(self) -> CFGObject:
-        raise NotImplementedError
-
-    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))
-
     @property
     def left_term(self) -> Variable:
         """Gives the non-terminal on the left of the rule
@@ -56,6 +51,10 @@ def left_term(self) -> Variable:
         """
         return self._left_term
 
+    @property
+    def right_term(self) -> CFGObject:
+        raise NotImplementedError
+
     @property
     def right_terms(self) -> List[CFGObject]:
         """Gives the non-terminals on the right of the rule
@@ -89,13 +88,13 @@ def terminals(self) -> Set[Terminal]:
         """
         return set()
 
-    def __repr__(self) -> str:
-        """Gives a string representation of the rule, ignoring the sigmas"""
-        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
+
+    def __repr__(self) -> str:
+        """Gives a string representation of the rule, ignoring the sigmas"""
+        return f"{self._left_term} -> \
+            {self._right_terms[0]} {self._right_terms[1]}"

pyformlang/indexed_grammar/end_rule.py

@@ -2,13 +2,12 @@
 Represents a end rule, i.e. a rule which give only a terminal
 """
 
-from typing import List, Set, Any
+from typing import List, Set, Hashable, Any
 
-from pyformlang.cfg import Variable, Terminal
-from pyformlang.cfg.utils import to_variable, to_terminal
-from pyformlang.cfg.cfg_object import CFGObject
+from pyformlang.cfg import CFGObject, Variable, Terminal
 
 from .reduced_rule import ReducedRule
+from ..objects.cfg_objects.utils import to_variable, to_terminal
 
 
 class EndRule(ReducedRule):
@@ -23,6 +22,10 @@ class EndRule(ReducedRule):
         The terminal on the right, "a" here
     """
 
+    def __init__(self, left_term: Hashable, right_term: Hashable) -> None:
+        self._left_term = to_variable(left_term)
+        self._right_term = to_terminal(right_term)
+
     @property
     def f_parameter(self) -> Terminal:
         raise NotImplementedError
@@ -31,10 +34,6 @@ def f_parameter(self) -> Terminal:
     def production(self) -> Terminal:
         raise NotImplementedError
 
-    def __init__(self, left_term: Any, right_term: Any) -> None:
-        self._left_term = to_variable(left_term)
-        self._right_term = to_terminal(right_term)
-
     @property
     def left_term(self) -> Variable:
         """Gets the non-terminal on the left of the rule
@@ -90,12 +89,12 @@ def terminals(self) -> Set[Terminal]:
         """
         return {self._right_term}
 
-    def __repr__(self) -> str:
-        """Gets the string representation of the rule"""
-        return f"{self._left_term} -> {self._right_term}"
-
     def __eq__(self, other: Any) -> bool:
         if not isinstance(other, EndRule):
             return False
         return other.left_term == self.left_term \
             and other.right_term == self.right_term
+
+    def __repr__(self) -> str:
+        """Gets the string representation of the rule"""
+        return f"{self._left_term} -> {self._right_term}"