pytest-boorst 0.1.0a5__py3-none-any.whl

pytest_boorst/__init__.py

@@ -0,0 +1 @@
+"""Optional, experimental acceleration for pytest."""

pytest_boorst/_discovery.py

@@ -0,0 +1,207 @@
+"""Reuse stock directory reports for a narrow, session-local file plan."""
+
+from __future__ import annotations
+
+import hashlib
+import inspect
+from collections import Counter
+from pathlib import Path
+
+from _pytest.main import Dir, Session
+from _pytest.python import Package
+
+MIN_FILES = 32
+_METHODS = (Session.collect, Session._collect_one_node, Dir.collect, Package.collect)
+_METHOD_HASHES = (
+    "059b4635fb9e56688b817887ea750616b10738cb6d29571f5b7721f401dc32d6",
+    "41c0b9cb38ec89c9157f5df1c6d6af9b3986f45de538c02366c5887e63065225",
+    "f314ca1c43aa632c04b5570c9b273419aa848c3dcf9275aa58d6091a8bd36848",
+    "2dc823bfc8facccd8af8e0b2c61363202832efd0feee92d7ebacc8c70e9f1ff8",
+)
+_HOOKS = (
+    "pytest_collect_directory",
+    "pytest_collect_file",
+    "pytest_pycollect_makemodule",
+    "pytest_ignore_collect",
+    "pytest_collectstart",
+    "pytest_make_collect_report",
+    "pytest_collectreport",
+)
+_HOOK_HASHES = {
+    "_pytest.python.pytest_pycollect_makemodule": "942b7cdbbcf74ea989b5b373f8429c1b0570f26c31c3d084330e0c3f6fe83f15",
+    "_pytest.main.Session.pytest_collectstart": "bcd2d6b3082c4a77f602a5453a9e551669491ef8a505ee9f8efab75710de15ac",
+    "_pytest.main.Session.pytest_runtest_logreport": "d3003ff2a48eccec1ec963a0786c4619b1775d95e78dd081a31ccbbe0d5e7473",
+    "_pytest.main.pytest_collect_directory": "681454321faaf96bc7fd65e5eceb0e55b4f4825e63e4bc7c9a4ec971f850d0a6",
+    "_pytest.python.pytest_collect_directory": "7d337767579e97d39cf47b6abe040675a80a967bf39e27e1aa309c3fc4c7372a",
+    "_pytest.python.pytest_collect_file": "8812fc7a1632f71df0f2aaea1e61b011e8293b41166135b9e8561088a7ff22f3",
+    "_pytest.doctest.pytest_collect_file": "674f6e18c5e7e3596fbadd8c77f6f6e78f409fa931e48e3bc113b340ed0596ba",
+    "_pytest.main.pytest_ignore_collect": "7329f1c31d9a480829163bd7d1a3083b3ffe434553edbc2c3ff7a3636b41cf08",
+    "_pytest.runner.pytest_make_collect_report": "dd5756e160df76070b1cdbabf033ce39b5a5392320106eb42409b2bd82022d08",
+    "_pytest.capture.CaptureManager.pytest_make_collect_report": "d2f4f10b82e12a841c41bd07310902cd727c044ac502611f99afd6b8f81de122",
+    "_pytest.fixtures.FixtureManager.pytest_make_collect_report": "29629dfaf02a19320d591003af61b89743f472fb2e370dc23067ee71f0b786d3",
+    "_pytest.cacheprovider.LFPlugin.pytest_collectreport": "52a840fb38a24163aa35e4adea902fe4e1206c19d4b8b51a2984b27c71129bc9",
+    "_pytest.terminal.TerminalReporter.pytest_collectreport": "1e4d932bbc21fa9f4b68e25bdbd0cf5dce6ff8d6c508a19463083dc532e8e946",
+}
+
+
+def _hash(function):
+    return hashlib.sha256(inspect.getsource(function).encode()).hexdigest()
+
+
+def _hooks(config):
+    return tuple(
+        (
+            impl.function,
+            getattr(impl.function, "__code__", None),
+            impl.wrapper,
+            impl.hookwrapper,
+        )
+        for name in _HOOKS
+        for impl in getattr(config.hook, name).get_hookimpls()
+    )
+
+
+def _options(config):
+    return (
+        tuple(config.args),
+        tuple(config.getini("python_files")),
+        tuple(config.option.ignore or ()),
+        tuple(config.option.ignore_glob or ()),
+        config.option.collect_in_virtualenv,
+        getattr(config.option, "doctestmodules", False),
+        tuple(getattr(config.option, "doctestglob", ()) or ()),
+        tuple(
+            getattr(config.option, name, False)
+            for name in ("pyargs", "keepduplicates", "lf", "failedfirst", "debug")
+        ),
+    )
+
+
+def install(session, state):
+    config = session.config
+    state.update(discovery_status="fallback", directory_reuses=0)
+    # ponytail: only large sibling groups; small groups keep stock discovery.
+    if len(config.args) < MIN_FILES or any(
+        getattr(config.option, name, False)
+        for name in (
+            "pyargs",
+            "keepduplicates",
+            "lf",
+            "failedfirst",
+            "doctestmodules",
+            "debug",
+        )
+    ):
+        return
+    try:
+        paths = [Path(arg).absolute() for arg in config.args]
+        groups = Counter(path.parent for path in paths)
+        parents = {parent for parent, count in groups.items() if count >= MIN_FILES}
+        # Overlapping parents rebuild child collectors and change fixture visibility.
+        if not parents or any(
+            parent in groups for child in groups for parent in child.parents
+        ):
+            return
+        if len(set(paths)) != len(paths) or any(
+            "::" in arg
+            or path.suffix != ".py"
+            or path.resolve() != path
+            or not path.is_file()
+            for arg, path in zip(config.args, paths, strict=True)
+        ):
+            return
+        if (
+            (Session.collect, Session._collect_one_node, Dir.collect, Package.collect)
+            != _METHODS
+            or "_collect_one_node" in session.__dict__
+            or tuple(map(_hash, _METHODS)) != _METHOD_HASHES
+        ):
+            return
+        hooks = _hooks(config)
+        for function, _, _, _ in hooks:
+            name = f"{function.__module__}.{function.__qualname__}"
+            if hasattr(function, "__wrapped__") or _hash(function) != _HOOK_HASHES.get(
+                name
+            ):
+                return
+        options = _options(config)
+        plugins = frozenset(config.pluginmanager.get_plugins())
+        codes = tuple(function.__code__ for function in _METHODS)
+    except (OSError, TypeError, AttributeError, ValueError):
+        return
+    original = session._collect_one_node
+    cached = {}
+    validated_epoch = None
+
+    def accelerated(node, handle_dupes=True):
+        nonlocal validated_epoch
+        if (
+            state["discovery_status"] != "active"
+            or Session._collect_one_node is not _METHODS[1]
+        ):
+            state["discovery_status"] = "fallback"
+            restore()
+            return session._collect_one_node(node, handle_dupes)
+        if handle_dupes or type(node) not in (Dir, Package) or node.path not in parents:
+            return original(node, handle_dupes)
+        if session._collection_cache is not validated_epoch:
+            cached.clear()
+            parts = session._initial_parts
+            if len(parts) != len(paths) or any(
+                part.path != path
+                or part.parts
+                or part.parametrization
+                or part.module_name
+                for part, path in zip(parts, paths, strict=True)
+            ):
+                state["discovery_status"] = "fallback"
+            validated_epoch = session._collection_cache
+        if (
+            state["discovery_status"] != "active"
+            or _hooks(config) != hooks
+            or _options(config) != options
+            or frozenset(config.pluginmanager.get_plugins()) != plugins
+            or tuple(function.__code__ for function in _METHODS) != codes
+            or (
+                Session.collect,
+                Session._collect_one_node,
+                Dir.collect,
+                Package.collect,
+            )
+            != _METHODS
+            or "collect" in node.__dict__
+        ):
+            cached.clear()
+            state["discovery_status"] = "fallback"
+            restore()
+            return session._collect_one_node(node, handle_dupes)
+        try:
+            stat = node.path.stat()
+            current = (stat.st_dev, stat.st_ino, stat.st_mtime_ns, stat.st_ctime_ns)
+        except OSError:
+            cached.pop(node, None)
+            return original(node, handle_dupes)
+        entry = cached.get(node)
+        if (
+            entry is not None
+            and session._collection_cache is entry[1]
+            and current == entry[2]
+        ):
+            node.ihook.pytest_collectstart(collector=node)
+            state["directory_reuses"] += 1
+            # This is still a new file argument, not a duplicate argument.
+            return entry[0], False
+        report, duplicate = original(node, handle_dupes)
+        if report.passed:
+            cached[node] = (report, session._collection_cache, current)
+        else:
+            cached.pop(node, None)
+        return report, duplicate
+
+    def restore():
+        if session.__dict__.get("_collect_one_node") is accelerated:
+            del session._collect_one_node
+
+    config.add_cleanup(restore)
+    session._collect_one_node = accelerated
+    state["discovery_status"] = "active"

pytest_boorst/_ids.py

@@ -0,0 +1,29 @@
+"""Python comparison implementation for the parameter ID benchmark."""
+
+from collections import Counter, defaultdict
+
+
+def unique_ids(ids: list[str]) -> list[str]:
+    """Match pytest suffixing while maintaining the live ID counts."""
+    result = list(ids)
+    counts = Counter(ids)
+    if len(counts) == len(ids):
+        return result
+    occupied = counts.copy()
+    suffixes: dict[str, int] = defaultdict(int)
+    for index, value in enumerate(ids):
+        if counts[value] < 2:
+            continue
+        separator = "_" if value and value[-1].isdigit() else ""
+        suffix = suffixes[value]
+        candidate = f"{value}{separator}{suffix}"
+        while candidate in occupied:
+            suffix += 1
+            candidate = f"{value}{separator}{suffix}"
+        occupied[value] -= 1
+        if not occupied[value]:
+            del occupied[value]
+        occupied[candidate] += 1
+        result[index] = candidate
+        suffixes[value] = suffix + 1
+    return result

pytest_boorst/plugin.py

@@ -0,0 +1,161 @@
+"""Opt-in adapters for verified pytest implementations."""
+
+from __future__ import annotations
+
+import hashlib
+import importlib
+import inspect
+import os
+import sys
+import sysconfig
+
+import pytest
+
+try:
+    from _pytest.python import IdMaker
+except ImportError:
+    IdMaker = None
+
+STATE_KEY = pytest.StashKey[dict]() if hasattr(pytest, "StashKey") else None
+MIN_IDS = 64
+_ORIGINAL = getattr(IdMaker, "make_unique_parameterset_ids", None)
+_SOURCE_SHA256 = "6baee487481ac9da41d36fee0c8870f093aab91b9f507434d5c89620ddf588b8"
+
+
+class _ResolvedIds:
+    """Let the original method consume IDs without repeating user callbacks."""
+
+    def __init__(self, maker, ids, strict=None):
+        self.maker = maker
+        self.ids = ids
+        self.strict = strict
+
+    def _resolve_ids(self):
+        return iter(self.ids)
+
+    def _strict_parametrization_ids_enabled(self):
+        if self.strict is not None:
+            return self.strict
+        return self.maker._strict_parametrization_ids_enabled()
+
+    def __getattr__(self, name):
+        return getattr(self.maker, name)
+
+
+def pytest_configure(config):
+    if STATE_KEY is None:
+        return
+    state = {
+        "status": "disabled",
+        "reason": "set PYTEST_BOORST=1 to enable the alpha",
+        "native_calls": 0,
+        "native_ids": 0,
+        "fallback_calls": 0,
+    }
+    config.stash[STATE_KEY] = state
+    if os.environ.get("PYTEST_BOORST") != "1":
+        return
+    state.update(status="fallback", reason="unsupported interpreter or pytest version")
+    if (
+        pytest.__version__ not in {"9.0.2", "9.0.3", "9.1.1"}
+        or sys.implementation.name != "cpython"
+        or not (3, 10) <= sys.version_info[:2] <= (3, 14)
+        or sysconfig.get_config_var("Py_GIL_DISABLED")
+    ):
+        return
+    state["reason"] = "pytest ID method was changed or cannot be verified"
+    if (
+        IdMaker is None
+        or _ORIGINAL is None
+        or getattr(IdMaker, "make_unique_parameterset_ids", None) is not _ORIGINAL
+        or not inspect.isfunction(_ORIGINAL)
+        or hasattr(_ORIGINAL, "__wrapped__")
+        or _ORIGINAL.__module__ != "_pytest.python"
+        or _ORIGINAL.__qualname__ != "IdMaker.make_unique_parameterset_ids"
+    ):
+        return
+    try:
+        source_hash = hashlib.sha256(inspect.getsource(_ORIGINAL).encode()).hexdigest()
+    except (OSError, TypeError):
+        return
+    if source_hash != _SOURCE_SHA256:
+        return
+    state["reason"] = "native extension unavailable"
+    try:
+        native = importlib.import_module("pytest_boorst._native")
+    except (ImportError, OSError):
+        return
+    unique_ids = native.unique_ids
+
+    def accelerated(maker):
+        if maker.config is not config:
+            return _ORIGINAL(maker)
+        # ponytail: small inputs use pytest; revisit the cutoff with real workloads.
+        if len(maker.parametersets) < MIN_IDS:
+            state["fallback_calls"] += 1
+            return _ORIGINAL(maker)
+        ids = list(maker._resolve_ids())
+        if not all(type(value) is str and value.isascii() for value in ids):
+            state["fallback_calls"] += 1
+            return _ORIGINAL(_ResolvedIds(maker, ids))
+        if len(ids) == len(set(ids)):
+            state["fallback_calls"] += 1
+            return ids
+        if maker._strict_parametrization_ids_enabled():
+            state["fallback_calls"] += 1
+            return _ORIGINAL(_ResolvedIds(maker, ids, strict=True))
+        result = unique_ids(ids)
+        state["native_calls"] += 1
+        state["native_ids"] += len(ids)
+        return result
+
+    def restore():
+        if IdMaker.make_unique_parameterset_ids is accelerated:
+            IdMaker.make_unique_parameterset_ids = _ORIGINAL
+
+    config.add_cleanup(restore)
+    IdMaker.make_unique_parameterset_ids = accelerated
+    state.update(status="active", reason="ASCII parameter ID deduplication")
+
+
+def pytest_report_header(config):
+    if STATE_KEY is None:
+        return
+    state = config.stash[STATE_KEY]
+    if state["status"] != "disabled":
+        return f"boorst: {state['status']} ({state['reason']})"
+
+
+@pytest.hookimpl(trylast=True)
+def pytest_sessionstart(session):
+    if (
+        STATE_KEY is None
+        or os.environ.get("PYTEST_BOORST") != "1"
+        or pytest.__version__ != "9.1.1"
+        or sys.platform == "win32"
+        or os.environ.get("PYTEST_DEBUG")
+        or sys.implementation.name != "cpython"
+        or not (3, 10) <= sys.version_info[:2] <= (3, 14)
+        or sysconfig.get_config_var("Py_GIL_DISABLED")
+    ):
+        return
+    from ._discovery import install
+
+    install(session, session.config.stash[STATE_KEY])
+
+
+def pytest_terminal_summary(terminalreporter, config):
+    if STATE_KEY is None:
+        return
+    state = config.stash[STATE_KEY]
+    if state["status"] == "active":
+        terminalreporter.write_line(
+            f"boorst: {state['native_calls']} native ID batches "
+            f"({state['native_ids']} IDs), {state['fallback_calls']} stock batches"
+        )
+    elif state["status"] == "fallback":
+        terminalreporter.write_line(f"boorst: fallback ({state['reason']})")
+    if state.get("directory_reuses"):
+        terminalreporter.write_line(
+            f"boorst: {state['directory_reuses']} directory reports reused"
+        )

pytest_boorst-0.1.0a5.dist-info/METADATA

@@ -0,0 +1,184 @@
+Metadata-Version: 2.4
+Name: pytest-boorst
+Version: 0.1.0a5
+Summary: Experimental Rust-powered acceleration for pytest
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Pytest
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Rust
+Requires-Dist: pytest
+Requires-Python: >=3.10
+Project-URL: Repository, https://github.com/dnikolayev/pytest-boorst
+Project-URL: Issues, https://github.com/dnikolayev/pytest-boorst/issues
+Description-Content-Type: text/markdown
+
+# pytest-boorst
+
+Experimental Rust-powered acceleration for pytest.
+
+This alpha accelerates duplicate parameter-ID bookkeeping and repeated directory
+discovery while pytest keeps control of test collection, fixtures, execution, and
+reporting. Acceleration is opt-in and guarded by a tested pytest version and
+implementation fingerprint. See the [measured results](#performance-evidence).
+
+## Try the alpha
+
+With uv installed, run this command from your project with its test dependencies
+already installed in its virtual environment. It works in POSIX shells and PowerShell:
+
+```sh
+uv run --no-sync https://raw.githubusercontent.com/dnikolayev/pytest-boorst/v0.1.0a5/scripts/try.py
+```
+
+Append your usual pytest arguments, such as `-q tests/`. The launcher installs the
+pinned GitHub release using a compatible wheel and enables Boorst for that pytest
+process. It preserves the existing Python, pytest, dependencies, project configuration,
+and lockfile. An already-installed matching alpha needs no wheel download or reinstallation.
+
+Native wheels cover macOS Intel/ARM64, Windows x86-64/x86/ARM64, and Linux
+glibc/musl on x86-64/x86/ARM64. See the [platform matrix](CONTRIBUTING.md#platform-wheels).
+Other platforms can install the universal Python wheel: it retains the guarded
+directory optimization on supported Linux/macOS environments and uses stock IDs.
+
+Boorst remains disabled for ordinary pytest runs unless `PYTEST_BOORST=1`. Use
+`-p no:boorst` to prevent plugin loading; uninstalling the package restores ordinary
+pytest behavior. The launcher respects plugin-autoload settings.
+
+You can also install the pinned alpha from PyPI with `uv pip install pytest-boorst==0.1.0a5`.
+[GitHub releases](https://github.com/dnikolayev/pytest-boorst/releases) trigger the full CI
+matrix, then publish its tested distributions to PyPI using Trusted Publishing.
+Release assets contain the same wheels, source distribution and SHA-256 manifest.
+
+## Compatibility boundary
+
+The parameter-ID adapter currently accelerates **pytest 9.0.2, 9.0.3, and 9.1.1 on CPython
+3.10–3.14 with the GIL enabled**. It checks the original method's source fingerprint
+before changing it and restores its owned patch at session cleanup. Other pytest versions,
+modified methods, and missing or unloadable native extensions use stock parameter IDs.
+Installation does not require changing an already-installed pytest version.
+On older releases without pytest's Stash API, the plugin falls back quietly.
+
+Only duplicate batches of at least 64 resolved, exact ASCII strings enter Rust.
+Small batches, unique IDs, Unicode, string subclasses, hidden IDs, and strict-ID
+errors use pytest behavior. Pytest still resolves custom IDs and calls user hooks
+exactly once. Unexpected native computation errors propagate rather than rerunning
+callbacks or hiding a bug.
+
+On **pytest 9.1.1, CPython 3.10–3.14, Linux and macOS**, directory discovery can
+reuse successful reports for directories with at least 32 distinct `.py` files
+passed as plain arguments. Groups may be interleaved across several directories;
+smaller groups retain stock discovery. Selected parent directories must not
+contain one another. This Python optimization avoids recreating every
+sibling collector for each requested file. It needs no native extension and does
+not change the arguments, import unrequested tests, or replace file collection.
+
+Directory reuse requires verified stock directory methods and discovery/report
+hooks. Custom discovery/report hooks, modified methods, selectors, duplicate paths, symlinks,
+overlapping parent directories, doctest-module mode, last-failed/failed-first modes, and debug
+tracing use stock discovery. Changed hooks, plugins, or collection options stop
+reuse; changed directory metadata invalidates the report. Windows currently uses
+stock discovery. Plugins inspecting discarded collectors or pytest's private
+collection-cache layout are outside this experimental compatibility boundary.
+
+This uses a narrowly guarded private pytest method. The tested compatibility
+boundary does not establish compatibility with every possible third-party plugin
+or modification of pytest internals. Tests cover ordered IDs, phase outcomes,
+coverage, asyncio, xdist, callbacks, errors, and repeated invocation.
+
+On releases with the Stash API, the header reports activation or fallback.
+The summary reports native ID batches, stock batches, and reused directory reports.
+Counters are per process; xdist workers collect their own batches, so the
+controller can report zero native calls.
+
+## Development
+
+Install uv and Rust, then:
+
+```sh
+uv sync --locked --python 3.14
+uv run --no-sync maturin develop --release --locked
+uv run --no-sync ruff check .
+uv run --no-sync ruff format --check .
+uv run --no-sync pytest
+cargo fmt --check
+cargo clippy --locked --all-targets -- -D warnings
+cargo test --locked --lib
+```
+
+`uv.lock` and `Cargo.lock` pin the development environments. Maturin builds the
+PyO3 extension. GitHub CI installs built wheels and tests Python 3.10–3.14 on Linux,
+plus macOS and Windows smoke coverage, and rebuilds the source distribution.
+The Linux Python 3.12 wheel lane also runs the complete suite and installed-wheel
+smoke checks with pytest 9.0.2 and 9.0.3, and verifies stock fallback on pytest 8.4.2.
+Normal wheel-installation checks preserve pytest 6.2.5 and 7.4.4 in separate
+environments and compare fallback IDs and phase outcomes against stock pytest.
+An independent benchmark job retains raw timings and CPU/memory observations.
+
+## Performance evidence
+
+Measured on Ubuntu 24.04, CPython 3.14.8, pytest 9.1.1 and Boorst 0.1.0a2.
+Times are medians of three fresh **full pytest runs**, including startup,
+collection, fixtures and execution. Percentages use unrounded medians.
+
+| Synthetic workload | Stock pytest | Boorst enabled | Time change |
+| --- | ---: | ---: | ---: |
+| 10,000 duplicate parameter IDs | 8.491 s | 6.685 s | 21.3% less |
+| 10,000 colliding numeric-suffix IDs | 8.291 s | 6.495 s | 21.7% less |
+| 384 explicit sibling test files | 7.755 s | 1.003 s | 87.1% less |
+| 10,000 unique IDs (control) | 6.526 s | 6.511 s | 0.2% less |
+| 8 IDs (control) | 0.244 s | 0.248 s | 1.7% more |
+
+| Optimization | Why it helps |
+| --- | --- |
+| Duplicate-ID bookkeeping | Avoids rebuilding the used-ID set for every collision; PyO3 accelerates the bounded helper. |
+| Directory-report reuse | Reuses a successful sibling-collector listing across file arguments, avoiding repeated scans and collector construction. This optimization uses Python. |
+
+Most ID savings come from the algorithm: the optimized Python comparison took
+6.739 s for duplicate IDs, versus 6.685 s with Rust. The isolated helper took
+6.40 ms in Python and 4.34 ms in Rust; helper timings describe only that component.
+Unique and small controls made zero native calls. Ordinary suites can see little
+benefit or overhead; these synthetic results do not predict overall project CI.
+
+Both harnesses verify exact ordered node IDs, setup/call/teardown outcomes and
+exit codes. The ID harness checks parity before timing; the discovery harness
+includes identical receipt recording during timing and disables bytecode writes
+for both modes. CI requires at least 10% duplicate-workload improvement and 5%
+directory-workload improvement. Separate compatibility tests cover callbacks,
+fixtures, errors, coverage, asyncio, xdist and fallback behavior. Multi-directory
+checks include interleaved groups, directory-local fixtures, syntax errors,
+independent directory invalidation and stock fallback for overlapping groups.
+
+Sources: [ID measurements](benchmarks/results/alpha2-python314-ids-ci.json),
+[directory measurements](benchmarks/results/alpha2-python314-discovery-ci.json), and the
+[successful CI run](https://github.com/dnikolayev/pytest-boorst/actions/runs/37696156274).
+
+Alpha 4 also covers independent sibling groups. A macOS ARM64 / CPython
+3.14.7 / pytest 9.1.1 trial with the universal wheel measured three fresh full runs:
+
+| Additional synthetic workload | Stock pytest | Boorst enabled | Time change |
+| --- | ---: | ---: | ---: |
+| 384 files across four directories | 1.963 s | 0.973 s | 50.4% less |
+
+[Raw measurements](benchmarks/results/alpha4-multiple-directories-local.json)
+record exact ordered-ID, phase and exit-code parity, with 380 directory reuses and
+zero native ID calls per run. This measures the Python discovery optimization.
+Alpha 3 uses stock discovery for this multi-directory plan. CI repeats the four-directory
+workload on Python 3.14.8 and retains its own raw receipt.
+
+The benchmark job uses CPython 3.14.8. Existing projects can keep their own
+Python version; the trial launcher uses their existing environment.
+
+Reproduce with Python 3.14 and a release build:
+
+```sh
+uv sync --locked --python 3.14
+uv run --no-sync maturin develop --release --locked
+uv run --no-sync python benchmarks/run.py --size 10000 --repeats 3
+uv run --no-sync python benchmarks/discovery.py --repeats 3
+uv run --no-sync python benchmarks/discovery.py --directories 4 --repeats 3 --output benchmark-results-multiple-directories.json
+```
+
+See [benchmark methodology](benchmarks/README.md) for detailed compatibility
+controls and earlier public-project measurements.

pytest_boorst-0.1.0a5.dist-info/RECORD

@@ -0,0 +1,9 @@
+pytest_boorst/__init__.py,sha256=V_9FjAHepAeKdccveW3tuEEzkFB_odn7XmVJK6DcYdQ,54
+pytest_boorst/_discovery.py,sha256=FjLRRrk7xvU6i0MPbJ6zKW0ro6hK40ys4cYt-XX0Mb4,8310
+pytest_boorst/_ids.py,sha256=FHVWuqeqzUg4QMmxHSOt5IGN3AFtj9-34Rp0FpXuhoo,984
+pytest_boorst/plugin.py,sha256=4Exm5NJ0Tzd-nahVgnCDyYIkaPOPS79s-l2l2lLolu4,5284
+pytest_boorst-0.1.0a5.dist-info/licenses/LICENSE,sha256=C3b0bJzAQcmo6MKZY7wMWxSBm8wFhozZCQQhF3trN4Y,3521
+pytest_boorst-0.1.0a5.dist-info/WHEEL,sha256=WKk67IZPzp9uSkBO-iWoZzrqp9-AwH7FE9EB8EoJbf4,81
+pytest_boorst-0.1.0a5.dist-info/entry_points.txt,sha256=C-OM76ixrlFiPIKKmGlQ8BBQVTFx90B4N63BsbkUgx4,42
+pytest_boorst-0.1.0a5.dist-info/METADATA,sha256=Lk-KQLNpKvVYkqwjgZM1-v52UlEdAW1pZ5dev1cDnXU,9794
+pytest_boorst-0.1.0a5.dist-info/RECORD,,

pytest_boorst-0.1.0a5.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.12.12
+Root-Is-Purelib: true
+Tag: py3-none-any

pytest_boorst-0.1.0a5.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[pytest11]
+boorst = pytest_boorst.plugin
+

pytest_boorst-0.1.0a5.dist-info/licenses/LICENSE

@@ -0,0 +1,70 @@
+MIT License
+
+Copyright (c) 2026 pytest-boorst contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+Third-party notices
+===================
+
+PyO3 provides the native Python bindings and is used under its MIT license:
+https://github.com/PyO3/pyo3
+
+Copyright (c) 2023-present PyO3 Project and Contributors. https://github.com/PyO3
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+Parameter ID suffix semantics follow pytest, which is distributed under MIT:
+https://github.com/pytest-dev/pytest
+
+Copyright (c) 2004 Holger Krekel and others
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.