add checks for any duplicates, add test for duplicate generation

Author: bygu4

pyformlang/finite_automaton/finite_automaton.py

@@ -602,29 +602,29 @@ def get_accepted_words(self, max_length: Optional[int] = None) \
         """
         if max_length is not None and max_length < 0:
             return []
-        states_to_visit = deque((start_state, start_state, [])
+        states_to_visit = deque((start_state, [])
                                 for start_state in self.start_states)
         states_leading_to_final = self._get_states_leading_to_final()
+        words_by_state = {state: set() for state in self.states}
+        yielded_words = set()
         while states_to_visit:
-            last_state_before_epsilon, current_state, current_word = \
-                states_to_visit.popleft()
+            current_state, current_word = states_to_visit.popleft()
             if max_length is not None and len(current_word) > max_length:
                 continue
+            word_to_add = tuple(current_word)
+            if not self.__try_add(words_by_state[current_state], word_to_add):
+                continue
             transitions = self._transition_function.get_transitions_from(
                 current_state)
             for symbol, next_state in transitions:
-                if symbol == Epsilon() \
-                        and next_state == last_state_before_epsilon:
-                    continue    # avoiding epsilon cycles
                 if next_state in states_leading_to_final:
-                    temp_state = last_state_before_epsilon
                     temp_word = current_word.copy()
                     if symbol != Epsilon():
-                        temp_state = next_state
                         temp_word.append(symbol)
-                    states_to_visit.append((temp_state, next_state, temp_word))
+                    states_to_visit.append((next_state, temp_word))
             if self.is_final_state(current_state):
-                yield current_word
+                if self.__try_add(yielded_words, word_to_add):
+                    yield current_word
 
     def _get_states_leading_to_final(self) -> Set[State]:
         """
@@ -713,6 +713,16 @@ def to_dict(self):
         """
         return self._transition_function.to_dict()
 
+    @staticmethod
+    def __try_add(set_to_add_to: Set[Any], element_to_add: Any) -> bool:
+        """
+        Tries to add a given element to the given set.
+        Returns True if element was added, otherwise False.
+        """
+        initial_length = len(set_to_add_to)
+        set_to_add_to.add(element_to_add)
+        return len(set_to_add_to) != initial_length
+
 
 def to_state(given: Any) -> Union[State, None]:
     """ Transforms the input into a state

pyformlang/finite_automaton/tests/test_deterministic_finite_automaton.py

@@ -288,6 +288,11 @@ def test_word_generation(self):
         assert [Symbol("b"), Symbol("d")] in accepted_words
         assert len(accepted_words) == 3
 
+    def test_dfa_generating_no_words(self):
+        dfa = get_dfa_example_without_accepted_words()
+        accepted_words = list(dfa.get_accepted_words())
+        assert not accepted_words
+
 
 def get_example0():
     """ Gives a dfa """
@@ -355,3 +360,18 @@ def get_dfa_example_for_word_generation():
     dfa.add_final_state(states[0])
     dfa.add_final_state(states[3])
     return dfa
+
+
+def get_dfa_example_without_accepted_words():
+    """ DFA example accepting no words """
+    dfa = DeterministicFiniteAutomaton()
+    states = [State(x) for x in range(4)]
+    symbol_a = Symbol("a")
+    symbol_b = Symbol("b")
+    dfa.add_transitions([
+        (states[0], symbol_a, states[1]),
+        (states[2], symbol_b, states[3]),
+    ])
+    dfa.add_start_state(states[0])
+    dfa.add_final_state(states[3])
+    return dfa

pyformlang/finite_automaton/tests/test_epsilon_nfa.py

@@ -661,7 +661,7 @@ def test_max_length_zero_accepting_empty_string(self):
     def test_max_length_zero_not_accepting_empty_string(self):
         enfa = get_cyclic_enfa_example()
         accepted_words = list(enfa.get_accepted_words(0))
-        assert accepted_words == []
+        assert not accepted_words
 
 
 def get_digits_enfa():

pyformlang/finite_automaton/tests/test_nondeterministic_finite_automaton.py

@@ -126,6 +126,13 @@ def test_word_generation(self):
         assert [Symbol("d"), Symbol("e"), Symbol("f")] in accepted_words
         assert len(accepted_words) == 5
 
+    def test_for_duplicate_generation(self):
+        nfa = get_nfa_example_with_duplicates()
+        accepted_words = list(nfa.get_accepted_words())
+        assert [Symbol("a"), Symbol("c")] in accepted_words
+        assert [Symbol("b"), Symbol("c")] in accepted_words
+        assert len(accepted_words) == 2
+
 
 def get_nfa_example_for_word_generation():
     """
@@ -158,3 +165,29 @@ def get_nfa_example_for_word_generation():
     nfa.add_final_state(states[6])
     nfa.add_final_state(states[8])
     return nfa
+
+
+def get_nfa_example_with_duplicates():
+    """ Gets NFA example with duplicate word chains """
+    nfa = NondeterministicFiniteAutomaton()
+    states = [State(x) for x in range(9)]
+    symbol_a = Symbol("a")
+    symbol_b = Symbol("b")
+    symbol_c = Symbol("c")
+    nfa.add_transitions([
+        (states[0], symbol_a, states[2]),
+        (states[1], symbol_a, states[2]),
+        (states[2], symbol_c, states[3]),
+        (states[2], symbol_c, states[4]),
+        (states[5], symbol_a, states[7]),
+        (states[6], symbol_b, states[7]),
+        (states[7], symbol_c, states[8]),
+    ])
+    nfa.add_start_state(states[0])
+    nfa.add_start_state(states[1])
+    nfa.add_start_state(states[5])
+    nfa.add_start_state(states[6])
+    nfa.add_final_state(states[3])
+    nfa.add_final_state(states[4])
+    nfa.add_final_state(states[8])
+    return nfa