pytest-threadpool 0.3.3__tar.gz → 0.3.5__tar.gz

{pytest_threadpool-0.3.3 → pytest_threadpool-0.3.5}/.github/workflows/ci.yml

@@ -3,6 +3,7 @@ name: CI
 on:
   push:
     branches: [main]
+    tags-ignore: ["v*"]
   pull_request:
     branches: [main]
   workflow_call:
@@ -25,7 +26,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python: ["3.13t", "3.14t", "3.15t"]
+        python: ["3.13", "3.13t", "3.14", "3.14t", "3.15", "3.15t"]
     steps:
       - uses: actions/checkout@v4
         with:
@@ -33,9 +34,23 @@ jobs:
       - uses: astral-sh/setup-uv@v6
       - run: uv python install ${{ matrix.python }}
       - run: uv sync --python ${{ matrix.python }} --group dev
-      - run: uv run --python ${{ matrix.python }} pytest -v --tb=short --cov --cov-branch --cov-report=xml
+      - name: Run tests
+        id: tests
+        env:
+          COVERAGE_PROCESS_START: pyproject.toml
+        run: uv run --python ${{ matrix.python }} coverage run -m pytest -v --tb=short
+      - name: Generate coverage report
+        if: always() && steps.tests.outcome != 'cancelled'
+        run: |
+          uv run --python ${{ matrix.python }} coverage combine
+          uv run --python ${{ matrix.python }} coverage report --format=markdown >> "$GITHUB_STEP_SUMMARY"
+          uv run --python ${{ matrix.python }} coverage xml
+          sed -i 's|<source></source>|<source>.</source>|' coverage.xml
       - name: Upload coverage reports to Codecov
-        if: matrix.python == '3.14t'
+        if: always() && matrix.python == '3.14t' && steps.tests.outcome != 'cancelled'
         uses: codecov/codecov-action@v5
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
+          files: coverage.xml
+          fail_ci_if_error: true
+          verbose: true

pytest_threadpool-0.3.5/.pre-commit-config.yaml

@@ -0,0 +1,17 @@
+repos:
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.15.6
+    hooks:
+      - id: ruff-format
+        args: [--check, src/, tests/]
+      - id: ruff
+        args: [src/, tests/]
+
+  - repo: local
+    hooks:
+      - id: pyright
+        name: pyright
+        entry: uv run pyright src/
+        language: system
+        types: [python]
+        pass_filenames: false

pytest_threadpool-0.3.5/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+
+## 0.3.5
+
+### Fixes
+
+- Fixed crash (KeyError) when a worker thread throws an unexpected exception
+  outside the normal test lifecycle — failures are now reported gracefully
+  instead of taking down the entire test run.
+- `--threadpool` with a non-numeric value (e.g. `--threadpool foo`) now raises
+  a clean `pytest.UsageError` instead of an unhandled `ValueError` traceback.
+- `@parallelizable("children")` applied directly to a test function now emits
+  a warning explaining that functions have no children, instead of being
+  silently ignored.
+
+### Cleanup
+
+- Moved `ParallelScope` import to module top in `_markers.py`, removed
+  misleading circular-import comment.

{pytest_threadpool-0.3.3 → pytest_threadpool-0.3.5}/CONTRIBUTING.md

@@ -13,7 +13,9 @@ This installs a free-threaded Python via uv, syncs all dependencies (including
 dev tools), and sets up a pre-commit hook that runs `ruff format`, `ruff check`,
 and `pyright` before each commit.
 
-> Python 3.13t and 3.14t ship with the GIL disabled by default.
+> Free-threaded builds (3.13t, 3.14t, 3.15t) ship with the GIL disabled and
+> provide true parallelism. Standard builds (3.13, 3.14, 3.15) are also
+> supported — threads work, but the GIL serializes CPU-bound code.
 
 ## Architecture rules
 
@@ -125,9 +127,6 @@ src/pytest_threadpool/
     _runner.py        # ParallelRunner: parallel execution orchestration
     plugin.py         # pytest hook implementations (wiring only)
 
-hooks/
-    pre-commit        # Git pre-commit hook (ruff + pyright)
-
 scripts/
     setup-dev         # One-command dev environment setup
 ```

pytest_threadpool-0.3.5/PKG-INFO

@@ -0,0 +1,228 @@
+Metadata-Version: 2.4
+Name: pytest-threadpool
+Version: 0.3.5
+Summary: Parallel test execution for free-threaded Python builds
+Project-URL: Homepage, https://github.com/pytest-threadpool/pytest-threadpool
+Project-URL: Source, https://github.com/pytest-threadpool/pytest-threadpool
+Project-URL: Issues, https://github.com/pytest-threadpool/pytest-threadpool/issues
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: free-threaded,nogil,parallel,pytest,pytest parallel,testing,threadpool
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.13
+Requires-Dist: pytest<=9.0.2,>=9.0.0
+Description-Content-Type: text/markdown
+
+# pytest-threadpool
+
+[![PyPI - Version](https://img.shields.io/pypi/v/pytest-threadpool)](https://pypi.org/project/pytest-threadpool/)
+[![Python](https://img.shields.io/badge/python-3.13%20%7C%203.13t%20%7C%203.14%20%7C%203.14t%20%7C%203.15%20%7C%203.15t-blue?logo=python&logoColor=white)](https://pypi.org/project/pytest-threadpool/)
+[![License](https://img.shields.io/github/license/pytest-threadpool/pytest-threadpool)](https://github.com/pytest-threadpool/pytest-threadpool/blob/main/LICENSE)
+[![GitHub](https://img.shields.io/badge/GitHub-pytest--threadpool-blue?logo=github)](https://github.com/pytest-threadpool/pytest-threadpool)
+[![CI](https://github.com/pytest-threadpool/pytest-threadpool/actions/workflows/ci.yml/badge.svg)](https://github.com/pytest-threadpool/pytest-threadpool/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/pytest-threadpool/pytest-threadpool/branch/main/graph/badge.svg)](https://codecov.io/gh/pytest-threadpool/pytest-threadpool)
+
+**Status: Beta** · Parallel test execution using threads.
+
+Runs test *bodies*, function-scoped fixture setup, and function-scoped fixture
+teardown concurrently in a thread pool while keeping shared fixtures
+(module/class/session scope) sequential.
+
+Works on any Python 3.13+. Free-threaded builds (3.13t, 3.14t, 3.15t) get true
+parallelism for CPU-bound tests. Standard builds still benefit from parallel
+execution of I/O-bound tests (network, database, file operations).
+
+## Installation
+
+```bash
+pip install pytest-threadpool
+```
+
+## Quick start
+
+```bash
+pytest --threadpool auto
+```
+
+Mark tests for parallel execution:
+
+```python
+from pytest_threadpool import parallelizable, not_parallelizable
+
+import pytest
+
+
+@parallelizable("children")  # all nested tests run in parallel
+class TestMyFeature:
+  def test_a(self): ...
+
+  def test_b(self): ...
+
+
+@parallelizable("parameters")  # parametrized variants run in parallel
+@pytest.mark.parametrize("x", [1, 2, 3])
+def test_with_params(x): ...
+
+
+@parallelizable("all")  # children + parameters combined
+class TestEverything:
+  @pytest.mark.parametrize("n", [1, 2])
+  def test_param(self, n): ...
+
+  def test_plain(self): ...
+
+
+@not_parallelizable  # opt out of inherited parallelism
+def test_must_be_sequential(): ...
+```
+
+## Scopes
+
+| Scope        | Effect                                                            |
+|--------------|-------------------------------------------------------------------|
+| `children`   | All nested tests run concurrently (children, grandchildren, etc.) |
+| `parameters` | Parametrized variants of the same test run concurrently           |
+| `all`        | Combines `children` + `parameters`                                |
+
+## Fixture handling
+
+Function-scoped fixtures are cloned per-item and set up in parallel alongside
+test calls. Each worker gets independent fixture instances — no shared mutable
+state between concurrent fixture setups.
+
+Shared fixtures (module, class, and session scope) are resolved once
+sequentially before workers launch and served from cache to all items.
+
+| Scope      | Behavior                                                |
+|------------|---------------------------------------------------------|
+| `function` | Cloned per-item, setup and teardown in parallel workers |
+| `class`    | Resolved once, cached, shared across items              |
+| `module`   | Resolved once, cached, shared across items              |
+| `session`  | Resolved once, cached, shared across items              |
+
+Shared fixture teardown runs sequentially after the parallel group completes.
+
+## Marker levels
+
+Markers can be applied at function, class, module (`pytestmark`), or
+package (`__init__.py` `pytestmark`) level. Priority (most specific wins):
+
+```
+not_parallelizable > own marker > class > module > package
+```
+
+## Shared state between tests
+
+Unlike `pytest-xdist`, which uses subprocesses and requires all test data to
+be pickleable, `pytest-threadpool` runs tests in threads within a **single
+process**. This means tests can share common non-pickleable, thread-safe
+objects — both within a parallel group and across sequential groups:
+
+```python
+import threading
+import pytest
+
+
+class SharedState:
+  lock = threading.Lock()  # not pickleable
+  event = threading.Event()  # not pickleable
+  results = {}
+
+
+@pytest.mark.parallelizable("children")
+class TestGroupA:
+  def test_a1(self):
+    with SharedState.lock:
+      SharedState.results["a1"] = True
+
+  def test_a2(self):
+    with SharedState.lock:
+      SharedState.results["a2"] = True
+
+
+@pytest.mark.parallelizable("children")
+class TestGroupB:
+  def test_b1(self):
+    SharedState.event.set()
+    with SharedState.lock:
+      SharedState.results["b1"] = True
+
+  def test_b2(self):
+    assert SharedState.event.wait(timeout=10)
+    with SharedState.lock:
+      SharedState.results["b2"] = True
+```
+
+Objects like `threading.Lock`, `threading.Event`, `logging.Logger`, database
+connections, and other non-pickleable resources can live as class attributes
+and be accessed freely from any test — parallel or sequential — without
+serialization overhead or workarounds.
+
+## Usage
+
+```bash
+# Auto-detect thread count
+pytest --threadpool auto
+
+# Fixed thread count
+pytest --threadpool 8
+
+# Normal sequential run (no flag)
+pytest
+```
+
+## Tested versions
+
+| Component | Versions                              |
+|-----------|---------------------------------------|
+| Python    | 3.13, 3.13t, 3.14, 3.14t, 3.15, 3.15t |
+| pytest    | 9.0.2                                 |
+
+> **Note:** On standard (GIL-enabled) builds, the GIL limits parallel speedup
+> for CPU-bound tests. I/O-bound tests still run concurrently.
+
+## Examples
+
+The [`examples/`](examples/) directory contains runnable usage patterns:
+
+- **DI container** — dependency injection with Singleton, ThreadLocal, ContextLocal, and Factory scopes
+- **Event bus** — shared in-memory test double with concurrent producers and aggregate verification
+- **Parallel logging** — shared thread-safe log collector (caplog alternative)
+- **Shared state** — barriers, atomic counters, and cross-group coordination
+- **User pool** — custom thread pool with LIFO queue recycling
+
+The [`tests/integration_tests/cases/`](tests/integration_tests/cases/) and
+[`tests/integration_tests/`](tests/integration_tests/) directories are also
+worth browsing for real-world grouping, fixture, and reporting scenarios.
+
+## Known limitations
+
+- **Private pytest API usage** — The plugin relies on internal `_pytest` APIs
+  (fixture finalizers, setup state, terminal writer) that have no public
+  equivalents. These may break across pytest releases without warning.
+- **No plugin compatibility guarantees** — Interactions with other pytest
+  plugins (e.g. `pytest-xdist`, `pytest-timeout`, `pytest-randomly`) are
+  untested and may conflict.
+- **No `capsys`/`capfd`/`caplog` in parallel** — These fixtures are not
+  thread-safe. `capsys`/`capfd` fail with "cannot use capsys and capsys at
+  the same time" when requested by parallel tests. `caplog` leaks records
+  across fixtures and its `at_level()` context managers race on the shared
+  root logger. Alternatives:
+  - **`print()`** — Worker output is suppressed by default (buffered by
+    thread-local stream proxies). Pass `-s` (`--capture=no`) to disable
+    suppression and see interleaved output.
+  - **Logging** — Use a per-test `FileHandler` writing to `tmp_path`, or
+    collect structured records in a shared thread-safe list (see
+    [`examples/test_logging/`](examples/test_logging/)).
+
+## License
+
+[Apache 2.0](LICENSE)

pytest_threadpool-0.3.3/PKG-INFO → pytest_threadpool-0.3.5/README.md

@@ -1,35 +1,22 @@
-Metadata-Version: 2.4
-Name: pytest-threadpool
-Version: 0.3.3
-Summary: Parallel test execution for free-threaded Python builds
-License-Expression: MIT
-License-File: LICENSE
-Keywords: free-threaded,nogil,parallel,pytest,pytest parallel,testing,threadpool
-Classifier: Development Status :: 4 - Beta
-Classifier: Framework :: Pytest
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Topic :: Software Development :: Testing
-Requires-Python: >=3.13
-Requires-Dist: pytest>=9.0.2
-Description-Content-Type: text/markdown
-
 # pytest-threadpool
 
 [![PyPI - Version](https://img.shields.io/pypi/v/pytest-threadpool)](https://pypi.org/project/pytest-threadpool/)
-[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pytest-threadpool)](https://pypi.org/project/pytest-threadpool/)
+[![Python](https://img.shields.io/badge/python-3.13%20%7C%203.13t%20%7C%203.14%20%7C%203.14t%20%7C%203.15%20%7C%203.15t-blue?logo=python&logoColor=white)](https://pypi.org/project/pytest-threadpool/)
 [![License](https://img.shields.io/github/license/pytest-threadpool/pytest-threadpool)](https://github.com/pytest-threadpool/pytest-threadpool/blob/main/LICENSE)
 [![GitHub](https://img.shields.io/badge/GitHub-pytest--threadpool-blue?logo=github)](https://github.com/pytest-threadpool/pytest-threadpool)
 [![CI](https://github.com/pytest-threadpool/pytest-threadpool/actions/workflows/ci.yml/badge.svg)](https://github.com/pytest-threadpool/pytest-threadpool/actions/workflows/ci.yml)
 [![codecov](https://codecov.io/gh/pytest-threadpool/pytest-threadpool/branch/main/graph/badge.svg)](https://codecov.io/gh/pytest-threadpool/pytest-threadpool)
 
-**Status: Beta** · Parallel test execution for free-threaded Python builds (3.13t+).
+**Status: Beta** · Parallel test execution using threads.
 
 Runs test *bodies*, function-scoped fixture setup, and function-scoped fixture
 teardown concurrently in a thread pool while keeping shared fixtures
 (module/class/session scope) sequential.
 
+Works on any Python 3.13+. Free-threaded builds (3.13t, 3.14t, 3.15t) get true
+parallelism for CPU-bound tests. Standard builds still benefit from parallel
+execution of I/O-bound tests (network, database, file operations).
+
 ## Installation
 
 ```bash
@@ -49,22 +36,28 @@ from pytest_threadpool import parallelizable, not_parallelizable
 
 import pytest
 
-@parallelizable("children")     # all nested tests run in parallel
+
+@parallelizable("children")  # all nested tests run in parallel
 class TestMyFeature:
-    def test_a(self): ...
-    def test_b(self): ...
+  def test_a(self): ...
+
+  def test_b(self): ...
 
-@parallelizable("parameters")   # parametrized variants run in parallel
+
+@parallelizable("parameters")  # parametrized variants run in parallel
 @pytest.mark.parametrize("x", [1, 2, 3])
 def test_with_params(x): ...
 
-@parallelizable("all")          # children + parameters combined
+
+@parallelizable("all")  # children + parameters combined
 class TestEverything:
-    @pytest.mark.parametrize("n", [1, 2])
-    def test_param(self, n): ...
-    def test_plain(self): ...
+  @pytest.mark.parametrize("n", [1, 2])
+  def test_param(self, n): ...
+
+  def test_plain(self): ...
 
-@not_parallelizable             # opt out of inherited parallelism
+
+@not_parallelizable  # opt out of inherited parallelism
 def test_must_be_sequential(): ...
 ```
 
@@ -85,8 +78,8 @@ state between concurrent fixture setups.
 Shared fixtures (module, class, and session scope) are resolved once
 sequentially before workers launch and served from cache to all items.
 
-| Scope      | Behavior                                        |
-|------------|-------------------------------------------------|
+| Scope      | Behavior                                                |
+|------------|---------------------------------------------------------|
 | `function` | Cloned per-item, setup and teardown in parallel workers |
 | `class`    | Resolved once, cached, shared across items              |
 | `module`   | Resolved once, cached, shared across items              |
@@ -116,33 +109,33 @@ import pytest
 
 
 class SharedState:
-    lock = threading.Lock()          # not pickleable
-    event = threading.Event()        # not pickleable
-    results = {}
+  lock = threading.Lock()  # not pickleable
+  event = threading.Event()  # not pickleable
+  results = {}
 
 
 @pytest.mark.parallelizable("children")
 class TestGroupA:
-    def test_a1(self):
-        with SharedState.lock:
-            SharedState.results["a1"] = True
+  def test_a1(self):
+    with SharedState.lock:
+      SharedState.results["a1"] = True
 
-    def test_a2(self):
-        with SharedState.lock:
-            SharedState.results["a2"] = True
+  def test_a2(self):
+    with SharedState.lock:
+      SharedState.results["a2"] = True
 
 
 @pytest.mark.parallelizable("children")
 class TestGroupB:
-    def test_b1(self):
-        SharedState.event.set()
-        with SharedState.lock:
-            SharedState.results["b1"] = True
-
-    def test_b2(self):
-        assert SharedState.event.wait(timeout=10)
-        with SharedState.lock:
-            SharedState.results["b2"] = True
+  def test_b1(self):
+    SharedState.event.set()
+    with SharedState.lock:
+      SharedState.results["b1"] = True
+
+  def test_b2(self):
+    assert SharedState.event.wait(timeout=10)
+    with SharedState.lock:
+      SharedState.results["b2"] = True
 ```
 
 Objects like `threading.Lock`, `threading.Event`, `logging.Logger`, database
@@ -165,10 +158,27 @@ pytest
 
 ## Tested versions
 
-| Component | Versions |
-|-----------|----------|
-| Python    | 3.13t, 3.14t, 3.15t |
-| pytest    | >=9.0.2 |
+| Component | Versions                              |
+|-----------|---------------------------------------|
+| Python    | 3.13, 3.13t, 3.14, 3.14t, 3.15, 3.15t |
+| pytest    | 9.0.2                                 |
+
+> **Note:** On standard (GIL-enabled) builds, the GIL limits parallel speedup
+> for CPU-bound tests. I/O-bound tests still run concurrently.
+
+## Examples
+
+The [`examples/`](examples/) directory contains runnable usage patterns:
+
+- **DI container** — dependency injection with Singleton, ThreadLocal, ContextLocal, and Factory scopes
+- **Event bus** — shared in-memory test double with concurrent producers and aggregate verification
+- **Parallel logging** — shared thread-safe log collector (caplog alternative)
+- **Shared state** — barriers, atomic counters, and cross-group coordination
+- **User pool** — custom thread pool with LIFO queue recycling
+
+The [`tests/integration_tests/cases/`](tests/integration_tests/cases/) and
+[`tests/integration_tests/`](tests/integration_tests/) directories are also
+worth browsing for real-world grouping, fixture, and reporting scenarios.
 
 ## Known limitations
 
@@ -178,10 +188,18 @@ pytest
 - **No plugin compatibility guarantees** — Interactions with other pytest
   plugins (e.g. `pytest-xdist`, `pytest-timeout`, `pytest-randomly`) are
   untested and may conflict.
-- **No captured stdout in parallel** — Standard output from tests running
-  concurrently is written directly to the terminal. Pytest's built-in capture
-  (`capsys`/`capfd`) is not supported during parallel execution.
+- **No `capsys`/`capfd`/`caplog` in parallel** — These fixtures are not
+  thread-safe. `capsys`/`capfd` fail with "cannot use capsys and capsys at
+  the same time" when requested by parallel tests. `caplog` leaks records
+  across fixtures and its `at_level()` context managers race on the shared
+  root logger. Alternatives:
+  - **`print()`** — Worker output is suppressed by default (buffered by
+    thread-local stream proxies). Pass `-s` (`--capture=no`) to disable
+    suppression and see interleaved output.
+  - **Logging** — Use a per-test `FileHandler` writing to `tmp_path`, or
+    collect structured records in a shared thread-safe list (see
+    [`examples/test_logging/`](examples/test_logging/)).
 
 ## License
 
-MIT
+[Apache 2.0](LICENSE)

pytest_threadpool-0.3.5/ROADMAP.md

@@ -0,0 +1,83 @@
+# Roadmap
+
+## Capture fixture support (capsys / capfd / caplog)
+
+**Goal:** Make `capsys`, `capfd`, and `caplog` work transparently in parallel tests.
+
+**Problem:** These fixtures assume exclusive ownership of global state (`sys.stdout`,
+root logger) during a test's lifetime. When multiple tests run concurrently, output
+interleaves and pytest raises "cannot use capsys and capsys at the same time".
+`caplog` leaks records across tests, and `at_level()` context managers race on the
+shared root logger.
+
+**Approach:** Delayed replay — collect output per-worker during parallel execution,
+then feed it back one item at a time during the sequential reporting phase.
+
+- **capsys/capfd:** The `_ThreadLocalStream` proxy already buffers worker output
+  into per-thread `StringIO`. Instead of discarding on `deactivate()`, associate
+  each buffer with its test item and flush to the real stream before
+  `pytest_runtest_makereport` reads the capture.
+
+- **caplog:** Install a per-thread `logging.Handler` that collects records into a
+  thread-local list. During sequential reporting, replay records into caplog's
+  handler so the fixture sees the correct records for each test.
+
+**Edge cases to handle:**
+- Nested captures (fixtures that call `capsys.readouterr()` mid-test)
+- `caplog.at_level()` context managers across threads
+- Fixtures that mix capsys with print output
+- `capfd` (file descriptor level) vs `capsys` (sys.stdout level)
+
+**Priority:** High — this is the most common friction point for adoption.
+
+## Harden FixtureDef cloning
+
+**Goal:** Make function-scoped fixture cloning more robust against pytest internals
+changes and more transparent to developers.
+
+**Current approach:** `clone_function_fixturedefs` uses `__new__` + `__dict__.update`
+for a shallow copy, then resets `cached_result` and `_finalizers`. This works because
+those are the only two fields mutated during fixture lifecycle — but it's fragile.
+
+**Improvements:**
+
+- **Deep-copy guard:** Validate at clone time that the only mutable fields are the
+  ones we reset. If a future pytest version adds mutable state to `FixtureDef`,
+  the clone should fail loudly (assertion or warning) rather than silently sharing
+  state across workers.
+
+- **Document fixture chain isolation:** When fixture A (function-scoped) depends on
+  fixture B (also function-scoped), both get cloned independently. Chain resolution
+  works because `_arg2fixturedefs` is replaced as a whole, so `getfixturevalue("B")`
+  hits B's clone. This is correct but non-obvious — add inline comments explaining
+  the chain resolution path through the cloned map.
+
+- **`object.__setattr__` on `_arg2fixturedefs`:** Currently bypasses the `Final`
+  typing annotation. If pytest ever enforces immutability at runtime (frozen
+  dataclass, `__slots__`), this breaks. Track whether upstream adds a setter or
+  public mutation API.
+
+**Priority:** Medium — current implementation works, but one pytest release could
+break it silently.
+
+## Plugin compatibility testing
+
+Validate and document interactions with commonly used pytest plugins:
+
+- `pytest-randomly` — test reordering vs parallel group formation
+- `pytest-timeout` — per-test timeouts in worker threads
+- `pytest-repeat` — repeated test execution in parallel groups
+- `pytest-cov` — coverage collection across worker threads
+
+## Public pytest API migration
+
+Track pytest releases for public equivalents of internal APIs currently used:
+
+- `_pytest.fixtures.FixtureDef._finalizers`
+- `_pytest.fixtures.FixtureDef.cached_result`
+- `_pytest.setupplan.SetupState.stack`
+- `_pytest.scope.Scope`
+- `callspec._arg2scope`
+
+Migrate to public APIs as they become available to reduce breakage risk
+across pytest releases.

pytest_threadpool-0.3.5/codecov.yml

@@ -0,0 +1,14 @@
+coverage:
+  status:
+    project:
+      default:
+        target: auto
+        threshold: 1%
+    patch:
+      default:
+        target: auto
+
+ignore:
+  - "src/pytest_threadpool/_version.py"
+
+comment: false

pytest_threadpool-0.3.5/examples/__init__.py

@@ -0,0 +1,3 @@
+from pytest_threadpool import parallelizable
+
+pytestmark = parallelizable("all")

pytest_threadpool-0.3.5/examples/test_di/__init__.py

@@ -0,0 +1 @@
+

pytest_threadpool-0.3.5/examples/test_di/conftest.py

@@ -0,0 +1,28 @@
+"""Fixtures resolving from the static DI container.
+
+- ``request_handler`` injects a fresh RequestHandler per test (Factory).
+- ``test_context`` injects a per-test TestContext (ContextLocal, reset per test).
+"""
+
+import pytest
+
+from examples.test_di.container import Container
+
+
+@pytest.fixture
+def request_handler():
+    """Fresh RequestHandler per test (Factory provider)."""
+    return Container.request_handler()
+
+
+@pytest.fixture
+def test_context():
+    """Per-test TestContext — ContextLocal + reset = test-local scope.
+
+    ContextLocal uses contextvars, so the instance follows the execution
+    context — not the OS thread.  Safe across await boundaries.
+    The reset() in teardown gives the next test a fresh instance.
+    """
+    ctx = Container.test_context()
+    yield ctx
+    Container.test_context.reset()