finish pda annotation

Author: bygu4

pyformlang/cfg/cfg.py

@@ -859,7 +859,7 @@ def _intersection_starting_rules(cfg: "CFG",
             new_body: List[CFGObject] = [
                 cv_converter.to_cfg_combined_variable(
                     start_other,
-                    cfg.start_symbol, # type: ignore
+                    cfg.start_symbol,
                     final_state)]
             productions_temp.append(
                 Production(start, new_body, filtering=False))
@@ -900,7 +900,7 @@ def _intersection_when_two_non_terminals(
                     cv_converter.to_cfg_combined_variable(
                         state_p, production.head, state_r)
                 productions_temp += [Production(new_head,
-                                                body, # type: ignore
+                                                body,
                                                 filtering=False)
                                      for body in bodies]
         return productions_temp
@@ -911,15 +911,15 @@ def _get_all_bodies(production: Production,
                         state_r: FAState,
                         states: Iterable[FAState],
                         cv_converter: CFGVariableConverter) \
-                            -> List[List[Variable]]:
+                            -> List[List[CFGObject]]:
         return [
             [cv_converter.to_cfg_combined_variable(
                 state_p,
-                production.body[0], # type: ignore
+                production.body[0],
                 state_q),
              cv_converter.to_cfg_combined_variable(
                  state_q,
-                 production.body[1], # type: ignore
+                 production.body[1],
                  state_r)]
             for state_q in states]
 

pyformlang/finite_automaton/finite_automaton.py

@@ -507,7 +507,7 @@ def to_networkx(self) -> MultiDiGraph:
                            peripheries=2 if state in self.final_states else 1,
                            label=state.value)
             if state in self.start_states:
-                add_start_state_to_graph(graph, state)
+                __add_start_state_to_graph(graph, state)
         for s_from, symbol, s_to in self._transition_function.get_edges():
             label_ = symbol.value
             if label_ == 'epsilon':
@@ -743,7 +743,7 @@ def to_symbol(given: Any) -> Symbol:
     return Symbol(given)
 
 
-def add_start_state_to_graph(graph: MultiDiGraph, state: State) -> None:
+def __add_start_state_to_graph(graph: MultiDiGraph, state: State) -> None:
     """ Adds a starting node to a given graph """
     graph.add_node("starting_" + str(state.value),
                    label="",

pyformlang/pda/cfg_variable_converter.py

@@ -2,23 +2,22 @@
 
 from typing import Dict, List, AbstractSet, Tuple, Optional, Any
 
-from pyformlang.finite_automaton import State
 from pyformlang.cfg import Variable
 
 class CFGVariableConverter:
     """A CFG Variable Converter"""
 
     def __init__(self,
-                 states: AbstractSet[State],
-                 stack_symbols: AbstractSet[Variable]) -> None:
+                 states: AbstractSet[Any],
+                 stack_symbols: AbstractSet[Any]) -> None:
         self._counter = 0
-        self._inverse_states_d: Dict[State, int] = {}
+        self._inverse_states_d: Dict[Any, int] = {}
         self._counter_state = 0
         for self._counter_state, state in enumerate(states):
             self._inverse_states_d[state] = self._counter_state
             state.index_cfg_converter = self._counter_state
         self._counter_state += 1
-        self._inverse_stack_symbol_d = {}
+        self._inverse_stack_symbol_d: Dict[Any, int] = {}
         self._counter_symbol = 0
         for self._counter_symbol, symbol in enumerate(stack_symbols):
             self._inverse_stack_symbol_d[symbol] = self._counter_symbol
@@ -29,7 +28,7 @@ def __init__(self,
                 for _ in range(len(stack_symbols))] for _ in
                range(len(states))]
 
-    def _get_state_index(self, state: State) -> int:
+    def _get_state_index(self, state: Any) -> int:
         """Get the state index"""
         if state.index_cfg_converter is None:
             if state not in self._inverse_states_d:
@@ -38,7 +37,7 @@ def _get_state_index(self, state: State) -> int:
             state.index_cfg_converter = self._inverse_states_d[state]
         return state.index_cfg_converter
 
-    def _get_symbol_index(self, symbol: Variable) -> int:
+    def _get_symbol_index(self, symbol: Any) -> int:
         """Get the symbol index"""
         if symbol.index_cfg_converter is None:
             if symbol not in self._inverse_stack_symbol_d:
@@ -48,9 +47,9 @@ def _get_symbol_index(self, symbol: Variable) -> int:
         return symbol.index_cfg_converter
 
     def to_cfg_combined_variable(self,
-                                 state0: State,
-                                 stack_symbol: Variable,
-                                 state1: State) -> Variable:
+                                 state0: Any,
+                                 stack_symbol: Any,
+                                 state1: Any) -> Variable:
         """ Conversion used in the to_pda method """
         i_stack_symbol, i_state0, i_state1 = self._get_indexes(
             stack_symbol, state0, state1)
@@ -75,19 +74,19 @@ def _create_new_variable(self,
         return temp
 
     def set_valid(self,
-                  state0: State,
-                  stack_symbol: Variable,
-                  state1: State) -> None:
+                  state0: Any,
+                  stack_symbol: Any,
+                  state1: Any) -> None:
         """Set valid"""
         i_stack_symbol, i_state0, i_state1 = self._get_indexes(
             stack_symbol, state0, state1)
         prev = self._conversions[i_state0][i_stack_symbol][i_state1]
         self._conversions[i_state0][i_stack_symbol][i_state1] = (True, prev[1])
 
     def is_valid_and_get(self,
-                         state0: State,
-                         stack_symbol: Variable,
-                         state1: State) -> Optional[Variable]:
+                         state0: Any,
+                         stack_symbol: Any,
+                         state1: Any) -> Optional[Variable]:
         """Check if valid and get"""
         i_state0 = self._get_state_index(state0)
         i_stack_symbol = self._get_symbol_index(stack_symbol)
@@ -103,9 +102,9 @@ def is_valid_and_get(self,
         return current[1]
 
     def _get_indexes(self,
-                     stack_symbol: Variable,
-                     state0: State,
-                     state1: State) \
+                     stack_symbol: Any,
+                     state0: Any,
+                     state1: Any) \
             -> Tuple[int, int, int]:
         i_state0 = self._get_state_index(state0)
         i_stack_symbol = self._get_symbol_index(stack_symbol)