add from_networkx abstract method to fa, use update instead of union in enfa

Author: bygu4

pyformlang/finite_automaton/deterministic_finite_automaton.py

@@ -368,7 +368,7 @@ def _from_epsilon_nfa_internal(cls, enfa: EpsilonNFA, eclose: bool) \
                 all_trans = [enfa(x, symbol) for x in current]
                 state = set()
                 for trans in all_trans:
-                    state = state.union(trans)
+                    state.update(trans)
                 if not state:
                     continue
                 # Eclose added

pyformlang/finite_automaton/epsilon_nfa.py

@@ -107,9 +107,7 @@ def _get_next_states_iterable(
         """
         next_states = set()
         for current_state in current_states:
-            next_states_temp = self._transition_function(current_state,
-                                                         symbol)
-            next_states = next_states.union(next_states_temp)
+            next_states.update(self(current_state, symbol))
         return next_states
 
     def accepts(self, word: Iterable[Hashable]) -> bool:
@@ -177,7 +175,7 @@ def eclose_iterable(self, states: Iterable[Hashable]) -> Set[State]:
         states = [to_state(x) for x in states]
         res = set()
         for state in states:
-            res = res.union(self.eclose(state))
+            res.update(self.eclose(state))
         return res
 
     def eclose(self, state: Hashable) -> Set[State]:
@@ -599,7 +597,7 @@ def __invert__(self) -> "EpsilonNFA":
         return self.reverse()
 
     def kleene_star(self) -> "EpsilonNFA":
-        """ Compute the kleene closure of current EpsilonNFA"""
+        """ Compute the kleene closure of current EpsilonNFA """
         new_start = self.__get_new_state("Start")
         kleene_closure = EpsilonNFA(start_states={new_start},
                                     final_states={new_start})

pyformlang/finite_automaton/finite_automaton.py

@@ -533,6 +533,16 @@ def to_networkx(self) -> MultiDiGraph:
             graph.add_edge(s_from.value, s_to.value, label=label_)
         return graph
 
+    @classmethod
+    @abstractmethod
+    def from_networkx(cls, graph: MultiDiGraph) -> "FiniteAutomaton":
+        """
+        Import a networkx graph into an finite state automaton. \
+        The imported graph requires to have the good format, i.e. to come \
+        from the function to_networkx
+        """
+        raise NotImplementedError
+
     def write_as_dot(self, filename: str) -> None:
         """
         Write the automaton in dot format into a file
@@ -573,8 +583,7 @@ def get_accepted_words(self, max_length: Optional[int] = None) \
             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)
+            transitions = self.get_transitions_from(current_state)
             for symbol, next_state in transitions:
                 if next_state in states_leading_to_final:
                     temp_word = current_word.copy()
@@ -593,7 +602,7 @@ def _get_states_leading_to_final(self) -> Set[State]:
         leading_to_final = self.final_states.copy()
         visited = set()
         states_to_process: deque[Any] = \
-            deque((None, start_state)  for start_state in self.start_states)
+            deque((None, start_state) for start_state in self.start_states)
         while states_to_process:
             previous_state, current_state = states_to_process.pop()
             if previous_state and current_state in leading_to_final:

pyformlang/finite_automaton/nondeterministic_finite_automaton.py

@@ -157,4 +157,4 @@ def from_epsilon_nfa(cls, enfa: EpsilonNFA) \
 
 class InvalidEpsilonTransition(Exception):
     """Exception raised when an epsilon transition is created in
-    nondeterministic automaton"""
+    non-epsilon NFA"""

pyformlang/regular_expression/regex.py

@@ -136,7 +136,7 @@ def get_number_operators(self) -> int:
             return 1 + sum(son.get_number_operators() for son in self.sons)
         return 0
 
-    def to_minimal_dfa(self) -> "DeterministicFiniteAutomaton":
+    def to_minimal_dfa(self) -> DeterministicFiniteAutomaton:
         """ Builds minimal dfa from current regex """
         enfa = self.to_epsilon_nfa()
         dfa = DeterministicFiniteAutomaton.from_epsilon_nfa(enfa)
@@ -164,13 +164,12 @@ def _to_epsilon_nfa_internal(self, copy: bool) -> EpsilonNFA:
         Transforms the regular expression into an epsilon NFA.
         Copy enfa in case of external usage.
         """
-        if self._enfa is not None:
-            return self._enfa.copy() if copy else self._enfa
-        self._enfa = EpsilonNFA()
-        s_initial = self._set_and_get_initial_state_in_enfa(self._enfa)
-        s_final = self._set_and_get_final_state_in_enfa(self._enfa)
-        self._process_to_enfa(self._enfa, s_initial, s_final)
-        return self._to_epsilon_nfa_internal(copy)
+        if self._enfa is None:
+            self._enfa = EpsilonNFA()
+            s_initial = self._set_and_get_initial_state_in_enfa(self._enfa)
+            s_final = self._set_and_get_final_state_in_enfa(self._enfa)
+            self._process_to_enfa(self._enfa, s_initial, s_final)
+        return self._enfa.copy() if copy else self._enfa
 
     def _set_and_get_final_state_in_enfa(self, enfa: EpsilonNFA) -> State:
         s_final = self._get_next_state_enfa()