add pda module annotations, rework pda objects

Author: bygu4

pyformlang/pda/epsilon.py

@@ -1,11 +1,11 @@
 """ An epsilon symbol """
 
-from .symbol import Symbol
+from .stack_symbol import StackSymbol
 
 
-class Epsilon(Symbol):
+class Epsilon(StackSymbol):
     """ An epsilon symbol """
     # pylint: disable=too-few-public-methods
 
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__("epsilon")

pyformlang/pda/pda.py

@@ -0,0 +1,27 @@
+""" Basic PDA object representation """
+
+from typing import Any
+
+
+class PDAObject:
+    """ Basic PDA object representation """
+
+    def __init__(self, value: Any) -> None:
+        self._value = value
+        self._hash = None
+
+    def __hash__(self) -> int:
+        if self._hash is None:
+            self._hash = hash(self._value)
+        return self._hash
+
+    @property
+    def value(self) -> Any:
+        """ Returns the value of the object """
+        return self._value
+
+    def __eq__(self, other: Any) -> bool:
+        raise NotImplementedError
+
+    def __repr__(self) -> str:
+        raise NotImplementedError

pyformlang/pda/pda_object.py

@@ -1,9 +1,10 @@
 """ A StackSymbol in a pushdown automaton """
 
-from typing import Optional
+from typing import Optional, Any
 
+from .symbol import Symbol
 
-class StackSymbol:
+class StackSymbol(Symbol):
     """ A StackSymbol in a pushdown automaton
 
     Parameters
@@ -13,13 +14,15 @@ class StackSymbol:
 
     """
 
-    def __init__(self, value):
-        self._value = value
-        self._hash = None
+    def __init__(self, value: Any) -> None:
+        super().__init__(value)
         self.index_cfg_converter: Optional[int] = None
 
+    def __hash__(self) -> int:
+        return super().__hash__()
+
     @property
-    def value(self):
+    def value(self) -> Any:
         """ Returns the value of the stack symbol
 
         Returns
@@ -29,13 +32,10 @@ def value(self):
         """
         return self._value
 
-    def __hash__(self):
-        if self._hash is None:
-            self._hash = hash(self._value)
-        return self._hash
-
-    def __eq__(self, other):
-        return self._value == other.value
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, StackSymbol):
+            return self._value == other.value
+        return False
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return "StackSymbol(" + str(self._value) + ")"

pyformlang/pda/stack_symbol.py

@@ -1,7 +1,11 @@
 """ A State in a pushdown automaton """
 
+from typing import Optional, Any
 
-class State:
+from .pda_object import PDAObject
+
+
+class State(PDAObject):
     """ A State in a pushdown automaton
 
     Parameters
@@ -11,19 +15,16 @@ class State:
 
     """
 
-    def __init__(self, value):
-        self._value = value
-        self._hash = None
-        self.index_cfg_converter = None
+    def __init__(self, value: Any) -> None:
+        super().__init__(value)
+        self.index_cfg_converter: Optional[int] = None
 
-    def __hash__(self):
-        if self._hash is None:
-            self._hash = hash(self._value)
-        return self._hash
+    def __hash__(self) -> int:
+        return super().__hash__()
 
     @property
-    def value(self):
-        """ Returns the value of the state
+    def value(self) -> Any:
+        """ Returns the value of the symbol
 
         Returns
         ----------
@@ -32,10 +33,10 @@ def value(self):
         """
         return self._value
 
-    def __eq__(self, other):
+    def __eq__(self, other: Any) -> bool:
         if isinstance(other, State):
             return self._value == other.value
         return False
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return "State(" + str(self._value) + ")"

pyformlang/pda/state.py

@@ -1,7 +1,11 @@
 """ A Symbol in a pushdown automaton """
 
+from typing import Any
 
-class Symbol:
+from .pda_object import PDAObject
+
+
+class Symbol(PDAObject):
     """ A Symbol in a pushdown automaton
 
     Parameters
@@ -11,14 +15,11 @@ class Symbol:
 
     """
 
-    def __init__(self, value):
-        self._value = value
-
-    def __hash__(self):
-        return hash(str(self._value))
+    def __hash__(self) -> int:
+        return super().__hash__()
 
     @property
-    def value(self):
+    def value(self) -> Any:
         """ Returns the value of the symbol
 
         Returns
@@ -28,10 +29,10 @@ def value(self):
         """
         return self._value
 
-    def __eq__(self, other):
+    def __eq__(self, other: Any) -> bool:
         if isinstance(other, Symbol):
             return self._value == other.value
         return False
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return "Symbol(" + str(self._value) + ")"

pyformlang/pda/symbol.py

@@ -1,6 +1,6 @@
 """ A transition function in a pushdown automaton """
 
-from typing import List
+from typing import Dict, List, Set, Iterator, Tuple, Optional
 
 from .stack_symbol import StackSymbol
 from .state import State
@@ -10,13 +10,17 @@
 class TransitionFunction:
     """ A transition function in a pushdown automaton """
 
-    def __init__(self):
-        self._transitions = {}
-        self._iter_key = None
-        self._current_key = None
-        self._iter_inside = None
+    def __init__(self) -> None:
+        self._transitions: Dict[Tuple[State, Symbol, StackSymbol],
+                                Set[Tuple[State, List[StackSymbol]]]] = {}
+        self._iter_key: Optional[Iterator[
+            Tuple[State, Symbol, StackSymbol]]] = None
+        self._current_key: Optional[
+            Tuple[State, Symbol, StackSymbol]] = None
+        self._iter_inside: Optional[Iterator[
+            Tuple[State, List[StackSymbol]]]] = None
 
-    def get_number_transitions(self):
+    def get_number_transitions(self) -> int:
         """ Gets the number of transitions
 
         Returns
@@ -32,7 +36,7 @@ def add_transition(self,
                        input_symbol: Symbol,
                        stack_from: StackSymbol,
                        s_to: State,
-                       stack_to: List[StackSymbol]):
+                       stack_to: List[StackSymbol]) -> None:
         """ Add a transition to the function
 
         Parameters
@@ -49,7 +53,7 @@ def add_transition(self,
             The string of stack symbol which replace the stack_from
         """
         temp_in = (s_from, input_symbol, stack_from)
-        temp_out = (s_to, tuple(stack_to))
+        temp_out = (s_to, stack_to.copy())
         if temp_in in self._transitions:
             self._transitions[temp_in].add(temp_out)
         else:
@@ -70,31 +74,35 @@ def copy(self) -> "TransitionFunction":
                                       temp_out[0], temp_out[1])
         return new_tf
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator[Tuple[Tuple[State, Symbol, StackSymbol],
+                                         Tuple[State, List[StackSymbol]]]]:
         self._iter_key = iter(self._transitions.keys())
         self._current_key = None
         self._iter_inside = None
         return self
 
-    def __next__(self):
+    def __next__(self) -> Tuple[Tuple[State, Symbol, StackSymbol],
+                                Tuple[State, List[StackSymbol]]]:
         if self._iter_inside is None:
-            next_key = next(self._iter_key)
+            next_key = next(self._iter_key) # type: ignore
             self._current_key = next_key
             self._iter_inside = iter(self._transitions[next_key])
         try:
             next_value = next(self._iter_inside)
-            return self._current_key, next_value
+            return self._current_key, next_value # type: ignore
         except StopIteration:
-            next_key = next(self._iter_key)
+            next_key = next(self._iter_key) # type: ignore
             self._current_key = next_key
             self._iter_inside = iter(self._transitions[next_key])
             return next(self)
 
     def __call__(self, s_from: State,
                  input_symbol: Symbol,
-                 stack_from: StackSymbol):
-        return self._transitions.get((s_from, input_symbol, stack_from), {})
+                 stack_from: StackSymbol) \
+                     -> Set[Tuple[State, List[StackSymbol]]]:
+        return self._transitions.get((s_from, input_symbol, stack_from), set())
 
-    def to_dict(self):
+    def to_dict(self) -> Dict[Tuple[State, Symbol, StackSymbol],
+                              Set[Tuple[State, List[StackSymbol]]]]:
         """Get the dictionary representation of the transitions"""
         return self._transitions

pyformlang/pda/transition_function.py

@@ -1,5 +1,7 @@
 """ Useful functions for a PDA """
 
+from typing import Type, Dict, Any
+
 from .state import State
 from .symbol import Symbol
 from .stack_symbol import StackSymbol
@@ -11,26 +13,26 @@ class PDAObjectCreator:
     A Object in a PDA
     """
 
-    def __init__(self):
-        self._state_creator = {}
-        self._symbol_creator = {}
-        self._stack_symbol_creator = {}
+    def __init__(self) -> None:
+        self._state_creator: Dict[Any, State] = {}
+        self._symbol_creator: Dict[Any, Symbol] = {}
+        self._stack_symbol_creator: Dict[Any, StackSymbol] = {}
 
-    def to_state(self, given):
+    def to_state(self, given: Any) -> State:
         """ Convert to a state """
         if isinstance(given, State):
             return _get_object_from_known(given, self._state_creator)
         return _get_object_from_raw(given, self._state_creator, State)
 
-    def to_symbol(self, given):
+    def to_symbol(self, given: Any) -> Symbol:
         """ Convert to a symbol """
         if isinstance(given, Symbol):
             return _get_object_from_known(given, self._symbol_creator)
         if given == "epsilon":
             return Epsilon()
         return _get_object_from_raw(given, self._symbol_creator, Symbol)
 
-    def to_stack_symbol(self, given):
+    def to_stack_symbol(self, given: Any) -> StackSymbol:
         """ Convert to a stack symbol """
         if isinstance(given, StackSymbol):
             return _get_object_from_known(given,
@@ -42,14 +44,17 @@ def to_stack_symbol(self, given):
                                     StackSymbol)
 
 
-def _get_object_from_known(given, obj_converter):
+def _get_object_from_known(given: Any,
+                           obj_converter: Dict[Any, Any]) -> Any:
     if given.value in obj_converter:
         return obj_converter[given.value]
     obj_converter[given.value] = given
     return given
 
 
-def _get_object_from_raw(given, obj_converter, to_type):
+def _get_object_from_raw(given: Any,
+                         obj_converter: Dict[Any, Any],
+                         to_type: Type) -> Any:
     if given in obj_converter:
         return obj_converter[given]
     temp = to_type(given)