Merge branch 'develop'

Author: caleb531

README.md

@@ -10,10 +10,13 @@
 [![Project Status: Active – The project has reached a stable, usable state and is being actively developed.](https://www.repostatus.org/badges/latest/active.svg)](https://www.repostatus.org/#active)
 ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/automata-lib)
 [![status](https://joss.theoj.org/papers/fe4d8521383598038e38bc0c948718af/status.svg)](https://joss.theoj.org/papers/fe4d8521383598038e38bc0c948718af)
+[![pyOpenSci](https://tinyurl.com/y22nb8up)](https://github.com/pyOpenSci/software-submission/issues/152)
 
-- **Documentation**: https://caleb531.github.io/automata/
-- **Migration Guide**: https://caleb531.github.io/automata/migration/
-- **API**: https://caleb531.github.io/automata/api/
+Links:
+- [**Documentation**](https://caleb531.github.io/automata/)
+- [**Examples**](https://caleb531.github.io/automata/examples/fa-examples/)
+- [**Migration Guide**](https://caleb531.github.io/automata/migration/)
+- [**API**](https://caleb531.github.io/automata/api/)
 
 Automata is a Python 3 library implementing structures and algorithms for manipulating finite automata,
 pushdown automata, and Turing machines. The algorithms have been optimized and are capable of
@@ -57,6 +60,9 @@ To install the optional visual dependencies, use the `visual` extra:
 pip install 'automata-lib[visual]'
 ```
 
+If you encounter errors building `pygraphviz`, you may need to install `graphviz`.
+See the instructions [here](https://graphviz.org/download/).
+
 ## Contributing
 
 Contributions are always welcome! Take a look at the [contributing guide](./CONTRIBUTING.md).

automata/fa/dfa.py

@@ -278,9 +278,8 @@ def to_partial(self, *, retain_names: bool = False, minify: bool = True) -> Self
         Self
             An equivalent partial DFA.
         """
-        if self.allow_partial:
-            return self.copy()
 
+        # Still want to try and remove dead states in the case of a partial DFA
         graph = self._get_digraph()
         live_states = get_reachable_nodes(graph, [self.initial_state])
         non_trap_states = get_reachable_nodes(graph, self.final_states, reversed=True)
@@ -338,7 +337,12 @@ def to_complete(self, trap_state: Optional[DFAStateT] = None) -> Self:
             An equivalent complete DFA.
 
         """
-        if not self.allow_partial:
+        is_partial = any(
+            len(lookup) != len(self.input_symbols)
+            for lookup in self.transitions.values()
+        )
+
+        if not is_partial:
             return self.copy()
 
         if trap_state is None:
@@ -624,7 +628,9 @@ def _minify(
                                 x for x in count(-1, -1) if x not in reachable_states
                             )
                             for trap_symbol in input_symbols:
-                                transition_back_map[trap_symbol][trap_state] = []
+                                transition_back_map[trap_symbol][trap_state] = [
+                                    trap_state
+                                ]
 
                             reachable_states.add(trap_state)
 
@@ -681,6 +687,11 @@ def _minify(
             if trap_state not in eq
         }
 
+        # If only one equivalence class with the trap state,
+        # return empty language.
+        if not back_map:
+            return cls.empty_language(input_symbols)
+
         new_input_symbols = input_symbols
         new_states = frozenset(back_map.values())
         new_initial_state = back_map[initial_state]
@@ -1276,6 +1287,8 @@ def predecessor(
         *,
         strict: bool = True,
         key: Optional[Callable[[Any], Any]] = None,
+        min_length: int = 0,
+        max_length: Optional[int] = None,
     ) -> Optional[str]:
         """
         Returns the first string accepted by the DFA that comes before
@@ -1291,6 +1304,10 @@ def predecessor(
         key : Optional[Callable], default: None
             Function for defining custom lexicographical ordering. Defaults to using
             the standard string ordering.
+        min_length : int, default: 0
+            Limits generation to words with at least the given length.
+        max_length : Optional[int], default: None
+            Limits generation to words with at most the given length.
 
         Returns
         ------
@@ -1303,7 +1320,13 @@ def predecessor(
             Raised if the language accepted by self is infinite, as we cannot
             generate predecessors in this case.
         """
-        for word in self.predecessors(input_str, strict=strict, key=key):
+        for word in self.predecessors(
+            input_str,
+            strict=strict,
+            key=key,
+            min_length=min_length,
+            max_length=max_length,
+        ):
             return word
         return None
 
@@ -1313,6 +1336,8 @@ def predecessors(
         *,
         strict: bool = True,
         key: Optional[Callable[[Any], Any]] = None,
+        min_length: int = 0,
+        max_length: Optional[int] = None,
     ) -> Generator[str, None, None]:
         """
         Generates all strings that come before the input string
@@ -1328,6 +1353,10 @@ def predecessors(
         key : Optional[Callable], default: None
             Function for defining custom lexicographical ordering. Defaults to using
             the standard string ordering.
+        min_length : int, default: 0
+            Limits generation to words with at least the given length.
+        max_length : Optional[int], default: None
+            Limits generation to words with at most the given length.
 
         Returns
         ------
@@ -1341,14 +1370,23 @@ def predecessors(
             Raised if the language accepted by self is infinite, as we cannot
             generate predecessors in this case.
         """
-        yield from self.successors(input_str, strict=strict, reverse=True, key=key)
+        yield from self.successors(
+            input_str,
+            strict=strict,
+            reverse=True,
+            key=key,
+            min_length=min_length,
+            max_length=max_length,
+        )
 
     def successor(
         self,
         input_str: Optional[str],
         *,
         strict: bool = True,
         key: Optional[Callable[[Any], Any]] = None,
+        min_length: int = 0,
+        max_length: Optional[int] = None,
     ) -> Optional[str]:
         """
         Returns the first string accepted by the DFA that comes after
@@ -1364,13 +1402,23 @@ def successor(
         key : Optional[Callable], default: None
             Function for defining custom lexicographical ordering. Defaults to using
             the standard string ordering.
+        min_length : int, default: 0
+            Limits generation to words with at least the given length.
+        max_length : Optional[int], default: None
+            Limits generation to words with at most the given length.
 
         Returns
         ------
         str
             The first string accepted by the DFA lexicographically before input_string.
         """
-        for word in self.successors(input_str, strict=strict, key=key):
+        for word in self.successors(
+            input_str,
+            strict=strict,
+            key=key,
+            min_length=min_length,
+            max_length=max_length,
+        ):
             return word
         return None
 
@@ -1381,6 +1429,8 @@ def successors(
         strict: bool = True,
         key: Optional[Callable[[Any], Any]] = None,
         reverse: bool = False,
+        min_length: int = 0,
+        max_length: Optional[int] = None,
     ) -> Generator[str, None, None]:
         """
         Generates all strings that come after the input string
@@ -1398,6 +1448,10 @@ def successors(
             the standard string ordering.
         reverse : bool, default: False
             If True, then predecessors will be generated instead of successors.
+        min_length : int, default: 0
+            Limits generation to words with at least the given length.
+        max_length : Optional[int], default: None
+            Limits generation to words with at most the given length.
 
         Returns
         ------
@@ -1446,6 +1500,8 @@ def successors(
             if (
                 not reverse
                 and should_yield
+                and min_length <= len(char_stack)
+                and (max_length is None or len(char_stack) <= max_length)
                 and candidate == first_symbol
                 and state in self.final_states
             ):
@@ -1456,7 +1512,9 @@ def successors(
                 else self._get_next_current_state(state, candidate)
             )
             # Traverse to child if candidate is viable
-            if candidate_state in coaccessible_nodes:
+            if candidate_state in coaccessible_nodes and (
+                max_length is None or len(char_stack) < max_length
+            ):
                 state_stack.append(candidate_state)
                 char_stack.append(cast(str, candidate))
                 candidate = first_symbol
@@ -1465,6 +1523,8 @@ def successors(
                 if (
                     reverse
                     and should_yield
+                    and min_length <= len(char_stack)
+                    and (max_length is None or len(char_stack) <= max_length)
                     and candidate is None
                     and state in self.final_states
                 ):
@@ -1480,6 +1540,8 @@ def successors(
         if (
             reverse
             and should_yield
+            and min_length <= len(char_stack)
+            and (max_length is None or len(char_stack) <= max_length)
             and candidate is None
             and state in self.final_states
         ):
@@ -1707,13 +1769,18 @@ def from_prefix(
 
         states = frozenset(transitions.keys())
         final_states = {last_state}
+
+        is_partial = any(
+            len(lookup) != len(input_symbols) for lookup in transitions.values()
+        )
+
         return cls(
             states=states,
             input_symbols=input_symbols,
             transitions=transitions,
             initial_state=0,
             final_states=final_states if contains else states - final_states,
-            allow_partial=as_partial,
+            allow_partial=is_partial,
         )
 
     @classmethod