PyPcre 0.6.2__tar.gz → 0.6.3__tar.gz

{pypcre-0.6.2 → pypcre-0.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPcre
-Version: 0.6.2
+Version: 0.6.3
 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
@@ -37,7 +37,7 @@ Fast, free-threaded Python bindings for `PCRE2` with a stable `stdlib.re`-compat
 </p>
 
 <p align="center">
-    <a href="https://github.com/ModelCloud/PyPcre/releases" style="text-decoration:none;"><img alt="GitHub release" src="https://img.shields.io/github/release/ModelCloud/Pcre.svg"></a>
+    <a href="https://github.com/ModelCloud/PyPcre/releases" style="text-decoration:none;"><img alt="GitHub release" src="https://img.shields.io/github/release/ModelCloud/PyPcre.svg"></a>
     <a href="https://pypi.org/project/PyPcre/" style="text-decoration:none;"><img alt="PyPI - Version" src="https://img.shields.io/pypi/v/PyPcre"></a>
     <a href="https://pepy.tech/projects/PyPcre" style="text-decoration:none;"><img src="https://static.pepy.tech/badge/PyPcre" alt="PyPI Downloads"></a>
     <a href="https://github.com/ModelCloud/PyPcre/blob/main/LICENSE"><img src="https://img.shields.io/pypi/l/PyPcre"></a>
@@ -47,8 +47,10 @@ Fast, free-threaded Python bindings for `PCRE2` with a stable `stdlib.re`-compat
 
 
 ## Latest News 🚀
-* 08/09–08/10/2026 **API performance and safety update**: common regex workloads and ordered `parallel_map(search)` workloads were benchmarked across Python 3.10 and free-threaded Python 3.14t/GIL=0. Compatibility fallbacks preserve complex patterns, subclasses, buffers, and callables. Unsafe UTF bytes compilation is also blocked, with differential, randomized, concurrency, subprocess, and memory-safety coverage. 🧵⚡🛡️
-* 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. 🚀⚡
+* 10/20/2026 **[0.6.3](https://github.com/ModelCloud/PyPcre/releases/tag/v0.6.3)**: Fixed free-threaded races in `Match.lastindex` replay and PCRE2 version initialization, and reduced Python dispatch overhead across module-level and compiled-pattern `match`, `search`, `fullmatch`, `findall`, `finditer`, `split`, `sub`, and `subn` hot paths, with new concurrency and GC-cycle regression coverage plus exact fallbacks for subclasses, legacy backends, and non-default arguments. 🛡️🧵🚀⚡
+* 08/25/2026 **[0.6.2](https://github.com/ModelCloud/PyPcre/releases/tag/v0.6.2)**: Hardened packaging metadata and fixed FreeBSD/WSL CI failures on PCRE2 10.42 runtimes, including legacy replacement-template and JIT-fallback compatibility. 🛠️🐧🪟
+* 08/25/2026 **[0.6.1](https://github.com/ModelCloud/PyPcre/releases/tag/v0.6.1)**: Workaround for PCRE2 10.46/10.47 JIT start-optimization regressions, new verifying clobber suite, second memory/thread-safety sweep, Python 3.15 `sre_parse` removal compatibility, aligned `Pattern` `pos`/`endpos` signatures, and `setuptools` metadata fixes. 🛡️🧵🐍
+* 08/09/2026 **[0.6.0](https://github.com/ModelCloud/PyPcre/releases/tag/v0.6.0)**: `findall`, `finditer`, `sub`/`subn`, `split`, and `match`/`search`/`fullmatch` hot-path speedups up to **46x** vs `stdlib.re` and **48x** vs `regex`, with free-threaded `findall` reaching **13.8x** 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. ⚡
@@ -83,7 +85,7 @@ PyPcre pairs Python's familiar `re`-compatible API with the real `PCRE2` engine.
 | Syntax power | Very rich ✅ | More limited | Rich, but different from `PCRE2` |
 | JIT execution | `PCRE2` JIT ✅ | No | No |
 | `re`-compatible API surface | Stable and familiar ✅ | Native | Similar, but not the main goal |
-| Free-threaded support | Built and tested for `PYTHON_GIL=0` ✅ | No explicit PyPcre-style layer | Not a project focus here |
+| Free-threaded support | Built and tested for `PYTHON_GIL=0` ✅ | No explicit free-threaded support | No explicit free-threaded fan-out layer |
 | Built-in threaded subject fan-out | `parallel_map()` ✅ | No | No |
 | System library updates | Uses system `libpcre2-8` by default ✅ | N/A | N/A |
 
@@ -252,8 +254,10 @@ numbers = pattern.findall(b"line 1\nline 22")
 ### API Overview 🧭
 
 - Module helpers: `prefixmatch`, `match`, `search`, `fullmatch`, `finditer`,
-  `findall`, `split`, `sub`, `subn`, `compile`, `escape`, `purge`, and
-  `parallel_map`.
+  `findall`, `split`, `sub`, `subn`, `compile`, `escape`, `purge`,
+  `template`, `parallel_map`, `configure`, `configure_threads`,
+  `configure_thread_pool`, `shutdown_thread_pool`, `set_cache_limit`,
+  `get_cache_limit`, and `clear_cache`.
 - `compile()` returns a `Pattern` object with the familiar matching helpers
   plus `split()`, `sub()`, and `subn()`.
 - `Pattern` exposes `.pattern`, `.flags`, `.jit`, `.groupindex`, and `.groups`
@@ -269,7 +273,7 @@ numbers = pattern.findall(b"line 1\nline 22")
 
 ### Common examples 🧪
 
-Compiled patterns:
+🧪 Compiled patterns:
 
 ```python
 from pcre import compile, Flag
@@ -279,7 +283,7 @@ match = pattern.search("User: alice")
 print(match.group("name"))  # alice
 ```
 
-Substitution:
+🔁 Substitution:
 
 ```python
 from pcre import sub
@@ -288,7 +292,7 @@ result = sub(r"\d+", "#", "room 101")
 print(result)  # room #
 ```
 
-Bytes:
+🗂️ Bytes:
 
 ```python
 from pcre import compile
@@ -353,9 +357,9 @@ the conversion without repeating the flag.
 
 ### Optional runtime controls 🎛️
 
-- `pcre.configure(jit=False)` disables JIT globally. `Flag.JIT` and
+- ⚙️ `pcre.configure(jit=False)` disables JIT globally. `Flag.JIT` and
   `Flag.NO_JIT` let you override that per pattern.
-- `pcre.set_cache_limit()`, `pcre.get_cache_limit()`, and `pcre.clear_cache()`
+- 🧹 `pcre.set_cache_limit()`, `pcre.get_cache_limit()`, and `pcre.clear_cache()`
   control every high-level compile/template helper cache in the active context.
   A zero limit disables them, and `None` uses a 256-entry hard safety ceiling
   rather than permitting unbounded growth. High-level cache entries never cross
@@ -363,7 +367,7 @@ the conversion without repeating the flag.
   workers' high-level helper caches on their next cache-backed call. Backend
   scratch buffers remain thread-scoped and are released when that thread exits.
   Oversized patterns and templates are not retained.
-- `pcre.configure_threads()`, `pcre.configure_thread_pool()`,
+- 🧵 `pcre.configure_threads()`, `pcre.configure_thread_pool()`,
   `shutdown_thread_pool()`, `Flag.THREADS`, and `Flag.NO_THREADS` are available
   if you want to opt into or restrict threaded execution.
 

{pypcre-0.6.2 → pypcre-0.6.3}/PyPcre.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPcre
-Version: 0.6.2
+Version: 0.6.3
 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
@@ -37,7 +37,7 @@ Fast, free-threaded Python bindings for `PCRE2` with a stable `stdlib.re`-compat
 </p>
 
 <p align="center">
-    <a href="https://github.com/ModelCloud/PyPcre/releases" style="text-decoration:none;"><img alt="GitHub release" src="https://img.shields.io/github/release/ModelCloud/Pcre.svg"></a>
+    <a href="https://github.com/ModelCloud/PyPcre/releases" style="text-decoration:none;"><img alt="GitHub release" src="https://img.shields.io/github/release/ModelCloud/PyPcre.svg"></a>
     <a href="https://pypi.org/project/PyPcre/" style="text-decoration:none;"><img alt="PyPI - Version" src="https://img.shields.io/pypi/v/PyPcre"></a>
     <a href="https://pepy.tech/projects/PyPcre" style="text-decoration:none;"><img src="https://static.pepy.tech/badge/PyPcre" alt="PyPI Downloads"></a>
     <a href="https://github.com/ModelCloud/PyPcre/blob/main/LICENSE"><img src="https://img.shields.io/pypi/l/PyPcre"></a>
@@ -47,8 +47,10 @@ Fast, free-threaded Python bindings for `PCRE2` with a stable `stdlib.re`-compat
 
 
 ## Latest News 🚀
-* 08/09–08/10/2026 **API performance and safety update**: common regex workloads and ordered `parallel_map(search)` workloads were benchmarked across Python 3.10 and free-threaded Python 3.14t/GIL=0. Compatibility fallbacks preserve complex patterns, subclasses, buffers, and callables. Unsafe UTF bytes compilation is also blocked, with differential, randomized, concurrency, subprocess, and memory-safety coverage. 🧵⚡🛡️
-* 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. 🚀⚡
+* 10/20/2026 **[0.6.3](https://github.com/ModelCloud/PyPcre/releases/tag/v0.6.3)**: Fixed free-threaded races in `Match.lastindex` replay and PCRE2 version initialization, and reduced Python dispatch overhead across module-level and compiled-pattern `match`, `search`, `fullmatch`, `findall`, `finditer`, `split`, `sub`, and `subn` hot paths, with new concurrency and GC-cycle regression coverage plus exact fallbacks for subclasses, legacy backends, and non-default arguments. 🛡️🧵🚀⚡
+* 08/25/2026 **[0.6.2](https://github.com/ModelCloud/PyPcre/releases/tag/v0.6.2)**: Hardened packaging metadata and fixed FreeBSD/WSL CI failures on PCRE2 10.42 runtimes, including legacy replacement-template and JIT-fallback compatibility. 🛠️🐧🪟
+* 08/25/2026 **[0.6.1](https://github.com/ModelCloud/PyPcre/releases/tag/v0.6.1)**: Workaround for PCRE2 10.46/10.47 JIT start-optimization regressions, new verifying clobber suite, second memory/thread-safety sweep, Python 3.15 `sre_parse` removal compatibility, aligned `Pattern` `pos`/`endpos` signatures, and `setuptools` metadata fixes. 🛡️🧵🐍
+* 08/09/2026 **[0.6.0](https://github.com/ModelCloud/PyPcre/releases/tag/v0.6.0)**: `findall`, `finditer`, `sub`/`subn`, `split`, and `match`/`search`/`fullmatch` hot-path speedups up to **46x** vs `stdlib.re` and **48x** vs `regex`, with free-threaded `findall` reaching **13.8x** 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. ⚡
@@ -83,7 +85,7 @@ PyPcre pairs Python's familiar `re`-compatible API with the real `PCRE2` engine.
 | Syntax power | Very rich ✅ | More limited | Rich, but different from `PCRE2` |
 | JIT execution | `PCRE2` JIT ✅ | No | No |
 | `re`-compatible API surface | Stable and familiar ✅ | Native | Similar, but not the main goal |
-| Free-threaded support | Built and tested for `PYTHON_GIL=0` ✅ | No explicit PyPcre-style layer | Not a project focus here |
+| Free-threaded support | Built and tested for `PYTHON_GIL=0` ✅ | No explicit free-threaded support | No explicit free-threaded fan-out layer |
 | Built-in threaded subject fan-out | `parallel_map()` ✅ | No | No |
 | System library updates | Uses system `libpcre2-8` by default ✅ | N/A | N/A |
 
@@ -252,8 +254,10 @@ numbers = pattern.findall(b"line 1\nline 22")
 ### API Overview 🧭
 
 - Module helpers: `prefixmatch`, `match`, `search`, `fullmatch`, `finditer`,
-  `findall`, `split`, `sub`, `subn`, `compile`, `escape`, `purge`, and
-  `parallel_map`.
+  `findall`, `split`, `sub`, `subn`, `compile`, `escape`, `purge`,
+  `template`, `parallel_map`, `configure`, `configure_threads`,
+  `configure_thread_pool`, `shutdown_thread_pool`, `set_cache_limit`,
+  `get_cache_limit`, and `clear_cache`.
 - `compile()` returns a `Pattern` object with the familiar matching helpers
   plus `split()`, `sub()`, and `subn()`.
 - `Pattern` exposes `.pattern`, `.flags`, `.jit`, `.groupindex`, and `.groups`
@@ -269,7 +273,7 @@ numbers = pattern.findall(b"line 1\nline 22")
 
 ### Common examples 🧪
 
-Compiled patterns:
+🧪 Compiled patterns:
 
 ```python
 from pcre import compile, Flag
@@ -279,7 +283,7 @@ match = pattern.search("User: alice")
 print(match.group("name"))  # alice
 ```
 
-Substitution:
+🔁 Substitution:
 
 ```python
 from pcre import sub
@@ -288,7 +292,7 @@ result = sub(r"\d+", "#", "room 101")
 print(result)  # room #
 ```
 
-Bytes:
+🗂️ Bytes:
 
 ```python
 from pcre import compile
@@ -353,9 +357,9 @@ the conversion without repeating the flag.
 
 ### Optional runtime controls 🎛️
 
-- `pcre.configure(jit=False)` disables JIT globally. `Flag.JIT` and
+- ⚙️ `pcre.configure(jit=False)` disables JIT globally. `Flag.JIT` and
   `Flag.NO_JIT` let you override that per pattern.
-- `pcre.set_cache_limit()`, `pcre.get_cache_limit()`, and `pcre.clear_cache()`
+- 🧹 `pcre.set_cache_limit()`, `pcre.get_cache_limit()`, and `pcre.clear_cache()`
   control every high-level compile/template helper cache in the active context.
   A zero limit disables them, and `None` uses a 256-entry hard safety ceiling
   rather than permitting unbounded growth. High-level cache entries never cross
@@ -363,7 +367,7 @@ the conversion without repeating the flag.
   workers' high-level helper caches on their next cache-backed call. Backend
   scratch buffers remain thread-scoped and are released when that thread exits.
   Oversized patterns and templates are not retained.
-- `pcre.configure_threads()`, `pcre.configure_thread_pool()`,
+- 🧵 `pcre.configure_threads()`, `pcre.configure_thread_pool()`,
   `shutdown_thread_pool()`, `Flag.THREADS`, and `Flag.NO_THREADS` are available
   if you want to opt into or restrict threaded execution.
 

{pypcre-0.6.2 → pypcre-0.6.3}/README.md

@@ -14,7 +14,7 @@ Fast, free-threaded Python bindings for `PCRE2` with a stable `stdlib.re`-compat
 </p>
 
 <p align="center">
-    <a href="https://github.com/ModelCloud/PyPcre/releases" style="text-decoration:none;"><img alt="GitHub release" src="https://img.shields.io/github/release/ModelCloud/Pcre.svg"></a>
+    <a href="https://github.com/ModelCloud/PyPcre/releases" style="text-decoration:none;"><img alt="GitHub release" src="https://img.shields.io/github/release/ModelCloud/PyPcre.svg"></a>
     <a href="https://pypi.org/project/PyPcre/" style="text-decoration:none;"><img alt="PyPI - Version" src="https://img.shields.io/pypi/v/PyPcre"></a>
     <a href="https://pepy.tech/projects/PyPcre" style="text-decoration:none;"><img src="https://static.pepy.tech/badge/PyPcre" alt="PyPI Downloads"></a>
     <a href="https://github.com/ModelCloud/PyPcre/blob/main/LICENSE"><img src="https://img.shields.io/pypi/l/PyPcre"></a>
@@ -24,8 +24,10 @@ Fast, free-threaded Python bindings for `PCRE2` with a stable `stdlib.re`-compat
 
 
 ## Latest News 🚀
-* 08/09–08/10/2026 **API performance and safety update**: common regex workloads and ordered `parallel_map(search)` workloads were benchmarked across Python 3.10 and free-threaded Python 3.14t/GIL=0. Compatibility fallbacks preserve complex patterns, subclasses, buffers, and callables. Unsafe UTF bytes compilation is also blocked, with differential, randomized, concurrency, subprocess, and memory-safety coverage. 🧵⚡🛡️
-* 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. 🚀⚡
+* 10/20/2026 **[0.6.3](https://github.com/ModelCloud/PyPcre/releases/tag/v0.6.3)**: Fixed free-threaded races in `Match.lastindex` replay and PCRE2 version initialization, and reduced Python dispatch overhead across module-level and compiled-pattern `match`, `search`, `fullmatch`, `findall`, `finditer`, `split`, `sub`, and `subn` hot paths, with new concurrency and GC-cycle regression coverage plus exact fallbacks for subclasses, legacy backends, and non-default arguments. 🛡️🧵🚀⚡
+* 08/25/2026 **[0.6.2](https://github.com/ModelCloud/PyPcre/releases/tag/v0.6.2)**: Hardened packaging metadata and fixed FreeBSD/WSL CI failures on PCRE2 10.42 runtimes, including legacy replacement-template and JIT-fallback compatibility. 🛠️🐧🪟
+* 08/25/2026 **[0.6.1](https://github.com/ModelCloud/PyPcre/releases/tag/v0.6.1)**: Workaround for PCRE2 10.46/10.47 JIT start-optimization regressions, new verifying clobber suite, second memory/thread-safety sweep, Python 3.15 `sre_parse` removal compatibility, aligned `Pattern` `pos`/`endpos` signatures, and `setuptools` metadata fixes. 🛡️🧵🐍
+* 08/09/2026 **[0.6.0](https://github.com/ModelCloud/PyPcre/releases/tag/v0.6.0)**: `findall`, `finditer`, `sub`/`subn`, `split`, and `match`/`search`/`fullmatch` hot-path speedups up to **46x** vs `stdlib.re` and **48x** vs `regex`, with free-threaded `findall` reaching **13.8x** 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. ⚡
@@ -60,7 +62,7 @@ PyPcre pairs Python's familiar `re`-compatible API with the real `PCRE2` engine.
 | Syntax power | Very rich ✅ | More limited | Rich, but different from `PCRE2` |
 | JIT execution | `PCRE2` JIT ✅ | No | No |
 | `re`-compatible API surface | Stable and familiar ✅ | Native | Similar, but not the main goal |
-| Free-threaded support | Built and tested for `PYTHON_GIL=0` ✅ | No explicit PyPcre-style layer | Not a project focus here |
+| Free-threaded support | Built and tested for `PYTHON_GIL=0` ✅ | No explicit free-threaded support | No explicit free-threaded fan-out layer |
 | Built-in threaded subject fan-out | `parallel_map()` ✅ | No | No |
 | System library updates | Uses system `libpcre2-8` by default ✅ | N/A | N/A |
 
@@ -229,8 +231,10 @@ numbers = pattern.findall(b"line 1\nline 22")
 ### API Overview 🧭
 
 - Module helpers: `prefixmatch`, `match`, `search`, `fullmatch`, `finditer`,
-  `findall`, `split`, `sub`, `subn`, `compile`, `escape`, `purge`, and
-  `parallel_map`.
+  `findall`, `split`, `sub`, `subn`, `compile`, `escape`, `purge`,
+  `template`, `parallel_map`, `configure`, `configure_threads`,
+  `configure_thread_pool`, `shutdown_thread_pool`, `set_cache_limit`,
+  `get_cache_limit`, and `clear_cache`.
 - `compile()` returns a `Pattern` object with the familiar matching helpers
   plus `split()`, `sub()`, and `subn()`.
 - `Pattern` exposes `.pattern`, `.flags`, `.jit`, `.groupindex`, and `.groups`
@@ -246,7 +250,7 @@ numbers = pattern.findall(b"line 1\nline 22")
 
 ### Common examples 🧪
 
-Compiled patterns:
+🧪 Compiled patterns:
 
 ```python
 from pcre import compile, Flag
@@ -256,7 +260,7 @@ match = pattern.search("User: alice")
 print(match.group("name"))  # alice
 ```
 
-Substitution:
+🔁 Substitution:
 
 ```python
 from pcre import sub
@@ -265,7 +269,7 @@ result = sub(r"\d+", "#", "room 101")
 print(result)  # room #
 ```
 
-Bytes:
+🗂️ Bytes:
 
 ```python
 from pcre import compile
@@ -330,9 +334,9 @@ the conversion without repeating the flag.
 
 ### Optional runtime controls 🎛️
 
-- `pcre.configure(jit=False)` disables JIT globally. `Flag.JIT` and
+- ⚙️ `pcre.configure(jit=False)` disables JIT globally. `Flag.JIT` and
   `Flag.NO_JIT` let you override that per pattern.
-- `pcre.set_cache_limit()`, `pcre.get_cache_limit()`, and `pcre.clear_cache()`
+- 🧹 `pcre.set_cache_limit()`, `pcre.get_cache_limit()`, and `pcre.clear_cache()`
   control every high-level compile/template helper cache in the active context.
   A zero limit disables them, and `None` uses a 256-entry hard safety ceiling
   rather than permitting unbounded growth. High-level cache entries never cross
@@ -340,7 +344,7 @@ the conversion without repeating the flag.
   workers' high-level helper caches on their next cache-backed call. Backend
   scratch buffers remain thread-scoped and are released when that thread exits.
   Oversized patterns and templates are not retained.
-- `pcre.configure_threads()`, `pcre.configure_thread_pool()`,
+- 🧵 `pcre.configure_threads()`, `pcre.configure_thread_pool()`,
   `shutdown_thread_pool()`, `Flag.THREADS`, and `Flag.NO_THREADS` are available
   if you want to opt into or restrict threaded execution.
 

{pypcre-0.6.2 → pypcre-0.6.3}/pcre/pcre.py

@@ -64,6 +64,26 @@ from .threads import (
 )
 
 _CPattern = _pcre2.Pattern
+_C_PATTERN_TYPE = _CPattern
+# Method descriptors avoid repeated bound-method lookup on the dominant
+# default-argument paths.  The exact-type guards below keep legacy backends,
+# subclasses, and monkeypatched test doubles on the general wrapper path.
+_RAW_MATCH_FAST = getattr(_C_PATTERN_TYPE, "_match_fast", None)
+_RAW_SEARCH_FAST = getattr(_C_PATTERN_TYPE, "_search_fast", None)
+_RAW_FULLMATCH_FAST = getattr(_C_PATTERN_TYPE, "_fullmatch_fast", None)
+_RAW_FINDITER_FAST = getattr(_C_PATTERN_TYPE, "_finditer_fast", None)
+_RAW_FINDALL_FAST = getattr(_C_PATTERN_TYPE, "_findall_fast", None)
+_RAW_SPLIT_FAST = getattr(_C_PATTERN_TYPE, "_split_fast", None)
+_RAW_SPLIT_LITERAL_CAPTURE_FAST = getattr(
+    _C_PATTERN_TYPE, "_split_literal_capture_fast", None
+)
+_RAW_SPLIT_LITERAL_CAPTURES_FAST = getattr(
+    _C_PATTERN_TYPE, "_split_literal_captures_fast", None
+)
+_RAW_SUBSTITUTE_FAST = getattr(_C_PATTERN_TYPE, "_substitute_fast", None)
+_RAW_SUBSTITUTE_PYTHON_FAST = getattr(
+    _C_PATTERN_TYPE, "_substitute_python_fast", None
+)
 _ORIGINAL_CACHED_COMPILE = cached_compile
 PcreError = _pcre2.PcreError
 Match = getattr(_pcre2, "Match", _CompatMatch)
@@ -101,6 +121,10 @@ def _synchronize_local_caches() -> None:
         setattr(_DEFAULT_COMPILE_LOCAL, name, None)
     _DEFAULT_COMPILE_LOCAL.module_hot_key = None
     _DEFAULT_COMPILE_LOCAL.module_hot_value = None
+    _DEFAULT_COMPILE_LOCAL.module_hot_pattern = None
+    _DEFAULT_COMPILE_LOCAL.module_hot_config = None
+    _DEFAULT_COMPILE_LOCAL.module_hot_thread_default = None
+    _DEFAULT_COMPILE_LOCAL.module_hot_epoch = -1
     _DEFAULT_COMPILE_LOCAL.replacement_hot_key = None
     _DEFAULT_COMPILE_LOCAL.replacement_hot_value = None
     for name in _LOCAL_CACHE_NAMES:
@@ -138,6 +162,10 @@ def _cache_configuration_changed() -> None:
         setattr(_DEFAULT_COMPILE_LOCAL, name, None)
     _DEFAULT_COMPILE_LOCAL.module_hot_key = None
     _DEFAULT_COMPILE_LOCAL.module_hot_value = None
+    _DEFAULT_COMPILE_LOCAL.module_hot_pattern = None
+    _DEFAULT_COMPILE_LOCAL.module_hot_config = None
+    _DEFAULT_COMPILE_LOCAL.module_hot_thread_default = None
+    _DEFAULT_COMPILE_LOCAL.module_hot_epoch = -1
     _DEFAULT_COMPILE_LOCAL.replacement_hot_key = None
     _DEFAULT_COMPILE_LOCAL.replacement_hot_value = None
     _DEFAULT_COMPILE_LOCAL.effective_limit = get_effective_cache_limit()
@@ -548,6 +576,17 @@ class Pattern:
         if type(subject) is memoryview:
             subject = subject.tobytes()
         if self._is_c_pattern:
+            if (
+                _RAW_MATCH_FAST is not None
+                and type(self) is Pattern
+                and type(self._pattern) is _C_PATTERN_TYPE
+                and type(pos) is int
+                and pos == 0
+                and endpos is None
+                and type(options) is int
+                and options == 0
+            ):
+                return _RAW_MATCH_FAST(self._pattern, subject, self)
             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:
@@ -575,6 +614,17 @@ class Pattern:
         if type(subject) is memoryview:
             subject = subject.tobytes()
         if self._is_c_pattern:
+            if (
+                _RAW_SEARCH_FAST is not None
+                and type(self) is Pattern
+                and type(self._pattern) is _C_PATTERN_TYPE
+                and type(pos) is int
+                and pos == 0
+                and endpos is None
+                and type(options) is int
+                and options == 0
+            ):
+                return _RAW_SEARCH_FAST(self._pattern, subject, self)
             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:
@@ -620,6 +670,17 @@ class Pattern:
         if type(subject) is memoryview:
             subject = subject.tobytes()
         if self._is_c_pattern:
+            if (
+                _RAW_FULLMATCH_FAST is not None
+                and type(self) is Pattern
+                and type(self._pattern) is _C_PATTERN_TYPE
+                and type(pos) is int
+                and pos == 0
+                and endpos is None
+                and type(options) is int
+                and options == 0
+            ):
+                return _RAW_FULLMATCH_FAST(self._pattern, subject, self)
             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:
@@ -644,6 +705,27 @@ class Pattern:
     ) -> Iterator[Match]:
         if type(subject) is memoryview:
             subject = subject.tobytes()
+        if (
+            _RAW_FINDITER_FAST is not None
+            and self._is_c_pattern
+            and type(self) is Pattern
+            and type(self._pattern) is _C_PATTERN_TYPE
+            and type(pos) is int
+            and pos == 0
+            and endpos is None
+            and type(options) is int
+            and options == 0
+        ):
+            return _RAW_FINDITER_FAST(self._pattern, subject, 0, -1, 0, self)
+        return self._finditer_general(subject, pos, endpos, options)
+
+    def _finditer_general(
+        self,
+        subject: Any,
+        pos: int,
+        endpos: int | None,
+        options: int,
+    ) -> Iterator[Match]:
         resolved_end = resolve_endpos(subject, endpos)
         backend_iter = getattr(self._pattern, "finditer", None)
         if backend_iter is not None:
@@ -783,6 +865,11 @@ class Pattern:
                 and type(options) is int
                 and options == 0
             ):
+                if (
+                    type(self._pattern) is _C_PATTERN_TYPE
+                    and _RAW_FINDALL_FAST is not None
+                ):
+                    return _RAW_FINDALL_FAST(self._pattern, subject)
                 fast = getattr(self._pattern, "_findall_fast", None)
                 if fast is not None:
                     return fast(subject)
@@ -846,9 +933,11 @@ class Pattern:
             and literal_capture is not None
             and type(subject) is type(literal_capture)
             and type(maxsplit) is int
+            and type(self._pattern) is _C_PATTERN_TYPE
+            and _RAW_SPLIT_LITERAL_CAPTURE_FAST is not None
         ):
-            return self._pattern._split_literal_capture_fast(
-                subject, literal_capture, maxsplit
+            return _RAW_SPLIT_LITERAL_CAPTURE_FAST(
+                self._pattern, subject, literal_capture, maxsplit
             )
 
         literal_multi = self._literal_findall_multi
@@ -858,10 +947,12 @@ class Pattern:
             and literal_multi is not None
             and type(subject) is type(literal_multi[0])
             and type(maxsplit) is int
+            and type(self._pattern) is _C_PATTERN_TYPE
+            and _RAW_SPLIT_LITERAL_CAPTURES_FAST is not None
         ):
             needle, groups = literal_multi
-            return self._pattern._split_literal_captures_fast(
-                subject, needle, groups, maxsplit
+            return _RAW_SPLIT_LITERAL_CAPTURES_FAST(
+                self._pattern, subject, needle, groups, maxsplit
             )
 
         # The common immutable/default shape can go straight to the C splitter.
@@ -875,6 +966,11 @@ class Pattern:
             and type(maxsplit) is int
             and maxsplit == 0
         ):
+            if (
+                type(self._pattern) is _C_PATTERN_TYPE
+                and _RAW_SPLIT_FAST is not None
+            ):
+                return _RAW_SPLIT_FAST(self._pattern, subject, 0)
             fast_split = getattr(self._pattern, "_split_fast", None)
             if fast_split is not None:
                 return fast_split(subject, 0)
@@ -946,6 +1042,42 @@ class Pattern:
         return parts
 
     def sub(self, repl: Any, subject: Any, count: Any = 0) -> Any:
+        if (
+            _RAW_SUBSTITUTE_FAST is not None
+            and self._is_c_pattern
+            and type(self) is Pattern
+            and type(self._pattern) is _C_PATTERN_TYPE
+            and self._literal_split is None
+            and type(subject) in (str, bytes)
+            and type(repl) is type(subject)
+            and type(count) is int
+            and 0 <= count <= 8
+        ):
+            replacement_is_text = type(repl) is str
+            has_escape = (
+                "\\" in repl if replacement_is_text else b"\\" in repl
+            )
+            has_dollar = "$" in repl if replacement_is_text else b"$" in repl
+            if not has_escape and not has_dollar:
+                if count == 0:
+                    return _RAW_SUBSTITUTE_FAST(self._pattern, subject, repl)[0]
+                return _RAW_SUBSTITUTE_FAST(
+                    self._pattern, subject, repl, count
+                )[0]
+            if (
+                has_escape
+                and not has_dollar
+                and _RAW_SUBSTITUTE_PYTHON_FAST is not None
+            ):
+                direct = (
+                    _RAW_SUBSTITUTE_PYTHON_FAST(self._pattern, subject, repl)
+                    if count == 0
+                    else _RAW_SUBSTITUTE_PYTHON_FAST(
+                        self._pattern, subject, repl, count
+                    )
+                )
+                if direct is not NotImplemented:
+                    return direct[0]
         result, _ = self.subn(repl, subject, count)
         return result
 
@@ -1528,6 +1660,10 @@ def _clear_module_cache() -> None:
     _DEFAULT_COMPILE_LOCAL.module_lru = None
     _DEFAULT_COMPILE_LOCAL.module_hot_key = None
     _DEFAULT_COMPILE_LOCAL.module_hot_value = None
+    _DEFAULT_COMPILE_LOCAL.module_hot_pattern = None
+    _DEFAULT_COMPILE_LOCAL.module_hot_config = None
+    _DEFAULT_COMPILE_LOCAL.module_hot_thread_default = None
+    _DEFAULT_COMPILE_LOCAL.module_hot_epoch = -1
 
 
 def _module_cache_size() -> int:
@@ -1539,26 +1675,41 @@ _cached_module_pattern.cache_clear = _clear_module_cache  # type: ignore[attr-de
 
 
 def _module_compile(pattern: Any, flags: FlagInput) -> Pattern:
-    if type(pattern) in (str, bytes) and type(flags) in (int, Flag) and flags == 0:
-        default_jit, default_compat = _default_config_snapshot()
+    if (
+        (type(pattern) is str or type(pattern) is bytes)
+        and (type(flags) is int or type(flags) is Flag)
+        and flags == 0
+    ):
+        state = _DEFAULT_COMPILE_LOCAL
+        thread_default = get_thread_default()
+        try:
+            if (
+                state.module_hot_pattern is pattern
+                and state.module_hot_config is _DEFAULT_CONFIG
+                and state.module_hot_thread_default == thread_default
+                and state.module_hot_epoch == get_cache_epoch()
+            ):
+                return state.module_hot_value
+        except AttributeError:
+            pass
+        default_jit, default_compat = _DEFAULT_CONFIG
         thread_mode = (
-            _THREAD_MODE_AUTO if get_thread_default() else _THREAD_MODE_DISABLED
+            _THREAD_MODE_AUTO if thread_default else _THREAD_MODE_DISABLED
         )
         key = (pattern, default_jit, default_compat, thread_mode)
-        if (
-            getattr(_DEFAULT_COMPILE_LOCAL, "epoch", -1) == get_cache_epoch()
-            and getattr(_DEFAULT_COMPILE_LOCAL, "module_hot_key", None) == key
-        ):
-            return _DEFAULT_COMPILE_LOCAL.module_hot_value
         compiled = _cached_module_pattern(
             pattern,
             default_jit,
             default_compat,
             thread_mode,
         )
-        if _DEFAULT_COMPILE_LOCAL.effective_limit > 0 and cache_input_allowed(pattern):
-            _DEFAULT_COMPILE_LOCAL.module_hot_key = key
-            _DEFAULT_COMPILE_LOCAL.module_hot_value = compiled
+        if state.effective_limit > 0 and cache_input_allowed(pattern):
+            state.module_hot_key = key
+            state.module_hot_value = compiled
+            state.module_hot_pattern = pattern
+            state.module_hot_config = _DEFAULT_CONFIG
+            state.module_hot_thread_default = thread_default
+            state.module_hot_epoch = get_cache_epoch()
         return compiled
     return compile(pattern, flags=flags)
 
@@ -1572,13 +1723,42 @@ def _module_lookup(pattern: Any, string: Any, flags: FlagInput, method: str) ->
         and type(string) in (str, bytes)
         and compiled._is_c_pattern
     ):
-        if (
-            method == "findall"
-            and getattr(compiled, "_literal_split", None) is not None
-            and type(string) is type(compiled._literal_split)
-        ):
-            return compiled.findall(string)
-        fast = getattr(compiled._pattern, f"_{method}_fast", None)
+        if method == "findall":
+            literal_capture = getattr(compiled, "_literal_findall", None)
+            if (
+                type(compiled) is Pattern
+                and literal_capture is not None
+                and type(string) is type(literal_capture)
+            ):
+                return [literal_capture] * string.count(literal_capture)
+            literal_multi = getattr(compiled, "_literal_findall_multi", None)
+            if (
+                type(compiled) is Pattern
+                and literal_multi is not None
+                and type(string) is type(literal_multi[0])
+            ):
+                needle, groups = literal_multi
+                return [groups] * string.count(needle)
+            literal_split = getattr(compiled, "_literal_split", None)
+            if (
+                type(compiled) is Pattern
+                and literal_split is not None
+                and type(string) is type(literal_split)
+            ):
+                return [literal_split] * string.count(literal_split)
+        raw_pattern = compiled._pattern
+        if type(raw_pattern) is _C_PATTERN_TYPE:
+            if method == "findall" and _RAW_FINDALL_FAST is not None:
+                return _RAW_FINDALL_FAST(raw_pattern, string)
+            if method == "finditer" and _RAW_FINDITER_FAST is not None:
+                return _RAW_FINDITER_FAST(raw_pattern, string, 0, -1, 0, compiled)
+            if method == "match" and _RAW_MATCH_FAST is not None:
+                return _RAW_MATCH_FAST(raw_pattern, string, compiled)
+            if method == "search" and _RAW_SEARCH_FAST is not None:
+                return _RAW_SEARCH_FAST(raw_pattern, string, compiled)
+            if method == "fullmatch" and _RAW_FULLMATCH_FAST is not None:
+                return _RAW_FULLMATCH_FAST(raw_pattern, string, compiled)
+        fast = getattr(raw_pattern, f"_{method}_fast", None)
         if fast is not None:
             if method == "findall":
                 return fast(string)
@@ -1626,7 +1806,41 @@ def split(
         literal_split = getattr(compiled, "_literal_split", None)
         if literal_split is not None and type(string) is type(literal_split):
             return compiled.split(string, maxsplit)
-        fast = getattr(compiled._pattern, "_split_fast", None)
+        literal_capture = getattr(compiled, "_literal_findall", None)
+        if (
+            type(compiled) is Pattern
+            and literal_capture is not None
+            and type(string) is type(literal_capture)
+        ):
+            raw_pattern = compiled._pattern
+            if (
+                type(raw_pattern) is _C_PATTERN_TYPE
+                and _RAW_SPLIT_LITERAL_CAPTURE_FAST is not None
+            ):
+                return _RAW_SPLIT_LITERAL_CAPTURE_FAST(
+                    raw_pattern, string, literal_capture, maxsplit
+                )
+            return compiled.split(string, maxsplit)
+        literal_multi = getattr(compiled, "_literal_findall_multi", None)
+        if (
+            type(compiled) is Pattern
+            and literal_multi is not None
+            and type(string) is type(literal_multi[0])
+        ):
+            needle, groups = literal_multi
+            raw_pattern = compiled._pattern
+            if (
+                type(raw_pattern) is _C_PATTERN_TYPE
+                and _RAW_SPLIT_LITERAL_CAPTURES_FAST is not None
+            ):
+                return _RAW_SPLIT_LITERAL_CAPTURES_FAST(
+                    raw_pattern, string, needle, groups, maxsplit
+                )
+            return compiled.split(string, maxsplit)
+        raw_pattern = compiled._pattern
+        if type(raw_pattern) is _C_PATTERN_TYPE and _RAW_SPLIT_FAST is not None:
+            return _RAW_SPLIT_FAST(raw_pattern, string, maxsplit)
+        fast = getattr(raw_pattern, "_split_fast", None)
         if fast is not None:
             return fast(string, maxsplit)
     return compiled.split(string, maxsplit=maxsplit)
@@ -1635,7 +1849,13 @@ def split(
 def sub(
     pattern: Any, repl: Any, string: Any, count: Any = 0, flags: FlagInput = 0
 ) -> Any:
-    result = subn(pattern, repl, string, count=count, flags=flags)
+    compiled = _module_compile(pattern, flags)
+    if (
+        type(compiled) is Pattern
+        and type(compiled._pattern) is _C_PATTERN_TYPE
+    ):
+        return compiled.sub(repl, string, count)
+    result = compiled.subn(repl, string, count=count)
     return result[0]
 
 

{pypcre-0.6.2 → pypcre-0.6.3}/pcre_ext/pcre2.c

@@ -30,6 +30,7 @@ resolve_pcre2_prerelease(void)
 /* Process-wide library metadata cached once during module initialization. */
 static char pcre2_library_version[64] = "unknown";
 static ATOMIC_VAR(int) pcre2_version_initialized = 0;
+static atomic_flag pcre2_version_lock = ATOMIC_FLAG_INIT;
 /* Module execution is limited to one interpreter because these are process globals. */
 static ATOMIC_VAR(PyInterpreterState *) primary_interpreter = ATOMIC_VAR_INIT(NULL);
 #if defined(PCRE2_USE_OFFSET_LIMIT)
@@ -1024,24 +1025,34 @@ Match_get_lastindex(MatchObject *self, void *closure)
         return PyLong_FromLong(lastindex);
     }
 
+    /*
+     * Replay compiles/runs PCRE2 and may allocate Python objects, so it must
+     * not run while holding the Match critical section.  Concurrent callers
+     * may replay the same immutable snapshot; the first successful result is
+     * published under the lock and all callers use that cached value.
+     */
     int lastindex = -1;
-    int replay_ok = 0;
-    Py_BEGIN_CRITICAL_SECTION(self);
-    if (self->lastindex_cache == -2) {
-        int replayed = 0;
-        if (match_replay_lastindex(self, &replayed) == 0) {
-            self->lastindex_cache = replayed == 0 ? -1 : replayed;
-            replay_ok = 1;
+    int replayed = 0;
+    if (match_replay_lastindex(self, &replayed) < 0) {
+        int cached_lastindex = -2;
+        Py_BEGIN_CRITICAL_SECTION(self);
+        cached_lastindex = self->lastindex_cache;
+        Py_END_CRITICAL_SECTION();
+        if (cached_lastindex == -2) {
+            return NULL;
         }
+        /* Another thread completed the replay while this one failed. */
+        PyErr_Clear();
+        lastindex = cached_lastindex;
     } else {
-        replay_ok = 1;
+        Py_BEGIN_CRITICAL_SECTION(self);
+        if (self->lastindex_cache == -2) {
+            self->lastindex_cache = replayed == 0 ? -1 : replayed;
+        }
+        lastindex = self->lastindex_cache;
+        Py_END_CRITICAL_SECTION();
     }
-    lastindex = self->lastindex_cache;
-    Py_END_CRITICAL_SECTION();
 
-    if (!replay_ok) {
-        return NULL;
-    }
     if (lastindex < 0) {
         Py_RETURN_NONE;
     }
@@ -6434,7 +6445,7 @@ module_exec(PyObject *module)
         goto error_cache;
     }
 
-    if (PyModule_AddStringConstant(module, "__version__", "0.6.1") < 0) {
+    if (PyModule_AddStringConstant(module, "__version__", "0.6.3") < 0) {
         goto error_cache;
     }
 
@@ -6512,6 +6523,16 @@ initialize_pcre2_version(void)
         return;
     }
 
+    while (atomic_flag_test_and_set_explicit(
+               &pcre2_version_lock,
+               memory_order_acquire)) {
+        /* Initialization only performs a few PCRE2 queries and string copies. */
+    }
+    if (atomic_load_explicit(&pcre2_version_initialized, memory_order_acquire)) {
+        atomic_flag_clear_explicit(&pcre2_version_lock, memory_order_release);
+        return;
+    }
+
     char buffer[sizeof(pcre2_library_version)] = {0};
     if (pcre2_config(PCRE2_CONFIG_VERSION, buffer) > 0 && buffer[0] != '\0') {
         strncpy(pcre2_library_version, buffer, sizeof(pcre2_library_version) - 1);
@@ -6538,4 +6559,5 @@ initialize_pcre2_version(void)
         }
     }
     atomic_store_explicit(&pcre2_version_initialized, 1, memory_order_release);
+    atomic_flag_clear_explicit(&pcre2_version_lock, memory_order_release);
 }

{pypcre-0.6.2 → pypcre-0.6.3}/pyproject.toml

@@ -9,7 +9,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "PyPcre"
-version = "0.6.2"
+version = "0.6.3"
 description = "Modern, GIL-friendly, Fast Python bindings for PCRE2 with auto caching and JIT of compiled patterns."
 readme = "README.md"
 requires-python = ">=3.10"

{pypcre-0.6.2 → pypcre-0.6.3}/setup.py

@@ -310,7 +310,7 @@ EXTENSION = Extension(
 
 setup(
     name="PyPcre",
-    version="0.6.1",
+    version="0.6.3",
     packages=["pcre"],
     ext_modules=[EXTENSION],
     cmdclass={"build_ext": build_ext},

{pypcre-0.6.2 → pypcre-0.6.3}/tests/test_lastindex_semantics.py

@@ -5,6 +5,7 @@
 from __future__ import annotations
 
 import re
+import threading
 from concurrent.futures import ThreadPoolExecutor
 
 import pcre_ext_c as raw
@@ -113,3 +114,22 @@ def test_lastindex_replay_code_initialization_is_shared_thread_safely() -> None:
     with ThreadPoolExecutor(max_workers=16) as executor:
         observed = list(executor.map(read_distinct_match, matches))
     assert observed == [(1, "outer")] * len(matches)
+
+
+def test_shared_multicapture_replay_is_thread_safe() -> None:
+    pattern = pcre.compile(r"(?P<outer>a(?P<inner>b))", pcre.Flag.NO_JIT)
+    match = pattern.fullmatch("ab")
+    assert match is not None
+    barrier = threading.Barrier(16)
+
+    def read_shared_match(_: int) -> set[tuple[int | None, str | None]]:
+        barrier.wait(timeout=5)
+        observed: set[tuple[int | None, str | None]] = set()
+        for _ in range(512):
+            observed.add((match.lastindex, match.lastgroup))
+            assert match.re is pattern
+        return observed
+
+    with ThreadPoolExecutor(max_workers=16) as executor:
+        observed = list(executor.map(read_shared_match, range(16)))
+    assert observed == [{(1, "outer")}] * 16

{pypcre-0.6.2 → pypcre-0.6.3}/tests/test_memory.py

@@ -4,8 +4,10 @@ from __future__ import annotations
 
 import gc
 import tracemalloc
+import weakref
 
 import pcre
+import pcre_ext_c as raw
 import pytest
 from pcre import Flag
 
@@ -159,3 +161,48 @@ def test_repeated_operation_releases_memory(method: str, flags: Flag) -> None:
 
     leaked = after - before
     assert leaked <= 16384, f"{method} leaked {leaked} bytes over 1000 iterations"
+
+
+class _TextSubject(str):
+    pass
+
+
+class _BufferSubject(bytearray):
+    pass
+
+
+def _assert_collected(ref: weakref.ReferenceType[object]) -> None:
+    for _ in range(5):
+        gc.collect()
+        if ref() is None:
+            return
+    assert ref() is None
+
+
+@pytest.mark.parametrize("subject_factory", [_TextSubject, _BufferSubject])
+@pytest.mark.parametrize("operation", ["match", "finditer"])
+def test_match_and_finditer_ownership_cycles_are_collectable(
+    subject_factory: type[str] | type[bytearray],
+    operation: str,
+) -> None:
+    is_text = subject_factory is _TextSubject
+    subject = subject_factory("abc" if is_text else b"abc")
+    pattern = raw.compile("(a)" if is_text else b"(a)", jit=False)
+    result = getattr(pattern, operation)(subject)
+    subject.owner = result
+    ref = weakref.ref(subject)
+
+    del result, pattern, subject
+    raw.clear_pattern_cache()
+    _assert_collected(ref)
+
+
+def test_pattern_source_ownership_cycle_is_collectable() -> None:
+    subject = _TextSubject("(a)")
+    pattern = raw.compile(subject, jit=False)
+    subject.owner = pattern
+    ref = weakref.ref(subject)
+
+    del pattern, subject
+    raw.clear_pattern_cache()
+    _assert_collected(ref)

{pypcre-0.6.2 → pypcre-0.6.3}/tests/test_version.py

@@ -1,3 +1,5 @@
+import concurrent.futures
+import threading
 import unittest
 
 import pcre_ext_c
@@ -17,6 +19,19 @@ class PcreVersionTest(unittest.TestCase):
 
         self.assertEqual(runtime_version, version_constant)
 
+    def test_runtime_version_query_is_thread_safe(self) -> None:
+        barrier = threading.Barrier(16)
+
+        def query(_: int) -> str:
+            barrier.wait(timeout=5)
+            return pcre_ext_c.get_library_version()
+
+        with concurrent.futures.ThreadPoolExecutor(max_workers=16) as executor:
+            versions = list(executor.map(query, range(64)))
+
+        self.assertEqual(len(set(versions)), 1)
+        self.assertTrue(versions[0])
+
 
 if __name__ == "__main__":
     unittest.main()