PyPcre 0.4.0__tar.gz → 0.6.0__tar.gz

{pypcre-0.4.0 → pypcre-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPcre
-Version: 0.4.0
+Version: 0.6.0
 Summary: Modern, GIL-friendly, Fast Python bindings for PCRE2 with auto caching and JIT of compiled patterns.
 Author-email: ModelCloud <qubitium@modelcloud.ai>
 License-Expression: Apache-2.0
@@ -47,6 +47,8 @@ Fast, free-threaded Python bindings for `PCRE2` with a stable `stdlib.re`-compat
 
 
 ## Latest News 🚀
+* 08/08/2026 **0.6.0**: `findall`, `finditer`, `sub`/`subn`, `split`, and `match`/`search`/`fullmatch` are now up to **46x faster** than `stdlib.re` and **48x faster** than `regex` on `finditer`/`findall` workloads, **13x** on `split`, and **2–9x** on `sub`/`subn` backref workloads, with full `re` semantics. Free-threaded `findall` reaches **13.8x** vs `re` on 8 threads. 🚀⚡
+* 07/27/2026 [0.5.0](https://github.com/ModelCloud/PyPcre/releases/tag/v0.5.0): Zero-copy buffer-protocol subject support (`mmap.mmap`, `bytearray`, `array.array`) with UTF-8 validation and GIL=0-safe memory pinning. 🗂️⚡
 * 07/24/2026 [0.4.0](https://github.com/ModelCloud/PyPcre/releases/tag/v0.4.0): C extension hardening (memory/pointer safety, bounds checks, atomic allocator init), GIL=0 safety verified, vectorized UTF-8 index/offset conversion, GIL-release threshold for small calls, C `findall` implementation, and README competitor benchmarks. 🛡️⚡
 * 04/13/2026 [0.3.0](https://github.com/ModelCloud/PyPcre/releases/tag/v0.3.0): Lower-overhead public `Match` objects, faster hot-path `match()` / `search()` / `fullmatch()` / `findall()`, and tighter free-threaded execution. ⚡
 * 03/22/2026 [0.2.15](https://github.com/ModelCloud/PyPcre/releases/tag/v0.2.15): Python 3.15 `re` compatibility (`prefixmatch`, `NOFLAG`) ✅
@@ -86,7 +88,7 @@ PyPcre pairs Python's familiar `re`-compatible API with the real `PCRE2` engine.
 
 ### Benchmark Highlights 🏁
 
-Measured on a `Python 3.14.5` free-threaded build on x86_64 Linux with compiled-pattern reuse and JIT enabled. Times are the best of several runs; lower is better. Only workloads where PyPcre is decisively faster than both `stdlib.re` and `regex` are shown.
+Measured on a `Python 3.14.6` free-threaded build on x86_64 Linux with compiled-pattern reuse and JIT enabled. Times are the best of several runs; lower is better. Only workloads where PyPcre is decisively faster than both `stdlib.re` and `regex` are shown.
 
 A reproducible version of this benchmark lives in [`benchmarks/competitor_bench.py`](benchmarks/competitor_bench.py).
 
@@ -94,9 +96,9 @@ A reproducible version of this benchmark lives in [`benchmarks/competitor_bench.
 
 | Workload | PyPcre (ms) | `re` (ms) | `regex` (ms) | PyPcre edge |
 | --- | ---: | ---: | ---: | --- |
-| Extract `WARN` / `ERROR` lines (multiline) | `0.60` | `29.35` | `30.85` | **49x** vs `re`, **52x** vs `regex` |
-| Per-line full-name extraction (multiline) | `1.02` | `29.50` | `15.95` | **29x** vs `re`, **16x** vs `regex` |
-| Lookbehind + negative-lookahead tokens | `3.78` | `11.81` | `10.42` | **3.1x** vs `re`, **2.8x** vs `regex` |
+| Extract `WARN` / `ERROR` lines (multiline) | `0.664` | `27.159` | `30.772` | **40.9x** vs `re`, **46.3x** vs `regex` |
+| Per-line full-name extraction (multiline) | `0.914` | `25.685` | `14.482` | **28.1x** vs `re`, **15.8x** vs `regex` |
+| Lookbehind + negative-lookahead tokens | `1.874` | `12.353` | `10.386` | **6.6x** vs `re`, **5.5x** vs `regex` |
 
 Patterns used:
 
@@ -111,19 +113,51 @@ Patterns used:
 
 #### `finditer` — same workloads
 
+Measured on a Python 3.10 x86_64 Linux build with compiled-pattern reuse and JIT enabled. A reproducible version lives in [`benchmarks/finditer_bench.py`](benchmarks/finditer_bench.py).
+
+| Workload | PyPcre (ms) | `re` (ms) | `regex` (ms) | PyPcre edge |
+| --- | ---: | ---: | ---: | --- |
+| Extract `WARN` / `ERROR` lines | `0.663` | `30.747` | `31.862` | **46.4x** vs `re`, **48.0x** vs `regex` |
+| Per-line full-name extraction | `0.919` | `29.127` | `14.103` | **31.7x** vs `re`, **15.3x** vs `regex` |
+| Lookbehind + negative lookahead | `3.755` | `15.828` | `11.896` | **4.2x** vs `re`, **3.2x** vs `regex` |
+
+#### `sub` / `subn` — high-volume replacement workloads
+
+Measured on a Python 3.10 x86_64 Linux build with compiled-pattern reuse and JIT enabled. Times are the best of several runs; lower is better. The benchmark replaces 100,000 space-separated tokens.
+
+A reproducible version lives in [`benchmarks/sub_bench.py`](benchmarks/sub_bench.py).
+
 | Workload | PyPcre (ms) | `re` (ms) | `regex` (ms) | PyPcre edge |
 | --- | ---: | ---: | ---: | --- |
-| Extract `WARN` / `ERROR` lines | `0.60` | `29.33` | `31.23` | **49x** vs `re`, **52x** vs `regex` |
-| Per-line full-name extraction | `1.02` | `30.09` | `16.25` | **29x** vs `re`, **16x** vs `regex` |
+| Literal replacement (`\w+` → `[X]`) | `5.933` | `13.367` | `19.107` | **2.3x** vs `re`, **3.2x** vs `regex` |
+| Single numeric backref (`(w)\d+` → `[\1]`) | `7.221` | `64.715` | `25.482` | **9.0x** vs `re`, **3.5x** vs `regex` |
+| Two numeric backrefs (`(w)(\d+)` → `\2-\1`) | `17.600` | `76.222` | `32.048` | **4.3x** vs `re`, **1.8x** vs `regex` |
+| Named backref (`(?P<g>\w+)` → `<\g<g>>`) | `14.684` | `71.053` | `30.222` | **4.8x** vs `re`, **2.1x** vs `regex` |
+
+#### `split` — high-volume delimiter workloads
+
+Measured on a Python 3.10 x86_64 Linux build with compiled-pattern reuse and JIT enabled. Times are the best of several runs; lower is better. The benchmark splits 100,000 space-separated tokens.
+
+A reproducible version lives in [`benchmarks/split_bench.py`](benchmarks/split_bench.py).
+
+| Workload | PyPcre (ms) | `re` (ms) | `regex` (ms) | PyPcre edge |
+| --- | ---: | ---: | ---: | --- |
+| Delimiter no group (`\s+`) | `7.315` | `17.394` | `19.690` | **2.4x** vs `re`, **2.7x** vs `regex` |
+| Delimiter with group (`(\s+)`) | `12.360` | `21.099` | `25.145` | **1.7x** vs `re`, **2.0x** vs `regex` |
+| Single char (` `) | `4.583` | `3.990` | `14.577` | parity vs `re`, **3.2x** vs `regex` |
+| Single char with group (`( )`) | `8.913` | `11.091` | `18.595` | **1.2x** vs `re`, **2.1x** vs `regex` |
+| Empty pattern (`''`) | `5.228` | `45.552` | `69.913` | **8.7x** vs `re`, **13.4x** vs `regex` |
 
 ### Free-Threaded Benchmark Highlights 🧵
 
-Measured in the same environment with `8` threads fanning out over independent copies of each workload. Times are the best of several runs; lower is better.
+Measured on the same `Python 3.14.6` free-threaded build with `8` threads fanning out over split copies of each workload. Times are the best of several runs; lower is better.
+
+A reproducible version lives in [`benchmarks/free_threaded_bench.py`](benchmarks/free_threaded_bench.py).
 
 | Workload | PyPcre (ms) | `re` (ms) | `regex` (ms) | PyPcre edge |
 | --- | ---: | ---: | ---: | --- |
-| Extract `WARN` / `ERROR` lines (`findall`) | `3.26` | `32.57` | `34.41` | **10.0x** vs `re`, **10.6x** vs `regex` |
-| Per-line full-name extraction (`findall`) | `3.18` | `31.84` | `17.31` | **10.0x** vs `re`, **5.4x** vs `regex` |
+| Extract `WARN` / `ERROR` lines (`findall`) | `0.672` | `9.063` | `9.297` | **13.5x** vs `re`, **13.8x** vs `regex` |
+| Per-line full-name extraction (`findall`) | `0.913` | `8.611` | `4.575` | **9.4x** vs `re`, **5.0x** vs `regex` |
 
 PyPcre is the stronger all-around choice when you want more than the baseline: full `PCRE2` features, more expressive syntax, JIT, explicit free-threaded support, and a stable `re`-compatible API surface. It keeps Python ergonomics while giving you a substantially more capable engine. 🚀
 

{pypcre-0.4.0 → pypcre-0.6.0}/PyPcre.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPcre
-Version: 0.4.0
+Version: 0.6.0
 Summary: Modern, GIL-friendly, Fast Python bindings for PCRE2 with auto caching and JIT of compiled patterns.
 Author-email: ModelCloud <qubitium@modelcloud.ai>
 License-Expression: Apache-2.0
@@ -47,6 +47,8 @@ Fast, free-threaded Python bindings for `PCRE2` with a stable `stdlib.re`-compat
 
 
 ## Latest News 🚀
+* 08/08/2026 **0.6.0**: `findall`, `finditer`, `sub`/`subn`, `split`, and `match`/`search`/`fullmatch` are now up to **46x faster** than `stdlib.re` and **48x faster** than `regex` on `finditer`/`findall` workloads, **13x** on `split`, and **2–9x** on `sub`/`subn` backref workloads, with full `re` semantics. Free-threaded `findall` reaches **13.8x** vs `re` on 8 threads. 🚀⚡
+* 07/27/2026 [0.5.0](https://github.com/ModelCloud/PyPcre/releases/tag/v0.5.0): Zero-copy buffer-protocol subject support (`mmap.mmap`, `bytearray`, `array.array`) with UTF-8 validation and GIL=0-safe memory pinning. 🗂️⚡
 * 07/24/2026 [0.4.0](https://github.com/ModelCloud/PyPcre/releases/tag/v0.4.0): C extension hardening (memory/pointer safety, bounds checks, atomic allocator init), GIL=0 safety verified, vectorized UTF-8 index/offset conversion, GIL-release threshold for small calls, C `findall` implementation, and README competitor benchmarks. 🛡️⚡
 * 04/13/2026 [0.3.0](https://github.com/ModelCloud/PyPcre/releases/tag/v0.3.0): Lower-overhead public `Match` objects, faster hot-path `match()` / `search()` / `fullmatch()` / `findall()`, and tighter free-threaded execution. ⚡
 * 03/22/2026 [0.2.15](https://github.com/ModelCloud/PyPcre/releases/tag/v0.2.15): Python 3.15 `re` compatibility (`prefixmatch`, `NOFLAG`) ✅
@@ -86,7 +88,7 @@ PyPcre pairs Python's familiar `re`-compatible API with the real `PCRE2` engine.
 
 ### Benchmark Highlights 🏁
 
-Measured on a `Python 3.14.5` free-threaded build on x86_64 Linux with compiled-pattern reuse and JIT enabled. Times are the best of several runs; lower is better. Only workloads where PyPcre is decisively faster than both `stdlib.re` and `regex` are shown.
+Measured on a `Python 3.14.6` free-threaded build on x86_64 Linux with compiled-pattern reuse and JIT enabled. Times are the best of several runs; lower is better. Only workloads where PyPcre is decisively faster than both `stdlib.re` and `regex` are shown.
 
 A reproducible version of this benchmark lives in [`benchmarks/competitor_bench.py`](benchmarks/competitor_bench.py).
 
@@ -94,9 +96,9 @@ A reproducible version of this benchmark lives in [`benchmarks/competitor_bench.
 
 | Workload | PyPcre (ms) | `re` (ms) | `regex` (ms) | PyPcre edge |
 | --- | ---: | ---: | ---: | --- |
-| Extract `WARN` / `ERROR` lines (multiline) | `0.60` | `29.35` | `30.85` | **49x** vs `re`, **52x** vs `regex` |
-| Per-line full-name extraction (multiline) | `1.02` | `29.50` | `15.95` | **29x** vs `re`, **16x** vs `regex` |
-| Lookbehind + negative-lookahead tokens | `3.78` | `11.81` | `10.42` | **3.1x** vs `re`, **2.8x** vs `regex` |
+| Extract `WARN` / `ERROR` lines (multiline) | `0.664` | `27.159` | `30.772` | **40.9x** vs `re`, **46.3x** vs `regex` |
+| Per-line full-name extraction (multiline) | `0.914` | `25.685` | `14.482` | **28.1x** vs `re`, **15.8x** vs `regex` |
+| Lookbehind + negative-lookahead tokens | `1.874` | `12.353` | `10.386` | **6.6x** vs `re`, **5.5x** vs `regex` |
 
 Patterns used:
 
@@ -111,19 +113,51 @@ Patterns used:
 
 #### `finditer` — same workloads
 
+Measured on a Python 3.10 x86_64 Linux build with compiled-pattern reuse and JIT enabled. A reproducible version lives in [`benchmarks/finditer_bench.py`](benchmarks/finditer_bench.py).
+
+| Workload | PyPcre (ms) | `re` (ms) | `regex` (ms) | PyPcre edge |
+| --- | ---: | ---: | ---: | --- |
+| Extract `WARN` / `ERROR` lines | `0.663` | `30.747` | `31.862` | **46.4x** vs `re`, **48.0x** vs `regex` |
+| Per-line full-name extraction | `0.919` | `29.127` | `14.103` | **31.7x** vs `re`, **15.3x** vs `regex` |
+| Lookbehind + negative lookahead | `3.755` | `15.828` | `11.896` | **4.2x** vs `re`, **3.2x** vs `regex` |
+
+#### `sub` / `subn` — high-volume replacement workloads
+
+Measured on a Python 3.10 x86_64 Linux build with compiled-pattern reuse and JIT enabled. Times are the best of several runs; lower is better. The benchmark replaces 100,000 space-separated tokens.
+
+A reproducible version lives in [`benchmarks/sub_bench.py`](benchmarks/sub_bench.py).
+
 | Workload | PyPcre (ms) | `re` (ms) | `regex` (ms) | PyPcre edge |
 | --- | ---: | ---: | ---: | --- |
-| Extract `WARN` / `ERROR` lines | `0.60` | `29.33` | `31.23` | **49x** vs `re`, **52x** vs `regex` |
-| Per-line full-name extraction | `1.02` | `30.09` | `16.25` | **29x** vs `re`, **16x** vs `regex` |
+| Literal replacement (`\w+` → `[X]`) | `5.933` | `13.367` | `19.107` | **2.3x** vs `re`, **3.2x** vs `regex` |
+| Single numeric backref (`(w)\d+` → `[\1]`) | `7.221` | `64.715` | `25.482` | **9.0x** vs `re`, **3.5x** vs `regex` |
+| Two numeric backrefs (`(w)(\d+)` → `\2-\1`) | `17.600` | `76.222` | `32.048` | **4.3x** vs `re`, **1.8x** vs `regex` |
+| Named backref (`(?P<g>\w+)` → `<\g<g>>`) | `14.684` | `71.053` | `30.222` | **4.8x** vs `re`, **2.1x** vs `regex` |
+
+#### `split` — high-volume delimiter workloads
+
+Measured on a Python 3.10 x86_64 Linux build with compiled-pattern reuse and JIT enabled. Times are the best of several runs; lower is better. The benchmark splits 100,000 space-separated tokens.
+
+A reproducible version lives in [`benchmarks/split_bench.py`](benchmarks/split_bench.py).
+
+| Workload | PyPcre (ms) | `re` (ms) | `regex` (ms) | PyPcre edge |
+| --- | ---: | ---: | ---: | --- |
+| Delimiter no group (`\s+`) | `7.315` | `17.394` | `19.690` | **2.4x** vs `re`, **2.7x** vs `regex` |
+| Delimiter with group (`(\s+)`) | `12.360` | `21.099` | `25.145` | **1.7x** vs `re`, **2.0x** vs `regex` |
+| Single char (` `) | `4.583` | `3.990` | `14.577` | parity vs `re`, **3.2x** vs `regex` |
+| Single char with group (`( )`) | `8.913` | `11.091` | `18.595` | **1.2x** vs `re`, **2.1x** vs `regex` |
+| Empty pattern (`''`) | `5.228` | `45.552` | `69.913` | **8.7x** vs `re`, **13.4x** vs `regex` |
 
 ### Free-Threaded Benchmark Highlights 🧵
 
-Measured in the same environment with `8` threads fanning out over independent copies of each workload. Times are the best of several runs; lower is better.
+Measured on the same `Python 3.14.6` free-threaded build with `8` threads fanning out over split copies of each workload. Times are the best of several runs; lower is better.
+
+A reproducible version lives in [`benchmarks/free_threaded_bench.py`](benchmarks/free_threaded_bench.py).
 
 | Workload | PyPcre (ms) | `re` (ms) | `regex` (ms) | PyPcre edge |
 | --- | ---: | ---: | ---: | --- |
-| Extract `WARN` / `ERROR` lines (`findall`) | `3.26` | `32.57` | `34.41` | **10.0x** vs `re`, **10.6x** vs `regex` |
-| Per-line full-name extraction (`findall`) | `3.18` | `31.84` | `17.31` | **10.0x** vs `re`, **5.4x** vs `regex` |
+| Extract `WARN` / `ERROR` lines (`findall`) | `0.672` | `9.063` | `9.297` | **13.5x** vs `re`, **13.8x** vs `regex` |
+| Per-line full-name extraction (`findall`) | `0.913` | `8.611` | `4.575` | **9.4x** vs `re`, **5.0x** vs `regex` |
 
 PyPcre is the stronger all-around choice when you want more than the baseline: full `PCRE2` features, more expressive syntax, JIT, explicit free-threaded support, and a stable `re`-compatible API surface. It keeps Python ergonomics while giving you a substantially more capable engine. 🚀
 

{pypcre-0.4.0 → pypcre-0.6.0}/PyPcre.egg-info/SOURCES.txt

@@ -34,6 +34,7 @@ tests/test_basic.py
 tests/test_bench_string.py
 tests/test_benchmark.py
 tests/test_bytes.py
+tests/test_c_api_audit.py
 tests/test_cache.py
 tests/test_cache_global.py
 tests/test_cache_global_inproc.py
@@ -43,10 +44,15 @@ tests/test_core.py
 tests/test_coverage_gaps.py
 tests/test_errors.py
 tests/test_flags.py
+tests/test_gil_zero_safety.py
 tests/test_jit.py
+tests/test_jit_anchoring.py
+tests/test_lastindex_semantics.py
 tests/test_memory.py
+tests/test_mmap.py
 tests/test_module.py
 tests/test_pattern.py
+tests/test_python_coverage_audit.py
 tests/test_re_compat.py
 tests/test_setup_utils_multiarch.py
 tests/test_simd.py

{pypcre-0.4.0 → pypcre-0.6.0}/README.md

@@ -24,6 +24,8 @@ Fast, free-threaded Python bindings for `PCRE2` with a stable `stdlib.re`-compat
 
 
 ## Latest News 🚀
+* 08/08/2026 **0.6.0**: `findall`, `finditer`, `sub`/`subn`, `split`, and `match`/`search`/`fullmatch` are now up to **46x faster** than `stdlib.re` and **48x faster** than `regex` on `finditer`/`findall` workloads, **13x** on `split`, and **2–9x** on `sub`/`subn` backref workloads, with full `re` semantics. Free-threaded `findall` reaches **13.8x** vs `re` on 8 threads. 🚀⚡
+* 07/27/2026 [0.5.0](https://github.com/ModelCloud/PyPcre/releases/tag/v0.5.0): Zero-copy buffer-protocol subject support (`mmap.mmap`, `bytearray`, `array.array`) with UTF-8 validation and GIL=0-safe memory pinning. 🗂️⚡
 * 07/24/2026 [0.4.0](https://github.com/ModelCloud/PyPcre/releases/tag/v0.4.0): C extension hardening (memory/pointer safety, bounds checks, atomic allocator init), GIL=0 safety verified, vectorized UTF-8 index/offset conversion, GIL-release threshold for small calls, C `findall` implementation, and README competitor benchmarks. 🛡️⚡
 * 04/13/2026 [0.3.0](https://github.com/ModelCloud/PyPcre/releases/tag/v0.3.0): Lower-overhead public `Match` objects, faster hot-path `match()` / `search()` / `fullmatch()` / `findall()`, and tighter free-threaded execution. ⚡
 * 03/22/2026 [0.2.15](https://github.com/ModelCloud/PyPcre/releases/tag/v0.2.15): Python 3.15 `re` compatibility (`prefixmatch`, `NOFLAG`) ✅
@@ -63,7 +65,7 @@ PyPcre pairs Python's familiar `re`-compatible API with the real `PCRE2` engine.
 
 ### Benchmark Highlights 🏁
 
-Measured on a `Python 3.14.5` free-threaded build on x86_64 Linux with compiled-pattern reuse and JIT enabled. Times are the best of several runs; lower is better. Only workloads where PyPcre is decisively faster than both `stdlib.re` and `regex` are shown.
+Measured on a `Python 3.14.6` free-threaded build on x86_64 Linux with compiled-pattern reuse and JIT enabled. Times are the best of several runs; lower is better. Only workloads where PyPcre is decisively faster than both `stdlib.re` and `regex` are shown.
 
 A reproducible version of this benchmark lives in [`benchmarks/competitor_bench.py`](benchmarks/competitor_bench.py).
 
@@ -71,9 +73,9 @@ A reproducible version of this benchmark lives in [`benchmarks/competitor_bench.
 
 | Workload | PyPcre (ms) | `re` (ms) | `regex` (ms) | PyPcre edge |
 | --- | ---: | ---: | ---: | --- |
-| Extract `WARN` / `ERROR` lines (multiline) | `0.60` | `29.35` | `30.85` | **49x** vs `re`, **52x** vs `regex` |
-| Per-line full-name extraction (multiline) | `1.02` | `29.50` | `15.95` | **29x** vs `re`, **16x** vs `regex` |
-| Lookbehind + negative-lookahead tokens | `3.78` | `11.81` | `10.42` | **3.1x** vs `re`, **2.8x** vs `regex` |
+| Extract `WARN` / `ERROR` lines (multiline) | `0.664` | `27.159` | `30.772` | **40.9x** vs `re`, **46.3x** vs `regex` |
+| Per-line full-name extraction (multiline) | `0.914` | `25.685` | `14.482` | **28.1x** vs `re`, **15.8x** vs `regex` |
+| Lookbehind + negative-lookahead tokens | `1.874` | `12.353` | `10.386` | **6.6x** vs `re`, **5.5x** vs `regex` |
 
 Patterns used:
 
@@ -88,19 +90,51 @@ Patterns used:
 
 #### `finditer` — same workloads
 
+Measured on a Python 3.10 x86_64 Linux build with compiled-pattern reuse and JIT enabled. A reproducible version lives in [`benchmarks/finditer_bench.py`](benchmarks/finditer_bench.py).
+
+| Workload | PyPcre (ms) | `re` (ms) | `regex` (ms) | PyPcre edge |
+| --- | ---: | ---: | ---: | --- |
+| Extract `WARN` / `ERROR` lines | `0.663` | `30.747` | `31.862` | **46.4x** vs `re`, **48.0x** vs `regex` |
+| Per-line full-name extraction | `0.919` | `29.127` | `14.103` | **31.7x** vs `re`, **15.3x** vs `regex` |
+| Lookbehind + negative lookahead | `3.755` | `15.828` | `11.896` | **4.2x** vs `re`, **3.2x** vs `regex` |
+
+#### `sub` / `subn` — high-volume replacement workloads
+
+Measured on a Python 3.10 x86_64 Linux build with compiled-pattern reuse and JIT enabled. Times are the best of several runs; lower is better. The benchmark replaces 100,000 space-separated tokens.
+
+A reproducible version lives in [`benchmarks/sub_bench.py`](benchmarks/sub_bench.py).
+
 | Workload | PyPcre (ms) | `re` (ms) | `regex` (ms) | PyPcre edge |
 | --- | ---: | ---: | ---: | --- |
-| Extract `WARN` / `ERROR` lines | `0.60` | `29.33` | `31.23` | **49x** vs `re`, **52x** vs `regex` |
-| Per-line full-name extraction | `1.02` | `30.09` | `16.25` | **29x** vs `re`, **16x** vs `regex` |
+| Literal replacement (`\w+` → `[X]`) | `5.933` | `13.367` | `19.107` | **2.3x** vs `re`, **3.2x** vs `regex` |
+| Single numeric backref (`(w)\d+` → `[\1]`) | `7.221` | `64.715` | `25.482` | **9.0x** vs `re`, **3.5x** vs `regex` |
+| Two numeric backrefs (`(w)(\d+)` → `\2-\1`) | `17.600` | `76.222` | `32.048` | **4.3x** vs `re`, **1.8x** vs `regex` |
+| Named backref (`(?P<g>\w+)` → `<\g<g>>`) | `14.684` | `71.053` | `30.222` | **4.8x** vs `re`, **2.1x** vs `regex` |
+
+#### `split` — high-volume delimiter workloads
+
+Measured on a Python 3.10 x86_64 Linux build with compiled-pattern reuse and JIT enabled. Times are the best of several runs; lower is better. The benchmark splits 100,000 space-separated tokens.
+
+A reproducible version lives in [`benchmarks/split_bench.py`](benchmarks/split_bench.py).
+
+| Workload | PyPcre (ms) | `re` (ms) | `regex` (ms) | PyPcre edge |
+| --- | ---: | ---: | ---: | --- |
+| Delimiter no group (`\s+`) | `7.315` | `17.394` | `19.690` | **2.4x** vs `re`, **2.7x** vs `regex` |
+| Delimiter with group (`(\s+)`) | `12.360` | `21.099` | `25.145` | **1.7x** vs `re`, **2.0x** vs `regex` |
+| Single char (` `) | `4.583` | `3.990` | `14.577` | parity vs `re`, **3.2x** vs `regex` |
+| Single char with group (`( )`) | `8.913` | `11.091` | `18.595` | **1.2x** vs `re`, **2.1x** vs `regex` |
+| Empty pattern (`''`) | `5.228` | `45.552` | `69.913` | **8.7x** vs `re`, **13.4x** vs `regex` |
 
 ### Free-Threaded Benchmark Highlights 🧵
 
-Measured in the same environment with `8` threads fanning out over independent copies of each workload. Times are the best of several runs; lower is better.
+Measured on the same `Python 3.14.6` free-threaded build with `8` threads fanning out over split copies of each workload. Times are the best of several runs; lower is better.
+
+A reproducible version lives in [`benchmarks/free_threaded_bench.py`](benchmarks/free_threaded_bench.py).
 
 | Workload | PyPcre (ms) | `re` (ms) | `regex` (ms) | PyPcre edge |
 | --- | ---: | ---: | ---: | --- |
-| Extract `WARN` / `ERROR` lines (`findall`) | `3.26` | `32.57` | `34.41` | **10.0x** vs `re`, **10.6x** vs `regex` |
-| Per-line full-name extraction (`findall`) | `3.18` | `31.84` | `17.31` | **10.0x** vs `re`, **5.4x** vs `regex` |
+| Extract `WARN` / `ERROR` lines (`findall`) | `0.672` | `9.063` | `9.297` | **13.5x** vs `re`, **13.8x** vs `regex` |
+| Per-line full-name extraction (`findall`) | `0.913` | `8.611` | `4.575` | **9.4x** vs `re`, **5.0x** vs `regex` |
 
 PyPcre is the stronger all-around choice when you want more than the baseline: full `PCRE2` features, more expressive syntax, JIT, explicit free-threaded support, and a stable `re`-compatible API surface. It keeps Python ergonomics while giving you a substantially more capable engine. 🚀
 

{pypcre-0.4.0 → pypcre-0.6.0}/pcre/__init__.py

@@ -12,12 +12,12 @@ surfacing PCRE2-specific flags and behaviours.
 
 from __future__ import annotations
 
+import importlib as _importlib
 import re as _std_re
 from typing import Any
 
 import pcre_ext_c as _backend
 
-from . import error as _error_module
 from .cache import cache_strategy, get_cache_limit, set_cache_limit
 from .error import ERRORS_BY_CODE, ERRORS_BY_MACRO, PcreErrorCode
 from .flags import Flag
@@ -43,6 +43,7 @@ from .pcre import (
 from .threads import configure_thread_pool, configure_threads, shutdown_thread_pool
 
 
+_error_module = _importlib.import_module(".error", __name__)
 pcre_ext_c = _backend
 
 __version__ = getattr(_backend, "__version__", "0.0")

{pypcre-0.4.0 → pypcre-0.6.0}/pcre/pcre.py

@@ -8,7 +8,7 @@
 from __future__ import annotations
 
 import re as _std_re
-from collections.abc import Generator, Iterable
+from collections.abc import Iterable, Iterator, Mapping
 from typing import Any, List
 
 import pcre_ext_c as _pcre2
@@ -175,13 +175,60 @@ def _normalise_flags(flags: FlagInput) -> int:
     raise TypeError("flags must be an int, stdlib re flag, or an iterable of those")
 
 
+def _pcre2_replacement_from_parsed(parsed: Any, is_bytes: bool) -> Any:
+    """Convert a parsed Python replacement template to a PCRE2 replacement string."""
+
+    if (
+        isinstance(parsed, tuple)
+        and len(parsed) == 2
+        and isinstance(parsed[0], list)
+        and isinstance(parsed[1], list)
+    ):
+        group_slots, literals = parsed
+        slot_to_group = {slot: group for slot, group in group_slots}
+        if is_bytes:
+            parts = []
+            for i, lit in enumerate(literals):
+                if i in slot_to_group:
+                    parts.append(("\\g<" + str(slot_to_group[i]) + ">").encode("ascii"))
+                if lit is not None:
+                    parts.append(lit.replace(b"\\", b"\\\\").replace(b"$", b"$$"))
+            return b"".join(parts)
+
+        parts = []
+        for i, lit in enumerate(literals):
+            if i in slot_to_group:
+                parts.append("\\g<" + str(slot_to_group[i]) + ">")
+            if lit is not None:
+                parts.append(lit.replace("\\", "\\\\").replace("$", "$$"))
+        return "".join(parts)
+
+    if is_bytes:
+        parts = []
+        for item in parsed:
+            if isinstance(item, int):
+                parts.append(("\\g<" + str(item) + ">").encode("ascii"))
+            else:
+                parts.append(item.replace(b"\\", b"\\\\").replace(b"$", b"$$"))
+        return b"".join(parts)
+
+    parts = []
+    for item in parsed:
+        if isinstance(item, int):
+            parts.append("\\g<" + str(item) + ">")
+        else:
+            parts.append(item.replace("\\", "\\\\").replace("$", "$$"))
+    return "".join(parts)
+
+
 class Pattern:
     """High-level wrapper around the C-backed :class:`pcre_ext_c.Pattern`."""
 
-    __slots__ = ("_pattern", "_groups_hint", "_thread_mode")
+    __slots__ = ("_pattern", "_groups_hint", "_thread_mode", "_is_c_pattern")
 
     def __init__(self, pattern: _CPattern) -> None:
         self._pattern = pattern
+        self._is_c_pattern = isinstance(pattern, _CPattern)
         self._thread_mode = _THREAD_MODE_DISABLED
         try:
             self._groups_hint = pattern.capture_count
@@ -196,7 +243,7 @@ class Pattern:
         return self._pattern.pattern
 
     @property
-    def groupindex(self) -> dict[str, int]:
+    def groupindex(self) -> Mapping[str, int]:
         return self._pattern.groupindex
 
     @property
@@ -260,20 +307,17 @@ class Pattern:
     ) -> Match | None:
         if type(subject) is memoryview:
             subject = subject.tobytes()
+        if self._is_c_pattern:
+            compiled_end = resolve_endpos(subject, endpos) if endpos is not None else -1
+            return self._pattern.match(subject, pos, compiled_end, options, self)
         if endpos is None:
-            raw = self._pattern.match(subject, pos=pos, options=options)
-            if raw is None:
-                return None
-            if _can_attach_match(raw):
-                return _ATTACH_MATCH(raw, self)
             resolved_end = len(subject)
+            raw = self._pattern.match(subject, pos=pos, options=options)
         else:
             resolved_end = resolve_endpos(subject, endpos)
             raw = self._pattern.match(subject, pos=pos, endpos=resolved_end, options=options)
-            if raw is None:
-                return None
-            if _can_attach_match(raw):
-                return _ATTACH_MATCH(raw, self)
+        if raw is None:
+            return None
         return self._wrap_match(raw, subject, pos, resolved_end)
 
     prefixmatch = match
@@ -288,20 +332,17 @@ class Pattern:
     ) -> Match | None:
         if type(subject) is memoryview:
             subject = subject.tobytes()
+        if self._is_c_pattern:
+            compiled_end = resolve_endpos(subject, endpos) if endpos is not None else -1
+            return self._pattern.search(subject, pos, compiled_end, options, self)
         if endpos is None:
-            raw = self._pattern.search(subject, pos=pos, options=options)
-            if raw is None:
-                return None
-            if _can_attach_match(raw):
-                return _ATTACH_MATCH(raw, self)
             resolved_end = len(subject)
+            raw = self._pattern.search(subject, pos=pos, options=options)
         else:
             resolved_end = resolve_endpos(subject, endpos)
             raw = self._pattern.search(subject, pos=pos, endpos=resolved_end, options=options)
-            if raw is None:
-                return None
-            if _can_attach_match(raw):
-                return _ATTACH_MATCH(raw, self)
+        if raw is None:
+            return None
         return self._wrap_match(raw, subject, pos, resolved_end)
 
     def fullmatch(
@@ -314,20 +355,17 @@ class Pattern:
     ) -> Match | None:
         if type(subject) is memoryview:
             subject = subject.tobytes()
+        if self._is_c_pattern:
+            compiled_end = resolve_endpos(subject, endpos) if endpos is not None else -1
+            return self._pattern.fullmatch(subject, pos, compiled_end, options, self)
         if endpos is None:
-            raw = self._pattern.fullmatch(subject, pos=pos, options=options)
-            if raw is None:
-                return None
-            if _can_attach_match(raw):
-                return _ATTACH_MATCH(raw, self)
             resolved_end = len(subject)
+            raw = self._pattern.fullmatch(subject, pos=pos, options=options)
         else:
             resolved_end = resolve_endpos(subject, endpos)
             raw = self._pattern.fullmatch(subject, pos=pos, endpos=resolved_end, options=options)
-            if raw is None:
-                return None
-            if _can_attach_match(raw):
-                return _ATTACH_MATCH(raw, self)
+        if raw is None:
+            return None
         return self._wrap_match(raw, subject, pos, resolved_end)
 
     def finditer(
@@ -337,44 +375,71 @@ class Pattern:
         pos: int = 0,
         endpos: int | None = None,
         options: int = 0,
-    ) -> Generator[Match, None, None]:
+    ) -> Iterator[Match]:
         if type(subject) is memoryview:
             subject = subject.tobytes()
-        origin_pos = pos
         resolved_end = resolve_endpos(subject, endpos)
         backend_iter = getattr(self._pattern, "finditer", None)
         if backend_iter is not None:
             compiled_end = resolved_end if endpos is not None else -1
+            if self._is_c_pattern:
+                # The C iterator stamps each Match with this public Pattern, so
+                # we can return it directly without per-match Python wrapping.
+                return backend_iter(subject, pos, compiled_end, options, self)
+            raw_iter = None
             try:
-                raw_iter = backend_iter(subject, pos=pos, endpos=compiled_end, options=options)
+                raw_iter = backend_iter(subject, pos=pos, endpos=compiled_end, options=options, owner=self)
             except TypeError:
-                raw_iter = None
+                # Older extensions and test doubles may not accept `owner`.
+                try:
+                    raw_iter = backend_iter(subject, pos=pos, endpos=compiled_end, options=options)
+                except TypeError:
+                    raw_iter = None
             if raw_iter is not None:
-                for raw in raw_iter:
-                    yield self._wrap_match(raw, subject, origin_pos, resolved_end)
-                return
+                # Peek to detect whether the backend already stamped the public
+                # owner on its Match objects.  If it did, we can yield from the
+                # raw iterator; otherwise wrap the raw results as before.
+                try:
+                    peek = next(raw_iter)
+                except StopIteration:
+                    return iter([])
+                if _can_attach_match(peek) and peek.re is self:
+                    def _owned_iter():
+                        yield peek
+                        yield from raw_iter
+                    return _owned_iter()
+                def _wrapped_iter():
+                    yield self._wrap_match(peek, subject, pos, resolved_end)
+                    for raw in raw_iter:
+                        yield self._wrap_match(raw, subject, pos, resolved_end)
+                return _wrapped_iter()
 
         search_end = resolved_end if endpos is not None else -1
         current = pos
+        origin_pos = pos
         subject_length = len(subject)
 
-        while True:
-            raw = self._pattern.search(subject, pos=current, endpos=search_end, options=options)
-            if raw is None:
-                break
+        def _generator():
+            nonlocal current
+            while True:
+                raw = self._pattern.search(subject, pos=current, endpos=search_end, options=options)
+                if raw is None:
+                    break
 
-            match_obj = self._wrap_match(raw, subject, origin_pos, resolved_end)
-            yield match_obj
+                match_obj = self._wrap_match(raw, subject, origin_pos, resolved_end)
+                yield match_obj
 
-            start, end = match_obj.span()
-            next_pos = compute_next_pos(current, (start, end), endpos)
-            if next_pos <= current:
-                next_pos = current + 1
-            current = next_pos
-            if current > subject_length:
-                break
-            if endpos is not None and current >= resolved_end:
-                break
+                start, end = match_obj.span()
+                next_pos = compute_next_pos(current, (start, end), endpos)
+                if next_pos <= current:
+                    next_pos = current + 1
+                current = next_pos
+                if current > subject_length:
+                    break
+                if endpos is not None and current >= resolved_end:
+                    break
+
+        return _generator()
 
     def findall(
         self,
@@ -422,11 +487,31 @@ class Pattern:
 
     def split(self, subject: Any, maxsplit: Any = 0) -> List[Any]:
         subject = prepare_subject(subject)
+        limit = normalise_count(maxsplit)
+        if limit == 0:
+            subject_is_bytes = is_bytes_like(subject)
+            return [
+                coerce_subject_slice(
+                    subject, 0, len(subject), is_bytes=subject_is_bytes
+                )
+            ]
+
+        # Empty patterns split at every code point/byte; avoid per-match overhead.
+        if limit is None and self.pattern in ("", b""):
+            if is_bytes_like(subject):
+                return [b""] + [bytes(subject[i : i + 1]) for i in range(len(subject))] + [b""]
+            return [""] + list(subject) + [""]
+
+        backend_split = getattr(self._pattern, "split", None)
+        if backend_split is not None:
+            try:
+                return backend_split(subject, 0 if limit is None else limit)
+            except TypeError:
+                pass
+
         subject_is_bytes = is_bytes_like(subject)
         empty = b"" if subject_is_bytes else ""
         parts: List[Any] = []
-        limit = normalise_count(maxsplit)
-
         last_end = 0
         splits_done = 0
 
@@ -472,6 +557,25 @@ class Pattern:
                     raise TypeError("replacement must be str when substituting on text")
                 template = repl
 
+            if limit is None:
+                backend_substitute = getattr(self._pattern, "substitute", None)
+                if backend_substitute is not None:
+                    try:
+                        parsed_template = _parser.parse_template(
+                            template,
+                            TemplatePatternStub(self.groups, self.groupindex),
+                        )
+                    except (ValueError, _std_re.error, IndexError) as exc:
+                        raise PcreError(str(exc)) from exc
+                    pcre2_repl = _pcre2_replacement_from_parsed(parsed_template, subject_is_bytes)
+                    try:
+                        backend_result = backend_substitute(subject, replacement=pcre2_repl, count=0)
+                    except Exception:
+                        backend_result = NotImplemented
+                    if backend_result is not NotImplemented and backend_result is not None:
+                        return backend_result
+                    parsed_template = None
+
             if self._groups_hint is not None:
                 try:
                     parsed_template = _parser.parse_template(