reru 0.1.2__cp39-cp39-win_amd64.whl → 0.2.0__cp39-cp39-win_amd64.whl

reru/__init__.pyi

@@ -1,17 +1,138 @@
-from typing import Optional
+from typing import Optional, List, Union
+
+class SelectEngine:
+    Std: int
+    Fancy: int
 
 class Match:
-    def start(self) -> int: ...
-    def end(self) -> int: ...
-    def group(self, _i: int = 0) -> str: ...
+    """
+    Represents a successful regex match.
+    contains the original text and span indices for the match and capture groups.
+    """
+    def start(self) -> int:
+        """
+        Returns the starting index of the match.
+        """
+
+    def end(self) -> int:
+        """
+        Returns the ending index of the match.
+        """
+
+    def group(self, ident: Union[int, str] = 0) -> str:
+        """
+        Returns the substring matched by the given group.
+
+        Args:
+            ident: The group index (int) or group name (str). Defaults to 0 (the whole match).
+
+        Returns:
+            The matched string.
+
+        Raises:
+            ValueError: If the group index/name is invalid or not found.
+        """
+
+    def groups(self) -> List[Optional[str]]:
+        """
+        Returns a list of all capture groups (excluding the specific whole-match group 0).
+
+        Returns:
+            A list where each element is the string matched by the group, or None if the group did not participate.
+        """
+
+    def lastindex(self) -> int:
+        """
+        Returns the integer index of the last matched capturing group.
+        """
 
 class Pattern:
-    def is_match(self, text: str) -> bool: ...
-    def match(self, text: str) -> Optional[Match]: ...
-    def search(self, text: str) -> Optional[Match]: ...
+    """
+    A compiled regular expression object.
+    
+    This object holds a thread-safe reference to the underlying Rust Regex engine.
+    It automatically handles switching between the standard `regex` crate (O(n) time)
+    and `fancy-regex` (for look-arounds and back-references) based on the pattern.
+    """
+
+    def engine_info(self) -> str:
+        """
+        Returns the name of the underlying engine being used ('regex' or 'fancy_regex').
+        """
+
+    def group_names(self) -> List[str]:
+        """
+        Returns a list of named capture groups defined in the pattern.
+        """
+
+    def is_match(self, text: str) -> bool:
+        """
+        Checks if the pattern matches the string at the beginning.
+
+        This is faster than `match()` as it returns a boolean without allocating a Match object.
+
+        Returns:
+            True if the pattern matches at the start of `text`.
+        """
+    def is_search(self, text: str) -> bool:
+        """
+        Checks if the pattern matches anywhere in the string.
+
+        This is faster than `search()` as it returns a boolean without allocating a Match object.
+
+        Returns:
+            True if the pattern is found anywhere in `text`.
+        """
+
+    def match(self, text: str) -> Optional[Match]:
+        """
+        Attempts to match the pattern at the beginning of the string.
+
+        Returns:
+            A Match object if found, otherwise None.
+        """
+    def search(self, text: str) -> Optional[Match]:
+        """
+        Searches for the pattern anywhere in the string.
+
+        Returns:
+            A Match object if found, otherwise None.
+        """
+    def find(self, text: str) -> Optional[Match]:
+        """
+        Finds the first occurrence of the pattern in the string.
+
+        Returns:
+            A Match object if found, otherwise None.
+        """
+    def findall(self, text: str) -> List[str]:
+        """
+        Finds all non-overlapping occurrences of the pattern in the string.
+        """
+
+    def sub(self, repl: str, text: str) -> str:
+        """
+        Return the string obtained by replacing the leftmost non-overlapping occurrences
+        of the pattern in string by the replacement `repl`.
+
+        Args:
+            repl: The replacement string.
+            text: The input string to perform replacements on.
+        Returns:
+            The modified string with replacements.
+        """
+
+    @staticmethod
+    def escape(text: str) -> str:
+        """
+        Escape special characters in a string.
+        """
 
 
 class ReConfig:
+    """
+    Configuration options for compiling a regex pattern.
+    """
     case_insensitive: bool
     ignore_whitespace: bool
     multiline: bool
@@ -21,13 +142,129 @@ class ReConfig:
     backtrack_limit: Optional[int]
 
     def __init__(self, 
-        case_insensitive: bool, ignore_whitespace: bool, multiline: bool, unicode_mode: bool,
-        size_limit: Optional[int], dfa_size_limit: int, backtrack_limit: Optional[int]
-    ) -> None: ...
+        case_insensitive: bool = False,
+        ignore_whitespace: bool = False,
+        multiline: bool = False,
+        unicode_mode: bool = False,
+        size_limit: Optional[int] = None,
+        dfa_size_limit: int = 10_000_000,
+        backtrack_limit: Optional[int] = None
+    ) -> None:
+        """
+        Args:
+            case_insensitive: Enable case-insensitive matching.
+            ignore_whitespace: Allow whitespace and comments in pattern.
+            multiline: ^ and $ match start/end of line.
+            unicode_mode: Enable Unicode support.
+            size_limit: Limit the size of the compiled regex.
+            dfa_size_limit: Limit the size of the DFA graph (std engine only).
+            backtrack_limit: Limit the backtrack stack (fancy engine only).
+        """
+
+
+def compile(pattern: str, config: Optional[ReConfig] = None) -> Pattern:
+    """
+    Compile a regular expression pattern into a Pattern object.
+
+    This function utilizes a thread-safe cache. If the pattern (and config) 
+    has been seen before, a cached Pattern is returned immediately.
+
+    Args:
+        pattern: The regex string.
+        config: Optional configuration object.
+
+    Returns:
+        A compiled Pattern object.
+    """
+
+def compile_custom(
+    pattern: str, 
+    config: Optional[ReConfig] = None, 
+    select_engine: Optional[SelectEngine] = None
+) -> Pattern:
+    """
+    Compile a regex pattern, forcing a specific underlying engine.
+
+    Args:
+        pattern: The regex string.
+        config: Optional configuration.
+        select_engine: Force usage of 'Std' (Rust Regex) or 'Fancy' (FancyRegex).
+                       If None, auto-detection is used.
+    """
+
+def is_match(pattern: str, text: str, config: Optional[ReConfig] = None) -> bool:
+    """
+    Checks if the pattern matches the string at the beginning.
+
+    This is faster than `match()` as it returns a boolean without allocating a Match object.
+
+    Args:
+        pattern: The regex string.
+        text: The input string to match against.
+        config: Optional configuration.
+    Returns:
+        True if the pattern matches at the start of `text`.
+    """
+def is_search(pattern: str, text: str, config: Optional[ReConfig] = None) -> bool: 
+    """
+    Checks if the pattern matches anywhere in the string.
+
+    This is faster than `search()` as it returns a boolean without allocating a Match object.
+
+    Args:
+        pattern: The regex string.
+        text: The input string to match against.
+        config: Optional configuration.
+    Returns:
+        True if the pattern is found anywhere in `text`.
+    """
+
+def match(pattern: str, text: str, config: Optional[ReConfig] = None) -> Optional[Match]:
+    """
+    Attempts to match the pattern at the beginning of the string.
+
+    Args:
+        pattern: The regex string.
+        text: The input string to match against.
+        config: Optional configuration.
+    Returns:
+        A Match object if found, otherwise None.
+    """
+
+def search(pattern: str, text: str, config: Optional[ReConfig] = None) -> Optional[Match]:
+    """
+    Searches for the pattern anywhere in the string.
+
+    Args:
+        pattern: The regex string.
+        text: The input string to match against.
+        config: Optional configuration.
+    Returns:
+        A Match object if found, otherwise None.
+    """
+
+def sub(pattern: str, repl: str, text: str, config: Optional[ReConfig] = None) -> str:
+    """
+    Return the string obtained by replacing the leftmost non-overlapping occurrences
+    of the pattern in string by the replacement `repl`.
+
+    Args:
+        pattern: The regex string.
+        repl: The replacement string.
+        text: The input string to perform replacements on.
+        config: Optional configuration.
+    Returns:
+        The modified string with replacements.
+    """
+
+def escape(text: str) -> str:
+    """
+    Escape special characters in a string.
+    """
+
 
 
-class ReRu:
-    def compile(pattern: str, config: Optional[ReConfig] = None) -> Pattern: ...
-    def is_match(pattern: str, text: str, config: Optional[ReConfig] = None) -> bool: ...
-    def match(pattern: str, text: str, config: Optional[ReConfig] = None) -> Optional[Match]: ...
-    def search(pattern: str, text: str, config: Optional[ReConfig] = None) -> Optional[Match]: ...
+__version__: str
+__name__: str
+__package__: str
+__all__: List[str]

{reru-0.1.2.dist-info → reru-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reru
-Version: 0.1.2
+Version: 0.2.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
@@ -34,12 +34,12 @@ It combines the raw speed of Rust's linear-time regex engine with the flexibilit
 ## 🚀 Features
 
 * **Hybrid Engine Architecture**:
-* **Fast Path**: Uses the `regex` crate (linear time `O(n)`) for standard patterns, ensuring protection against ReDoS (Regular Expression Denial of Service).
-* **Feature Path**: Automatically switches to `fancy-regex` for patterns requiring look-arounds (`(?=...)`, `(?<=...)`) or backreferences (`\1`), maintaining compatibility with Python's standard regex features.
-
-
+    * **Fast Path**: Uses the `regex` crate (linear time `O(n)`) for standard patterns, ensuring protection against ReDoS (Regular Expression Denial of Service).
+    * **Feature Path**: Automatically switches to `fancy-regex` for patterns requiring look-arounds (`(?=...)`, `(?<=...)`) or backreferences (`\1`), maintaining compatibility with Python's standard regex features.
+* **Global Caching**: Compilations are cached efficiently using a thread-safe `DashMap`, making repeated calls lightning fast across threads.
 * **High Performance**: Implemented purely in Rust using `pyo3` and `maturin`.
-* **Built-in Caching**: Compilations are cached efficiently using a concurrent `DashMap` implementation, making repeated calls lightning fast.
+* **Rich API**: Supports standard methods like `match`, `search`, `findall`, and `sub`, plus named capture groups.
+* **Global Caching**: Compilations are cached efficiently using a thread-safe `DashMap`, making repeated calls lightning fast across threads.
 * **Type Safe**: Includes full type hints (`.pyi`) for better IDE integration and static analysis.
 * **Cross-Platform**: Pre-built wheels available for Linux (x86_64, aarch64, armv7, musl), macOS (Intel & Apple Silicon), and Windows (x64, x86, arm64).
 
@@ -54,64 +54,89 @@ pip install reru
 
 ## 🛠 Usage
 
-`reru` exposes a simple API similar to Python's standard `re` module but encapsulates methods within the `ReRu` class for optimized dispatch.
+`reru` exposes a simple API similar to Python's standard `re` module. Functions are available directly at the module level for optimized dispatch.
 
 ### Basic Matching and Searching
 
 ```python
-from reru import ReRu
+import reru
 
 # Check if a pattern matches (returns bool)
-if ReRu.is_match(r"\d+", "The answer is 42"):
+if reru.is_match(r"\d+", "The answer is 42"):
     print("It's a match!")
 
 # Search for a pattern (returns a Match object or None)
-match = ReRu.search(r"(\w+) world", "hello world")
+match = reru.search(r"(\w+) world", "hello world")
 if match:
     print(f"Full match: {match.group()}") # "hello world"
     print(f"Start index: {match.start()}") # 0
     print(f"End index: {match.end()}")     # 11
 
 # Optimized usage
-RE1 = ReRu.compile(r"\d+")
-RE1.is_match(r"\d+", "The answer is 42")
-RE2 = ReRu.compile(r"(\w+) world")
+RE1 = reru.compile(r"\d+")
+RE1.is_match("The answer is 42")
+RE2 = reru.compile(r"(\w+) world")
 RE2.search("hello world")
 ```
 
-### Advanced Configuration
+### Named Groups and New Methods
+`reru` now supports named capture groups, `findall`, and `sub` (substitution).
+
+
+
+```python
+import reru
+
+# Named Groups
+match = reru.match(r"(?P<year>\d{4})-(?P<month>\d{2})", "2024-05")
+if match:
+    print(match.group("year"))  # "2024"
+    print(match.group(1))       # "2024"
+
+# Find All Matches
+results = reru.findall(r"\d+", "Items: 10, 20, 30")
+print(results) # ['10', '20', '30']
 
+# Substitution
+text = reru.sub(r"ERROR", "CRITICAL", "System status: ERROR")
+print(text) # "System status: CRITICAL"
+```
+
+### Advanced Configuration
 You can fine-tune the regex engine using `ReConfig`. This allows you to control case sensitivity, multiline modes, whitespace ignoring, and execution limits.
 
+
 ```python
-from reru import ReRu, ReConfig
-
-# Configure the regex engine
-config = ReConfig(
-    case_insensitive=True,
-    ignore_whitespace=False,
-    multiline=True,
-    unicode_mode=True,
-    size_limit=10 * (1 << 20),  # 10 MB size limit
-    dfa_size_limit=2 * (1 << 20), # 2 MB DFA limit
-    backtrack_limit=1_000_000     # Limit for backtracking engine
-)
-
-# Perform search with config
-match = ReRu.search(r"ERROR", "Critical error occurred", config=config)
+import reru
+
+# Named Groups
+match = reru.match(r"(?P<year>\d{4})-(?P<month>\d{2})", "2024-05")
 if match:
-    print("Found error!")
+    print(match.group("year"))  # "2024"
+    print(match.group(1))       # "2024"
 
-# Or
-RE1 = ReRu.compile(r"ERROR", config=config)
-if RE1.match("Critical error occurred"):
-    print("Found error!")
+# Find All Matches
+results = reru.findall(r"\d+", "Items: 10, 20, 30")
+print(results) # ['10', '20', '30']
 
+# Substitution
+text = reru.sub(r"ERROR", "CRITICAL", "System status: ERROR")
+print(text) # "System status: CRITICAL"
 ```
 
+### Engine Selection (Advanced)
+If you need to force a specific engine (ignoring the auto-detection), you can use `compile_custom`:
+```
+from reru import SelectEngine, compile_custom
+
+# Force the Standard Rust engine (strictly linear time)
+pat = compile_custom(r"\d+", select_engine=SelectEngine.Std)
+```
+
+
 ## ⚙️ How It Works
 
-Under the hood, `reru` inspects the byte-code of your pattern before compilation:
+reru uses a "Try-Fail" fallback strategy to ensure the best balance between performance and compatibility:
 
 1. **Inspection**: It checks for "expensive" features like look-aheads, look-behinds, and backreferences.
 2. **Selection**:

reru-0.2.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+reru/__init__.py,sha256=NxObr2TsGAshHvjPqEyqs6h6lYecUR7X3iDcMJqOj2w,99
+reru/__init__.pyi,sha256=hkkLUlnsuaCN5D7owR0WVdgL7_GcOvJ9SBCViRh-zcs,8090
+reru/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+reru/reru.cp39-win_amd64.pyd,sha256=lx9s8VGUjXDHjPPycdrZPLvdc9Uj9UFq_w35XEhPPTY,1837056
+reru-0.2.0.dist-info/METADATA,sha256=Qyf_nxqc1UaZuxKg48hyeTr3v5QmAnfy3aBMylF2qQw,6301
+reru-0.2.0.dist-info/WHEEL,sha256=H5klTgXu3iVXpFbMzUkXja9m3gL244ExCR0k1sRMImo,95
+reru-0.2.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+reru-0.2.0.dist-info/RECORD,,

reru-0.1.2.dist-info/RECORD

@@ -1,8 +0,0 @@
-reru/__init__.py,sha256=NxObr2TsGAshHvjPqEyqs6h6lYecUR7X3iDcMJqOj2w,99
-reru/__init__.pyi,sha256=UEnyo7dVtdzEjcv-c7uYD99aWNwADA9E-qUuVyyJLzo,1134
-reru/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-reru/reru.cp39-win_amd64.pyd,sha256=tBZpD6960fV1SN8y_2fnVwtkyYp2TsUzTQil1UcyfK0,1762304
-reru-0.1.2.dist-info/METADATA,sha256=AB-anV1ip9bs6tfCHAQR1KPk5dsbpK0j70UrJ5Wn3Ww,5371
-reru-0.1.2.dist-info/WHEEL,sha256=H5klTgXu3iVXpFbMzUkXja9m3gL244ExCR0k1sRMImo,95
-reru-0.1.2.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-reru-0.1.2.dist-info/RECORD,,