debug indexed grammar intersection and generating variables obtaining

Author: bygu4

pyformlang/fst/fst.py

@@ -146,6 +146,19 @@ def add_transitions(self, transitions: Iterable[InputTransition]) -> None:
                                 s_to,
                                 output_symbols)
 
+    def remove_transition(self,
+                          s_from: Hashable,
+                          input_symbol: Hashable,
+                          s_to: Hashable,
+                          output_symbols: Iterable[Hashable]) -> None:
+        """ Removes the given transition from the FST """
+        s_from = to_state(s_from)
+        input_symbol = to_symbol(input_symbol)
+        s_to = to_state(s_to)
+        output_symbols = tuple(to_symbol(x) for x in output_symbols)
+        head = (s_from, input_symbol)
+        self._delta.get(head, set()).discard((s_to, output_symbols))
+
     def add_start_state(self, start_state: Hashable) -> None:
         """ Add a start state
 

pyformlang/fst/tests/test_fst.py

@@ -190,3 +190,29 @@ def test_paper(self):
         assert len(translation) == 2
         fst.write_as_dot("fst.dot")
         assert path.exists("fst.dot")
+
+    def test_contains(self, fst0: FST):
+        """ Tests the containment of transition in the FST """
+        assert ("q0", "a", "q1", ["b"]) in fst0
+        assert ("a", "b", "c", "d") not in fst0
+        fst0.add_transition("a", "b", "c", "d")
+        assert ("a", "b", "c", "d") in fst0
+
+    def test_iter(self, fst0: FST):
+        """ Tests the iteration of FST transitions """
+        fst0.add_transition("q1", "A", "q2", ["B"])
+        fst0.add_transition("q1", "A", "q2", ["C", "D"])
+        transitions = list(iter(fst0))
+        assert (("q0", "a"), ("q1", tuple("b"))) in transitions
+        assert (("q1", "A"), ("q2", tuple("B"))) in transitions
+        assert (("q1", "A"), ("q2", ("C", "D"))) in transitions
+        assert len(transitions) == 3
+
+    def test_remove_transition(self, fst0: FST):
+        """ Tests the removal of transition from the FST """
+        assert ("q0", "a", "q1", "b") in fst0
+        fst0.remove_transition("q0", "a", "q1", "b")
+        assert ("q0", "a", "q1", "b") not in fst0
+        fst0.remove_transition("q0", "a", "q1", "b")
+        assert ("q0", "a", "q1", "b") not in fst0
+        assert fst0.get_number_transitions() == 0

pyformlang/fst/utils.py

@@ -1,4 +1,4 @@
-""" Class for renaming the states in FST """
+""" Utility for FST """
 
 from typing import Dict, Set, Iterable, Tuple
 

pyformlang/indexed_grammar/indexed_grammar.py

@@ -259,7 +259,7 @@ def get_generating_non_terminals(self) -> Set[Variable]:
         """
         # Preprocess
         generating_from: Dict[Variable, Set[Variable]] = {}
-        duplication_pointer: Dict[CFGObject, List[Tuple[Variable, int]]] = {}
+        duplication_pointer: Dict[CFGObject, List[List]] = {}
         generating = set()
         to_process = []
         self._preprocess_rules_generating(duplication_pointer, generating,
@@ -272,12 +272,12 @@ def get_generating_non_terminals(self) -> Set[Variable]:
                 if symbol not in generating:
                     generating.add(symbol)
                     to_process.append(symbol)
-            for symbol, pointer in duplication_pointer.get(current, []):
-                pointer -= 1
-                if pointer == 0:
-                    if symbol not in generating:
-                        generating.add(symbol)
-                        to_process.append(symbol)
+            for duplication in duplication_pointer.get(current, []):
+                duplication[1] -= 1
+                if duplication[1] == 0:
+                    if duplication[0] not in generating:
+                        generating.add(duplication[0])
+                        to_process.append(duplication[0])
         return generating
 
     def _preprocess_consumption_rules_generating(
@@ -295,7 +295,7 @@ def _preprocess_consumption_rules_generating(
 
     def _preprocess_rules_generating(
         self,
-        duplication_pointer: Dict[CFGObject, List[Tuple[Variable, int]]],
+        duplication_pointer: Dict[CFGObject, List[List]],
         generating: Set[Variable],
         generating_from: Dict[Variable, Set[Variable]],
         to_process: List[Variable]) \
@@ -305,7 +305,7 @@ def _preprocess_rules_generating(
                 left = rule.left_term
                 right0 = rule.right_terms[0]
                 right1 = rule.right_terms[1]
-                temp = (left, 2)
+                temp = [left, 2]
                 duplication_pointer.setdefault(right0, []).append(temp)
                 duplication_pointer.setdefault(right1, []).append(temp)
             if isinstance(rule, ProductionRule):
@@ -424,7 +424,7 @@ def _extract_fst_duplication_rules_intersection(
             for start_state in other.start_states:
                 new_rules.append(DuplicationRule(
                     "S",
-                    (start_state, "S", final_state),
+                    (start_state.value, "S", final_state.value),
                     "T"))
 
     def _extract_fst_epsilon_intersection(
@@ -434,7 +434,7 @@ def _extract_fst_epsilon_intersection(
                 -> None:
         for state in other.states:
             new_rules.append(EndRule(
-                (state, "epsilon", state),
+                (state.value, "epsilon", state.value),
                 "epsilon"))
 
     def _extract_fst_delta_intersection(
@@ -444,8 +444,8 @@ def _extract_fst_delta_intersection(
                 -> None:
         for (s_from, symb_from), (s_to, symb_to) in other:
             new_rules.append(EndRule(
-                (s_from, symb_from, s_to),
-                symb_to))
+                (s_from.value, symb_from.value, s_to.value),
+                tuple(map(lambda x: x.value, symb_to))))
 
     def _extract_epsilon_transitions_intersection(
             self,
@@ -456,9 +456,9 @@ def _extract_epsilon_transitions_intersection(
             for state_q in other.states:
                 for state_r in other.states:
                     new_rules.append(DuplicationRule(
-                        (state_p, "epsilon", state_q),
-                        (state_p, "epsilon", state_r),
-                        (state_r, "epsilon", state_q)))
+                        (state_p.value, "epsilon", state_q.value),
+                        (state_p.value, "epsilon", state_r.value),
+                        (state_r.value, "epsilon", state_q.value)))
 
     def _extract_indexed_grammar_rules_intersection(
             self,
@@ -471,22 +471,29 @@ def _extract_indexed_grammar_rules_intersection(
                     for state_q in other.states:
                         for state_r in other.states:
                             new_rules.append(DuplicationRule(
-                                (state_p, rule.left_term, state_q),
-                                (state_p, rule.right_terms[0], state_r),
-                                (state_r, rule.right_terms[1], state_q)))
+                                (state_p.value, rule.left_term.value,
+                                 state_q.value),
+                                (state_p.value, rule.right_terms[0].value,
+                                 state_r.value),
+                                (state_r.value, rule.right_terms[1].value,
+                                 state_q.value)))
             elif isinstance(rule, ProductionRule):
                 for state_p in other.states:
                     for state_q in other.states:
                         new_rules.append(ProductionRule(
-                            (state_p, rule.left_term, state_q),
-                            (state_p, rule.right_term, state_q),
-                            rule.production))
+                            (state_p.value, rule.left_term.value,
+                             state_q.value),
+                            (state_p.value, rule.right_term.value,
+                             state_q.value),
+                            rule.production.value))
             elif isinstance(rule, EndRule):
                 for state_p in other.states:
                     for state_q in other.states:
                         new_rules.append(DuplicationRule(
-                            (state_p, rule.left_term, state_q),
-                            (state_p, rule.right_term, state_q),
+                            (state_p.value, rule.left_term.value,
+                             state_q.value),
+                            (state_p.value, rule.right_term.value,
+                             state_q.value),
                             "T"))
 
     def _extract_terminals_intersection(
@@ -499,13 +506,13 @@ def _extract_terminals_intersection(
                 for state_q in other.states:
                     for state_r in other.states:
                         new_rules.append(DuplicationRule(
-                            (state_p, terminal, state_q),
-                            (state_p, "epsilon", state_r),
-                            (state_r, terminal, state_q)))
+                            (state_p.value, terminal.value, state_q.value),
+                            (state_p.value, "epsilon", state_r.value),
+                            (state_r.value, terminal.value, state_q.value)))
                         new_rules.append(DuplicationRule(
-                            (state_p, terminal, state_q),
-                            (state_p, terminal, state_r),
-                            (state_r, "epsilon", state_q)))
+                            (state_p.value, terminal.value, state_q.value),
+                            (state_p.value, terminal.value, state_r.value),
+                            (state_r.value, "epsilon", state_q.value)))
 
     def _extract_consumption_rules_intersection(
             self,
@@ -518,6 +525,8 @@ def _extract_consumption_rules_intersection(
                 for state_r in other.states:
                     for state_s in other.states:
                         new_rules.append(ConsumptionRule(
-                            consumption.f_parameter,
-                            (state_r, consumption.left_term, state_s),
-                            (state_r, consumption.right_term, state_s)))
+                            consumption.f_parameter.value,
+                            (state_r.value, consumption.left_term.value,
+                             state_s.value),
+                            (state_r.value, consumption.right_term.value,
+                             state_s.value)))

pyformlang/indexed_grammar/rules.py

@@ -123,8 +123,8 @@ def non_terminals(self) -> Set[Variable]:
             The non terminals used in the rule
         """
         non_terminals = set()
-        for temp_rule in self._consumption_rules.values():
-            for rule in temp_rule:
+        for rules in self._consumption_rules.values():
+            for rule in rules:
                 non_terminals.update(rule.non_terminals)
         for rule in self._rules:
             non_terminals.update(rule.non_terminals)

pyformlang/pda/transition_function.py

@@ -64,8 +64,7 @@ def remove_transition(self,
                           stack_to: Tuple[StackSymbol, ...]) -> None:
         """ Remove the given transition from the function """
         key = (s_from, input_symbol, stack_from)
-        if key in self._transitions:
-            self._transitions[key].discard((s_to, stack_to))
+        self._transitions.get(key, set()).discard((s_to, stack_to))
 
     def copy(self) -> "TransitionFunction":
         """ Copy the current transition function