Prioritize cmake and fix cmake check (#16)

* ruff

* always clean old builds for src builds

* prioritize cmake

* refractor

* update

Author: Qubitium

README.md

@@ -9,14 +9,22 @@
 
 Python bindings for the system PCRE2 library with a familiar `re`-style API.
 
+<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://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>
+    <a href="https://huggingface.co/modelcloud/"><img src="https://img.shields.io/badge/🤗%20Hugging%20Face-ModelCloud-%23ff8811.svg"></a>
+</p>
+
+
 ## Installation
 
 ```bash
 pip install PyPcre
 ```
 
-The package links against the `libpcre2-8` variant already available on your
-system. See [Building](#building) for manual build details.
+The package prioritizes linking against the `libpcre2-8` shared library in system for fast install and max security protection which gets latest patches from OS. See [Building](#building) for manual build details.
 
 ## Usage
 
@@ -78,16 +86,10 @@ the conversion without repeating the flag.
 ### Automatic pattern caching
 
 `pcre.compile()` caches the final `Pattern` wrapper for up to 128
-unique `(pattern, flags)` pairs when the pattern object is hashable. This
-keeps repeated calls to top-level helpers efficient without any extra work
-from the caller. Adjust the capacity with `pcre.set_cache_limit(n)`—pass
+unique `(pattern, flags)` pairs when the pattern object is hashable. Adjust the capacity with `pcre.set_cache_limit(n)`—pass
 `0` to disable caching completely or `None` for an unlimited cache—and
 check the current limit with `pcre.get_cache_limit()`. The cache can be
-emptied at any time with `pcre.clear_cache()` if your application needs to
-release memory proactively.
-
-Non-hashable patterns (for example, custom objects) bypass the cache and are
-still compiled immediately.
+emptied at any time with `pcre.clear_cache()`.
 
 ### Text versus bytes defaults
 
@@ -116,7 +118,7 @@ bytes.
   order of the provided subjects and returns the same result objects you’d
   normally receive from the `Pattern` methods.
 - Threading is **opt-in by default** when Python runs without the GIL
-  (e.g. CPython with `-X gil=0` or `PYTHON_GIL=0`). When the GIL is active the default falls
+  (e.g. Python with `-X gil=0` or `PYTHON_GIL=0`). When the GIL is active the default falls
   back to sequential execution to avoid needless overhead.
 - With auto threading enabled (`configure_threads(enabled=True)`), the pool
   is only engaged when at least one subject is larger than the configured
@@ -131,9 +133,9 @@ bytes.
   `preload=True` to spin the pool up eagerly, and `shutdown_thread_pool()`
   to tear it down manually if needed.
 
-### JIT control
+### JIT Pattern Compilation and Execution
 
-Pcre’s JIT compiler is enabled by default for every compiled pattern. The
+Pcre2’s JIT compiler is enabled by default for every compiled pattern. The
 wrapper exposes two complementary ways to adjust that behaviour:
 
 - Toggle the global default at runtime with `pcre.configure(jit=False)` to
@@ -151,6 +153,29 @@ wrapper exposes two complementary ways to adjust that behaviour:
   slow = compile(r"expr", flags=Flag.NO_JIT)   # force-disable for this pattern
   ```
 
+## Pattern cache
+- `pcre.compile()` caches hashable `(pattern, flags)` pairs, keeping up to 128 entries.
+- Use `pcre.clear_cache()` when you need to free the cache proactively.
+- Non-hashable pattern objects skip the cache and are compiled each time.
+
+## Default flags for text patterns
+- String patterns enable `Flag.UTF` and `Flag.UCP` automatically so behaviour matches `re`.
+- Byte patterns keep both flags disabled; opt in manually if Unicode semantics are desired.
+- Explicitly supply `Flag.NO_UTF`/`Flag.NO_UCP` to override the defaults for strings.
+
+## Additional usage notes
+- All top-level helpers (`match`, `search`, `fullmatch`, `finditer`, `findall`) defer to the cached compiler.
+- Compiled `Pattern` objects expose `.pattern`, `.flags`, `.jit`, and `.groupindex` for introspection.
+- Execution helpers accept `pos`, `endpos`, and `options`, allowing you to thread PCRE2 execution flags per call.
+
+## Memory allocation
+- PyPcre will select the fastest available allocator at import time: it
+  prefers jemalloc, then tcmalloc, and finally falls back to the platform
+  `malloc`. Optional allocators are loaded via `dlopen`, so no additional
+  link flags are required when they are absent.
+- Call `pcre_ext_c.get_allocator()` to inspect which backend is active at
+  runtime.
+
 ## Building
 
 The extension links against an existing PCRE2 installation (the `libpcre2-8`
@@ -182,31 +207,3 @@ If your system ships `libpcre2-8` under `/usr` but you also maintain a
 manually built copy under `/usr/local`, export `PCRE2_LIBRARY_PATH` (and, if
 needed, a matching `PCRE2_INCLUDE_DIR`) so the build links against the desired
 location.
-
-# Notes
-
-## Pattern cache
-- `pcre.compile()` caches hashable `(pattern, flags)` pairs, keeping up to 128 entries.
-- Use `pcre.clear_cache()` when you need to free the cache proactively.
-- Non-hashable pattern objects skip the cache and are compiled each time.
-
-## Default flags for text patterns
-- String patterns enable `Flag.UTF` and `Flag.UCP` automatically so behaviour matches `re`.
-- Byte patterns keep both flags disabled; opt in manually if Unicode semantics are desired.
-- Explicitly supply `Flag.NO_UTF`/`Flag.NO_UCP` to override the defaults for strings.
-
-## Additional usage notes
-- All top-level helpers (`match`, `search`, `fullmatch`, `finditer`, `findall`) defer to the cached compiler.
-- Compiled `Pattern` objects expose `.pattern`, `.flags`, `.jit`, and `.groupindex` for introspection.
-- Execution helpers accept `pos`, `endpos`, and `options`, allowing you to thread PCRE2 execution flags per call.
-
-## Memory allocation
-- The extension selects the fastest available allocator at import time: it
-  prefers jemalloc, then tcmalloc, and finally falls back to the platform
-  `malloc`. Optional allocators are loaded via `dlopen`, so no additional
-  link flags are required when they are absent.
-- All internal buffers (match data wrappers, JIT stack cache entries, error
-  formatting scratch space) use the chosen allocator; CPython’s `PyMem_*`
-  family is no longer used within the extension.
-- Call `pcre_ext_c.get_allocator()` to inspect which backend is active at
-  runtime.

pcre/__init__.py

@@ -18,6 +18,7 @@
 
 import pcre_ext_c as _backend
 
+
 pcre_ext_c = _backend
 from .cache import get_cache_limit, set_cache_limit
 from .flags import PY_ONLY_FLAG_MEMBERS
@@ -39,9 +40,7 @@
     sub,
     subn,
 )
-
-from .threads import configure_thread_pool, shutdown_thread_pool
-from .threads import configure_threads
+from .threads import configure_thread_pool, configure_threads, shutdown_thread_pool
 
 
 __version__ = getattr(_backend, "__version__", "0.0")

pcre/pcre.py

@@ -13,6 +13,7 @@
 from typing import Any, List
 
 import pcre_ext_c as _pcre2
+
 from .cache import cached_compile
 from .cache import clear_cache as _clear_cache
 from .flags import (

setup.py

@@ -5,17 +5,233 @@
 
 from __future__ import annotations
 
+import os
+import shlex
 import sys
 from pathlib import Path
 
 from setuptools import Extension, setup
 from setuptools.command.build_ext import build_ext
 
+
 ROOT_DIR = Path(__file__).resolve().parent
 if str(ROOT_DIR) not in sys.path:
     sys.path.insert(0, str(ROOT_DIR))
 
-from setup_utils import MODULE_SOURCES, collect_build_config
+import setup_utils
+from setup_utils import (
+    augment_compile_flags,
+    discover_include_dirs,
+    discover_library_dirs,
+    extend_env_paths,
+    extend_unique,
+    find_library_with_brew,
+    find_library_with_ldconfig,
+    find_library_with_pkg_config,
+    has_header,
+    has_library,
+    is_truthy_env,
+    is_windows_platform,
+    locate_library_file,
+    prepare_pcre2_source,
+    run_pkg_config,
+)
+
+
+MODULE_SOURCES = [
+    "pcre_ext/pcre2.c",
+    "pcre_ext/error.c",
+    "pcre_ext/cache.c",
+    "pcre_ext/flag.c",
+    "pcre_ext/util.c",
+    "pcre_ext/memory.c",
+]
+
+PCRE_EXT_DIR = ROOT_DIR / "pcre_ext"
+PCRE2_REPO_URL = "https://github.com/PCRE2Project/pcre2.git"
+PCRE2_TAG = "pcre2-10.46"
+
+LIB_EXTENSIONS = [
+    ".so",
+    ".so.0",
+    ".so.1",
+    ".a",
+    ".dylib",
+    ".sl",
+]
+
+LIBRARY_BASENAME = "libpcre2-8"
+
+LIBRARY_SEARCH_PATTERNS = [
+    f"**/{LIBRARY_BASENAME}.lib",
+    f"**/{LIBRARY_BASENAME}.a",
+    f"**/{LIBRARY_BASENAME}.so",
+    f"**/{LIBRARY_BASENAME}.so.*",
+    f"**/{LIBRARY_BASENAME}.dylib",
+    "**/pcre2-8.lib",
+    "**/pcre2-8.dll",
+    "**/pcre2-8-static.lib",
+    "**/pcre2-8-static.dll",
+]
+
+RUNTIME_LIBRARY_FILES: list[str] = []
+
+setup_utils.configure_environment(
+    pcre_ext_dir=PCRE_EXT_DIR,
+    repo_url=PCRE2_REPO_URL,
+    repo_tag=PCRE2_TAG,
+    lib_extensions=LIB_EXTENSIONS,
+    library_basename=LIBRARY_BASENAME,
+    library_search_patterns=LIBRARY_SEARCH_PATTERNS,
+)
+
+
+def collect_build_config() -> dict[str, list[str] | list[tuple[str, str | None]]]:
+    include_dirs: list[str] = []
+    library_dirs: list[str] = []
+    libraries: list[str] = []
+    extra_compile_args: list[str] = []
+    extra_link_args: list[str] = []
+    define_macros: list[tuple[str, str | None]] = []
+    library_files: list[str] = []
+
+    source_include_dirs, source_library_dirs, source_library_files = prepare_pcre2_source()
+    for directory in source_include_dirs:
+        extend_unique(include_dirs, directory)
+    for directory in source_library_dirs:
+        extend_unique(library_dirs, directory)
+    for path in source_library_files:
+        extend_unique(library_files, path)
+
+    cflags = run_pkg_config("--cflags")
+    libs = run_pkg_config("--libs")
+
+    for flag in cflags:
+        if flag.startswith("-I") and len(flag) > 2:
+            extend_unique(include_dirs, flag[2:])
+        elif flag.startswith("-D") and len(flag) > 2:
+            name_value = flag[2:].split("=", 1)
+            define_macros.append((name_value[0], name_value[1] if len(name_value) > 1 else None))
+        else:
+            extra_compile_args.append(flag)
+
+    for flag in libs:
+        if flag.startswith("-L") and len(flag) > 2:
+            extend_unique(library_dirs, flag[2:])
+        elif flag.startswith("-l") and len(flag) > 2:
+            extend_unique(libraries, flag[2:])
+        else:
+            extra_link_args.append(flag)
+
+    extend_env_paths(include_dirs, "PCRE2_INCLUDE_DIR")
+    extend_env_paths(library_dirs, "PCRE2_LIBRARY_DIR")
+
+    env_lib_path = os.environ.get("PCRE2_LIBRARY_PATH")
+    if env_lib_path:
+        for raw_path in env_lib_path.split(os.pathsep):
+            candidate = raw_path.strip()
+            if not candidate:
+                continue
+            path = Path(candidate)
+            if path.is_file() or any(candidate.endswith(ext) for ext in LIB_EXTENSIONS):
+                extend_unique(library_files, str(path))
+                parent = str(path.parent)
+                if parent:
+                    extend_unique(library_dirs, parent)
+            else:
+                extend_unique(library_dirs, candidate)
+
+    extend_env_paths(libraries, "PCRE2_LIBRARIES")
+
+    if not library_files:
+        for path in find_library_with_pkg_config():
+            extend_unique(library_files, path)
+
+    if not library_files:
+        directory_candidates = [Path(p) for p in library_dirs]
+        directory_candidates.extend(Path(p) for p in discover_library_dirs())
+        for directory in directory_candidates:
+            located = locate_library_file(directory)
+            if located is not None:
+                extend_unique(library_files, str(located))
+                break
+
+    if not library_files:
+        for path in find_library_with_ldconfig():
+            extend_unique(library_files, path)
+
+    if not library_files:
+        for path in find_library_with_brew():
+            extend_unique(library_files, path)
+
+    env_cflags = os.environ.get("PCRE2_CFLAGS")
+    if env_cflags:
+        extra_compile_args.extend(shlex.split(env_cflags))
+
+    env_ldflags = os.environ.get("PCRE2_LDFLAGS")
+    if env_ldflags:
+        extra_link_args.extend(shlex.split(env_ldflags))
+
+    if not is_windows_platform() and not any(flag.startswith("-std=") for flag in extra_compile_args):
+        extra_compile_args.append("-std=c99")
+
+    if not has_header(include_dirs):
+        include_dirs.extend(discover_include_dirs())
+
+    if not has_library(library_dirs):
+        library_dirs.extend(discover_library_dirs())
+
+    runtime_libraries: list[str] = []
+
+    if library_files:
+        for runtime_path in library_files:
+            lower_name = runtime_path.lower()
+            if lower_name.endswith(".dll") or lower_name.endswith(".dylib") or ".so" in Path(runtime_path).name:
+                extend_unique(runtime_libraries, runtime_path)
+
+        linkable_files: list[str] = []
+        for path in library_files:
+            suffix = Path(path).suffix.lower()
+            if suffix == ".dll":
+                continue
+            linkable_files.append(path)
+
+        if linkable_files:
+            libraries = [lib for lib in libraries if lib != "pcre2-8"]
+            for path in linkable_files:
+                extend_unique(extra_link_args, path)
+                parent = str(Path(path).parent)
+                if parent:
+                    extend_unique(library_dirs, parent)
+        elif "pcre2-8" not in libraries:
+            libraries.append("pcre2-8")
+    elif "pcre2-8" not in libraries:
+        libraries.append("pcre2-8")
+
+    if sys.platform.startswith("linux") and "dl" not in libraries:
+        libraries.append("dl")
+
+    if is_windows_platform():
+        has_runtime_dll = any(path.lower().endswith(".dll") for path in runtime_libraries)
+        force_static_env = is_truthy_env("PCRE2_FORCE_STATIC")
+        if (force_static_env or (library_files and not has_runtime_dll)) and not any(
+            macro[0] == "PCRE2_STATIC" for macro in define_macros
+        ):
+            define_macros.append(("PCRE2_STATIC", "1"))
+
+    augment_compile_flags(extra_compile_args)
+
+    RUNTIME_LIBRARY_FILES.clear()
+    RUNTIME_LIBRARY_FILES.extend(runtime_libraries)
+
+    return {
+        "include_dirs": include_dirs,
+        "library_dirs": library_dirs,
+        "libraries": libraries,
+        "extra_compile_args": extra_compile_args,
+        "extra_link_args": extra_link_args,
+        "define_macros": define_macros,
+    }
 
 
 EXTENSION = Extension(