Refactor regex parsing to use Group class and update README for feature support

Author: Buba98

README.md

@@ -38,7 +38,10 @@ print(re.next()) # a2b
 
 ## What I plan to support
 
-- [ ] Lookahead and lookbehind
+I think those features would slow down the library too much and they are not widely used. If you have suggestions on how to implement them efficiently, please let me know.
+
+- [ ] Lookahead
+- [ ] Lookbehind
 
 ## What is not supported
 

regex_enumerator/regex_enumerator.py

@@ -1,5 +1,5 @@
 from .regex_parser import RegexParser
-from .regex_tree import RegexTree
+from .regex_tree import Group
 
 
 class RegexEnumerator:
@@ -20,7 +20,7 @@ def __init__(self, regex: str, additional_charset: str | list[str] = None) -> No
 
         charset = ''.join(sorted(set(default_charset + additional)))
         parser = RegexParser(regex, charset)
-        self.regexTree: RegexTree = parser.parse()
+        self.regexTree: Group = 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

@@ -1,4 +1,4 @@
-from .regex_tree import Alternative, BackReference, CharClass, RegexTree
+from .regex_tree import Alternative, BackReference, CharClass, Group
 
 
 class RegexError(Exception):
@@ -22,15 +22,15 @@ def __init__(self, regex: str, charset: str) -> None:
         self.regex = regex
         self.charset = charset
 
-    def parse(self) -> RegexTree:
+    def parse(self) -> Group:
         self.index = 0
-        return self._parseRegex(False)
+        return self._parseGroup(False)
 
-    def _parseRegex(self, to_close: bool) -> RegexTree:
+    def _parseGroup(self, to_close: bool) -> Group:
         alternatives: list[Alternative] = []
-        elements: list[CharClass | RegexTree | BackReference] = []
-        named_groups: dict[str, RegexTree] = {}
-        ordered_groups: list[RegexTree] = []
+        elements: list[CharClass | Group | BackReference] = []
+        named_groups: dict[str, Group] = {}
+        ordered_groups: list[Group] = []
         min_len_group, max_len_group = 1, 1
 
         while self.index < len(self.regex):
@@ -53,16 +53,16 @@ def _parseRegex(self, to_close: bool) -> RegexTree:
                             self.index += 1
                             if name in named_groups:
                                 self._raise_error("Duplicate named group")
-                            subTree = self._parseRegex(True)
+                            subTree = self._parseGroup(True)
                             named_groups[name] = subTree
                             ordered_groups.append(subTree)
                         elif self.regex[self.index] == ':':
                             self.index += 1
-                            subTree = self._parseRegex(True)
+                            subTree = self._parseGroup(True)
                         else:
                             self._raise_error("Invalid group")
                     else:
-                        subTree = self._parseRegex(True)
+                        subTree = self._parseGroup(True)
                         ordered_groups.append(subTree)
                     elements.append(subTree)
                 case ')':
@@ -115,7 +115,7 @@ def _parseRegex(self, to_close: bool) -> RegexTree:
             self._raise_error("Unmatched opening parenthesis")
 
         alternatives.append(Alternative(elements))
-        return RegexTree(alternatives, min_len_group, max_len_group)
+        return Group(alternatives, min_len_group, max_len_group)
 
     def _parseBackReferenceLookahead(self) -> str | int | None:
         if len(self.regex) <= self.index:

regex_enumerator/regex_tree.py

@@ -1,4 +1,4 @@
-class RegexTree:
+class Group:
     pass
 
 
@@ -46,11 +46,11 @@ def next(self) -> list[str]:
 
 
 class BackReference:
-    def __init__(self, reference: RegexTree, min_len: int, max_len: int | None):
+    def __init__(self, reference: Group, min_len: int, max_len: int | None):
         self._min_len = min_len
         self._max_len = max_len
         self._index = 0
-        self.reference: RegexTree = reference
+        self.reference: Group = reference
         self.done = max_len == 0 or (
             reference.done and len(reference.current) == 0)
         self.current = self._first()
@@ -91,7 +91,7 @@ def next(self) -> dict[str, list[str]]:
 
 
 class Alternative:
-    def __init__(self, elements: list[CharClass | RegexTree | BackReference]):
+    def __init__(self, elements: list[CharClass | Group | BackReference]):
         self._index = 0
         self._elements = [e for e in elements if not e.done or len(e.current)]
         self._noBackreference = not any(isinstance(
@@ -116,9 +116,9 @@ def next(self) -> set[str]:
                 index = 0
 
         self._index = index
-        result: list[tuple[str, dict[RegexTree, str]]] = []
+        result: list[tuple[str, dict[Group, str]]] = []
 
-        if isinstance(self._elements[0], RegexTree) and len(self._elements[0].references):
+        if isinstance(self._elements[0], Group) and len(self._elements[0].references):
             for string in self._elements[0].next() if index == 0 else self._elements[0].current:
                 result.append((string, {self._elements[0]: string}))
         else:
@@ -138,7 +138,7 @@ def next(self) -> set[str]:
                     for sfx in element.current[reference]:
                         temp.append(
                             (pfx[0] + sfx, pfx[1]))
-            elif isinstance(element, RegexTree) and len(element.references):
+            elif isinstance(element, Group) and len(element.references):
                 for sfx in element.next() if i == index else element.current:
                     for pfx in result:
                         temp.append((pfx[0] + sfx, {**pfx[1], element: sfx}))
@@ -202,9 +202,9 @@ def _first(self) -> set[str]:
 
         assert not isinstance(self._elements[0], BackReference)
 
-        result: list[tuple[str, dict[RegexTree, str]]] = []
+        result: list[tuple[str, dict[Group, str]]] = []
 
-        if isinstance(self._elements[0], RegexTree) and len(self._elements[0].references):
+        if isinstance(self._elements[0], Group) and len(self._elements[0].references):
             for char in self._elements[0].current:
                 result.append((char, {self._elements[0]: char}))
         else:
@@ -214,7 +214,7 @@ def _first(self) -> set[str]:
         done = self._elements[0].done
 
         for element in self._elements[1:]:
-            temp: list[tuple[str, dict[RegexTree, str]]] = []
+            temp: list[tuple[str, dict[Group, str]]] = []
             done = done and element.done
             if isinstance(element, BackReference):
                 for pfx in result:
@@ -223,7 +223,7 @@ def _first(self) -> set[str]:
                     for sfx in element.current[reference]:
                         temp.append(
                             (pfx[0] + sfx, pfx[1]))
-            elif isinstance(element, RegexTree) and len(element.references):
+            elif isinstance(element, Group) and len(element.references):
                 for pfx in result:
                     for sfx in element.current:
                         temp.append((pfx[0] + sfx, {**pfx[1], element: sfx}))
@@ -238,7 +238,7 @@ def _first(self) -> set[str]:
         return {struct[0] for struct in result}
 
 
-class RegexTree:
+class Group:
     def __init__(self, alternatives: list[Alternative], min_len: int, max_len: int | None):
         self.references: list[BackReference] = []
         self._alternatives: list[Alternative] = alternatives

setup.py

@@ -5,7 +5,7 @@
 
 setup(
     name='regex_enumerator',
-    version='0.10.1',
+    version='1.0.0',
     packages=find_packages(include=['regex_enumerator', 'regex_enumerator.*']),
     description='Enumerate all strings that match a given regex',
     author='Vincenzo Greco',