correct generic type naming, simplify _to_epsilon_nfa_internal method

Author: bygu4

pyformlang/finite_automaton/deterministic_transition_function.py

@@ -2,8 +2,6 @@
 A deterministic transition function
 """
 
-# pylint: disable=function-redefined
-
 from typing import Optional
 
 from .state import State

pyformlang/finite_automaton/finite_automaton.py

@@ -1,7 +1,5 @@
 """ A general finite automaton representation """
 
-# pylint: disable=function-redefined
-
 from typing import Dict, List, Set, Tuple, \
     Iterable, Iterator, Optional, Hashable, Any, TypeVar
 from abc import abstractmethod
@@ -17,7 +15,7 @@
 from .transition_function import TransitionFunction
 from .utils import to_state, to_symbol
 
-fa_type = TypeVar("fa_type", bound="FiniteAutomaton")
+AutomatonT = TypeVar("AutomatonT", bound="FiniteAutomaton")
 
 
 class FiniteAutomaton(Iterable[Tuple[State, Symbol, State]]):
@@ -41,6 +39,7 @@ class FiniteAutomaton(Iterable[Tuple[State, Symbol, State]]):
         A set of final or accepting states. It is a subset of states.
     """
 
+    @abstractmethod
     def __init__(self) -> None:
         self._states: Set[State]
         self._input_symbols: Set[Symbol]
@@ -553,13 +552,18 @@ def write_as_dot(self, filename: str) -> None:
         """
         write_dot(self.to_networkx(), filename)
 
+    @abstractmethod
+    def accepts(self, word: Iterable[Hashable]) -> bool:
+        """ Checks whether the finite automaton accepts a given word """
+        raise NotImplementedError
+
     def get_accepted_words(self, max_length: Optional[int] = None) \
             -> Iterable[List[Symbol]]:
         """
         Gets words accepted by the finite automaton.
         """
         if max_length is not None and max_length < 0:
-            return []
+            return
         states_to_visit = deque((start_state, [])
                                 for start_state in self.start_states)
         states_leading_to_final = self._get_states_leading_to_final()
@@ -657,14 +661,14 @@ def to_dict(self) -> Dict[State, Dict[Symbol, Set[State]]]:
         return self._transition_function.to_dict()
 
     @abstractmethod
-    def copy(self: fa_type) -> fa_type:
+    def copy(self: AutomatonT) -> AutomatonT:
         """ Copies the current Finite Automaton instance """
         raise NotImplementedError
 
-    def __copy__(self: fa_type) -> fa_type:
+    def __copy__(self: AutomatonT) -> AutomatonT:
         return self.copy()
 
-    def _copy_to(self, fa_to_copy_to: fa_type) -> fa_type:
+    def _copy_to(self, fa_to_copy_to: AutomatonT) -> AutomatonT:
         """ Copies current automaton properties to the given one """
         for start in self._start_states:
             fa_to_copy_to.add_start_state(start)

pyformlang/finite_automaton/nondeterministic_transition_function.py

@@ -2,8 +2,6 @@
 A nondeterministic transition function
 """
 
-# pylint: disable=function-redefined
-
 from typing import Dict, Set, Iterable, Tuple
 from copy import deepcopy
 

pyformlang/finite_automaton/transition_function.py

@@ -2,8 +2,6 @@
 General transition function representation
 """
 
-# pylint: disable=function-redefined
-
 from typing import Dict, Set, Tuple, Iterable, Iterator
 from abc import abstractmethod
 

pyformlang/regular_expression/regex.py

@@ -88,8 +88,8 @@ class Regex(RegexReader):
     """
 
     def __init__(self, regex: str) -> None:
-        self.sons: List[Regex] = [] # type: ignore
         super().__init__(regex)
+        self.sons: List[Regex] # type: ignore
         self._counter = 0
         self._enfa: Optional[EpsilonNFA] = None
 
@@ -138,7 +138,7 @@ def get_number_operators(self) -> int:
 
     def to_minimal_dfa(self) -> DeterministicFiniteAutomaton:
         """ Builds minimal dfa from current regex """
-        enfa = self.to_epsilon_nfa()
+        enfa = self._to_epsilon_nfa_internal()
         dfa = DeterministicFiniteAutomaton.from_epsilon_nfa(enfa)
         return dfa.minimize()
 
@@ -157,19 +157,16 @@ def to_epsilon_nfa(self) -> EpsilonNFA:
         >>> regex.to_epsilon_nfa()
 
         """
-        return self._to_epsilon_nfa_internal(True)
+        return self._to_epsilon_nfa_internal().copy()
 
-    def _to_epsilon_nfa_internal(self, copy: bool) -> EpsilonNFA:
-        """
-        Transforms the regular expression into an epsilon NFA.
-        Copy enfa in case of external usage.
-        """
+    def _to_epsilon_nfa_internal(self) -> EpsilonNFA:
+        """ Transforms the regular expression into an epsilon NFA """
         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
+        return self._enfa
 
     def _set_and_get_final_state_in_enfa(self, enfa: EpsilonNFA) -> State:
         s_final = self._get_next_state_enfa()
@@ -567,8 +564,7 @@ def accepts(self, word: Iterable[str]) -> bool:
         True
 
         """
-        self._enfa = self._to_epsilon_nfa_internal(False)
-        return self._enfa.accepts(word)
+        return self._to_epsilon_nfa_internal().accepts(word)
 
     @classmethod
     def from_finite_automaton(cls, automaton: FiniteAutomaton) -> "Regex":