Bump version to 0.10.0; remove precompute option from RegexEnumerator and RegexParser; add tests for empty character class and group with alternative; optimized generation

Author: Buba98

README.md

@@ -75,16 +75,6 @@ assert '¢' in result
 assert '£' in result
 ```
 
-## Precomputation
-
-For optimization purposes, the library precomputes the strings of the elements in the regex pattern when those does not repeat indefinitely. To disable this feature, in order to reduce the time of the first call to `next()`, set `precompute=False` when creating the `RegexEnumerator`.
-
-```python
-from regex_enumerator import RegexEnumerator
-
-re = RegexEnumerator(r'a[0-9]b', precompute=False)
-```
-
 ## How it works
 
 This library works by parsing the regex pattern into a tree structure. Once parsed, it performs a breadth-first search (BFS) on the tree to generate all matching strings. This ensures it does not get stuck on unbounded quantifiers for character classes or groups.

regex_enumerator/regex_enumerator.py

@@ -3,7 +3,7 @@
 
 
 class RegexEnumerator:
-    def __init__(self, regex: str, additional_charset: str | list[str] = None, precompute: bool = True) -> None:
+    def __init__(self, regex: str, additional_charset: str | list[str] = None) -> None:
         default_charset = [chr(c) for c in range(32, 127)]
 
         if additional_charset is None:
@@ -14,7 +14,7 @@ def __init__(self, regex: str, additional_charset: str | list[str] = None, preco
             additional = list(additional_charset)
 
         charset = ''.join(sorted(set(default_charset + additional)))
-        parser = RegexParser(regex, charset, precompute)
+        parser = RegexParser(regex, charset)
         self.regexTree: RegexTree = parser.parse()
         self.current: list[str] = list(self.regexTree.current)
         self.done: bool = self.regexTree.done and len(self.current) == 0

regex_enumerator/regex_parser.py

@@ -18,10 +18,9 @@ class RegexParser:
     DIGITS = '0123456789'
     SPACES = ' \t\n\r\f\v'
 
-    def __init__(self, regex: str, charset: str, precompute: bool):
+    def __init__(self, regex: str, charset: str) -> None:
         self.regex = regex
         self.charset = charset
-        self.precompute = precompute
 
     def parse(self) -> RegexTree:
         self.index = 0
@@ -81,19 +80,19 @@ def _parseRegex(self, to_close: bool) -> RegexTree:
                     chars = self._parseCharClass()
                     min_len, max_len = self._parseQuantifier()
                     elements.append(
-                        CharClass(chars, min_len, max_len, self.precompute))
+                        CharClass(chars, min_len, max_len))
                 case '.':
                     chars = list(self.charset)
                     min_len, max_len = self._parseQuantifier()
                     elements.append(
-                        CharClass(chars, min_len, max_len, self.precompute))
+                        CharClass(chars, min_len, max_len))
                 case '\\':
                     reference = self._parseBackReferenceLookahead()
                     if reference is None:
                         chars = self._parseEscapeChar()
                         min_len, max_len = self._parseQuantifier()
                         elements.append(
-                            CharClass([chars], min_len, max_len, self.precompute))
+                            CharClass([chars], min_len, max_len))
                         continue
                     if isinstance(reference, str):
                         if reference not in named_groups:
@@ -105,20 +104,19 @@ def _parseRegex(self, to_close: bool) -> RegexTree:
                                 "Positional back reference not found")
                         group = ordered_groups[reference - 1]
                     min_len, max_len = self._parseQuantifier()
-                    reference = BackReference(
-                        group, min_len, max_len, self.precompute)
+                    reference = BackReference(group, min_len, max_len)
                     group.add_reference(reference)
                     elements.append(reference)
                 case _:
                     min_len, max_len = self._parseQuantifier()
                     elements.append(
-                        CharClass([char], min_len, max_len, self.precompute))
+                        CharClass([char], min_len, max_len))
 
         if to_close:
             self._raise_error("Unmatched opening parenthesis")
 
         alternatives.append(Alternative(elements))
-        return RegexTree(alternatives, min_len_group, max_len_group, self.precompute)
+        return RegexTree(alternatives, min_len_group, max_len_group)
 
     def _parseBackReferenceLookahead(self) -> str | int | None:
         if len(self.regex) <= self.index: