pytest-threadpool 0.3.0__tar.gz → 0.3.4__tar.gz

{pytest_threadpool-0.3.0 → pytest_threadpool-0.3.4}/.github/workflows/ci.yml

@@ -3,14 +3,18 @@ name: CI
 on:
   push:
     branches: [main]
+    tags-ignore: ["v*"]
   pull_request:
     branches: [main]
+  workflow_call:
 
 jobs:
   lint:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
       - uses: astral-sh/setup-uv@v6
       - run: uv sync --python 3.14t --group dev
       - run: uv run ruff format --check src/ tests/
@@ -22,9 +26,11 @@ 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:
+          fetch-depth: 0
       - uses: astral-sh/setup-uv@v6
       - run: uv python install ${{ matrix.python }}
       - run: uv sync --python ${{ matrix.python }} --group dev

pytest_threadpool-0.3.4/.github/workflows/publish.yml

@@ -0,0 +1,25 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags: ["v*"]
+
+jobs:
+  ci:
+    uses: ./.github/workflows/ci.yml
+    secrets: inherit
+
+  publish:
+    needs: ci
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: astral-sh/setup-uv@v6
+      - run: uv build
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

{pytest_threadpool-0.3.0 → pytest_threadpool-0.3.4}/.gitignore

@@ -163,3 +163,6 @@ cython_debug/
 .idea/
 uv.lock
 
+# hatch-vcs generated version file
+src/pytest_threadpool/_version.py
+

{pytest_threadpool-0.3.0 → pytest_threadpool-0.3.4}/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
 
@@ -40,10 +42,13 @@ Any mutable state needed across tests or across a test run must be held as
 class attributes or instance attributes — never as module-level variables.
 
 ```python
+import threading
+
 # Good
 class TestState:
-    log = {}
-    barrier = threading.Barrier(3, timeout=10)
+  log = {}
+  barrier = threading.Barrier(3, timeout=10)
+
 
 # Bad
 _log = {}
@@ -67,9 +72,11 @@ subprocess with the exact thread count needed. Use explicit thread counts for
 barrier-based tests (not `auto`) to avoid deadlocks on low-core machines.
 
 ```python
+import threading
+
 # Good — isolated subprocess via ftdir, explicit thread count
 def test_children_run_concurrently(self, ftdir):
-    ftdir.makepyfile("""
+  ftdir.makepyfile("""
         import threading, pytest
         @pytest.mark.parallelizable("children")
         class TestBarrier:
@@ -77,16 +84,25 @@ def test_children_run_concurrently(self, ftdir):
             def test_a(self): self.barrier.wait()
             def test_b(self): self.barrier.wait()
     """)
-    result = ftdir.run_pytest("--threadpool", "2")
-    result.assert_outcomes(passed=2)
+  result = ftdir.run_pytest("--threadpool", "2")
+  result.assert_outcomes(passed=2)
+
 
 # Bad — depends on outer runner flags
 class TestBarrier:
-    barrier = threading.Barrier(2, timeout=10)
-    def test_a(self): self.barrier.wait()
-    def test_b(self): self.barrier.wait()
+  barrier = threading.Barrier(2, timeout=10)
+
+  def test_a(self): self.barrier.wait()
+
+  def test_b(self): self.barrier.wait()
 ```
 
+### Use `pytest.fail()` for intentional failures
+
+In test cases that need to intentionally fail (e.g., verifying teardown after
+failure), use `pytest.fail("reason")` instead of `assert False, "reason"`.
+The latter triggers ruff PT015 and B011.
+
 ### Constants over strings
 
 Use `ParallelScope` enum and `_constants` module instead of bare string
@@ -128,18 +144,19 @@ Every commit message starts with one or more tags in brackets:
 
 ### Tags
 
-| Tag | Scope |
-|-----|-------|
-| `[Runner]` | Core parallel execution engine (`_runner.py`, `_fixtures.py`) |
-| `[Markers]` | Marker resolution and grouping (`_markers.py`, `_grouping.py`, `_constants.py`) |
-| `[Report]` | Terminal reporting and display (`_LiveReporter`) |
-| `[Plugin]` | Plugin hooks and CLI options (`plugin.py`) |
-| `[API]` | Public API changes (`_api.py`, `__init__.py`) |
-| `[Test]` | Test additions or changes only |
-| `[Tooling]` | Ruff, pyright, pre-commit, CI, scripts |
-| `[Docs]` | README, CONTRIBUTING, docstrings |
-| `[Refactor]` | Internal restructuring, no behavior change |
-| `[Fix]` | Bug fix — must include issue number if fixing a known issue |
+| Tag          | Scope                                                                           |
+|--------------|---------------------------------------------------------------------------------|
+| `[Runner]`   | Core parallel execution engine (`_runner.py`, `_fixtures.py`)                   |
+| `[Markers]`  | Marker resolution and grouping (`_markers.py`, `_grouping.py`, `_constants.py`) |
+| `[Report]`   | Terminal reporting and display (`_LiveReporter`)                                |
+| `[Plugin]`   | Plugin hooks and CLI options (`plugin.py`)                                      |
+| `[API]`      | Public API changes (`_api.py`, `__init__.py`)                                   |
+| `[Test]`     | Test additions or changes only                                                  |
+| `[Build]`    | CI/CD pipelines, publishing, versioning                                         |
+| `[Tooling]`  | Ruff, pyright, pre-commit, scripts                                              |
+| `[Docs]`     | README, CONTRIBUTING, docstrings                                                |
+| `[Refactor]` | Internal restructuring, no behavior change                                      |
+| `[Fix]`      | Bug fix — must include issue number if fixing a known issue                     |
 
 ### Combining tags
 

{pytest_threadpool-0.3.0 → pytest_threadpool-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest-threadpool
-Version: 0.3.0
+Version: 0.3.4
 Summary: Parallel test execution for free-threaded Python builds
 License-Expression: MIT
 License-File: LICENSE
@@ -10,26 +10,32 @@ Classifier: Framework :: Pytest
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT 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
-Requires-Dist: selenium>=4.41.0
 Description-Content-Type: text/markdown
 
 # pytest-threadpool
 
-![PyPI - Version](https://img.shields.io/pypi/v/pytest-threadpool)
-![PyPI - Python Version](https://img.shields.io/pypi/pyversions/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 for free-threaded Python builds (3.13t+).
+**Status: Beta** · Parallel test execution using threads.
 
-Runs test *bodies* and function-scoped fixture setup concurrently in a thread
-pool while keeping shared fixtures (module/class/session scope) and teardown
-sequential.
+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
 
@@ -88,12 +94,12 @@ sequentially before workers launch and served from cache to all items.
 
 | Scope      | Behavior                                        |
 |------------|-------------------------------------------------|
-| `function` | Cloned per-item, set up in parallel workers     |
-| `class`    | Resolved once, cached, shared across items      |
-| `module`   | Resolved once, cached, shared across items      |
-| `session`  | Resolved once, cached, shared across items      |
+| `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              |
 
-Teardown for all scopes runs sequentially after the parallel group completes.
+Shared fixture teardown runs sequentially after the parallel group completes.
 
 ## Marker levels
 
@@ -168,9 +174,12 @@ pytest
 
 | Component | Versions |
 |-----------|----------|
-| Python    | 3.13t, 3.14t, 3.15t |
+| 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.
+
 ## Known limitations
 
 - **Private pytest API usage** — The plugin relies on internal `_pytest` APIs

{pytest_threadpool-0.3.0 → pytest_threadpool-0.3.4}/README.md

@@ -1,17 +1,21 @@
 # pytest-threadpool
 
-![PyPI - Version](https://img.shields.io/pypi/v/pytest-threadpool)
-![PyPI - Python Version](https://img.shields.io/pypi/pyversions/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 for free-threaded Python builds (3.13t+).
+**Status: Beta** · Parallel test execution using threads.
 
-Runs test *bodies* and function-scoped fixture setup concurrently in a thread
-pool while keeping shared fixtures (module/class/session scope) and teardown
-sequential.
+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
 
@@ -70,12 +74,12 @@ sequentially before workers launch and served from cache to all items.
 
 | Scope      | Behavior                                        |
 |------------|-------------------------------------------------|
-| `function` | Cloned per-item, set up in parallel workers     |
-| `class`    | Resolved once, cached, shared across items      |
-| `module`   | Resolved once, cached, shared across items      |
-| `session`  | Resolved once, cached, shared across items      |
+| `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              |
 
-Teardown for all scopes runs sequentially after the parallel group completes.
+Shared fixture teardown runs sequentially after the parallel group completes.
 
 ## Marker levels
 
@@ -150,9 +154,12 @@ pytest
 
 | Component | Versions |
 |-----------|----------|
-| Python    | 3.13t, 3.14t, 3.15t |
+| 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.
+
 ## Known limitations
 
 - **Private pytest API usage** — The plugin relies on internal `_pytest` APIs

pytest_threadpool-0.3.4/codecov.yml

@@ -0,0 +1,11 @@
+coverage:
+  status:
+    project:
+      default:
+        target: auto
+        threshold: 1%
+    patch:
+      default:
+        target: auto
+
+comment: false

pytest_threadpool-0.3.4/examples/__init__.py

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

pytest_threadpool-0.3.4/examples/test_di/__init__.py

@@ -0,0 +1 @@
+

pytest_threadpool-0.3.4/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()

pytest_threadpool-0.3.4/examples/test_di/container.py

@@ -0,0 +1,44 @@
+"""DI container wiring four provider scopes — pure stdlib, no GIL re-enablement.
+
+- Singleton:      one Config for the entire session
+- ThreadLocal:    one DbConnection per worker thread
+- ContextLocal:   one TestContext per test (survives await, reset between tests)
+- Factory:        fresh RequestHandler every injection
+
+All providers are class attributes — use ``Container.config()`` etc. directly.
+
+.. note::
+
+   The `dependency-injector <https://github.com/ets-labs/python-dependency-injector>`_
+   library offers similar provider scopes, but its C-extension is not marked as
+   free-threaded safe.  On 3.13t+ builds Python will fall back to the GIL-enabled
+   interpreter when it is imported, negating the benefit of free-threaded execution.
+   This example uses pure-stdlib providers to avoid that limitation.
+"""
+
+from examples.test_di.providers import ContextLocal, Factory, Singleton, ThreadLocal
+from examples.test_di.services import Config, DbConnection, RequestHandler, TestContext
+
+
+class Container:
+    config = Singleton(
+        Config,
+        db_url="postgresql://localhost/testdb",
+        pool_size=4,
+    )
+
+    db_connection = ThreadLocal(
+        DbConnection,
+        config=config,
+    )
+
+    test_context = ContextLocal(
+        TestContext,
+        config=config,
+    )
+
+    request_handler = Factory(
+        RequestHandler,
+        db=db_connection,
+        config=config,
+    )

pytest_threadpool-0.3.4/examples/test_di/providers.py

@@ -0,0 +1,104 @@
+"""Pure-stdlib DI providers — no C extensions, no GIL re-enablement.
+
+Four scopes built on threading and contextvars primitives:
+
+- ``Singleton``:        one instance for the process lifetime (thread-safe).
+- ``ThreadLocal``:      one instance per OS thread.
+- ``ContextLocal``:     one instance per execution context (survives await).
+- ``Factory``:          fresh instance on every call.
+"""
+
+import contextlib
+import contextvars
+import threading
+from typing import Any
+
+
+class Singleton:
+    """Thread-safe singleton — one instance for the entire process."""
+
+    def __init__(self, cls: type, **kwargs: Any):
+        self._cls = cls
+        self._kwargs = kwargs
+        self._instance: Any = None
+        self._lock = threading.Lock()
+
+    def __call__(self) -> Any:
+        if self._instance is None:
+            with self._lock:
+                if self._instance is None:
+                    self._instance = self._cls(**self._resolve_kwargs())
+        return self._instance
+
+    def reset(self) -> None:
+        with self._lock:
+            self._instance = None
+
+    def _resolve_kwargs(self) -> dict:
+        return {k: v() if callable(v) else v for k, v in self._kwargs.items()}
+
+
+class ThreadLocal:
+    """Thread-local singleton — one instance per OS thread."""
+
+    def __init__(self, cls: type, **kwargs: Any):
+        self._cls = cls
+        self._kwargs = kwargs
+        self._local = threading.local()
+
+    def __call__(self) -> Any:
+        try:
+            return self._local.instance
+        except AttributeError:
+            self._local.instance = self._cls(**self._resolve_kwargs())
+            return self._local.instance
+
+    def reset(self) -> None:
+        with contextlib.suppress(AttributeError):
+            del self._local.instance
+
+    def _resolve_kwargs(self) -> dict:
+        return {k: v() if callable(v) else v for k, v in self._kwargs.items()}
+
+
+class ContextLocal:
+    """Context-local singleton — one instance per execution context.
+
+    Uses ``contextvars.ContextVar``, so the instance follows the async
+    execution flow across ``await`` boundaries, even if the coroutine
+    resumes on a different OS thread.
+    """
+
+    _SENTINEL = object()
+
+    def __init__(self, cls: type, **kwargs: Any):
+        self._cls = cls
+        self._kwargs = kwargs
+        self._var: contextvars.ContextVar = contextvars.ContextVar(f"_di_{cls.__name__}")
+
+    def __call__(self) -> Any:
+        instance = self._var.get(self._SENTINEL)
+        if instance is self._SENTINEL:
+            instance = self._cls(**self._resolve_kwargs())
+            self._var.set(instance)
+        return instance
+
+    def reset(self) -> None:
+        self._var.set(self._SENTINEL)  # type: ignore[arg-type]
+
+    def _resolve_kwargs(self) -> dict:
+        return {k: v() if callable(v) else v for k, v in self._kwargs.items()}
+
+
+class Factory:
+    """Factory — fresh instance on every call."""
+
+    def __init__(self, cls: type, **kwargs: Any):
+        self._cls = cls
+        self._kwargs = kwargs
+
+    def __call__(self) -> Any:
+        return self._cls(**self._resolve_kwargs())
+
+    def _resolve_kwargs(self) -> dict:
+        return {k: v() if callable(v) else v for k, v in self._kwargs.items()}

pytest_threadpool-0.3.4/examples/test_di/services.py

@@ -0,0 +1,53 @@
+"""Minimal service classes for the DI example."""
+
+import threading
+import uuid
+
+
+class Config:
+    """Application config — intended as a Singleton (shared across all tests)."""
+
+    def __init__(self, db_url: str, pool_size: int):
+        self.db_url = db_url
+        self.pool_size = pool_size
+        self.instance_id = uuid.uuid4()
+
+
+class DbConnection:
+    """Database connection — intended as ThreadLocal (one per worker thread).
+
+    In a real app this would be sqlalchemy.Session, asyncpg.Connection, etc.
+    """
+
+    def __init__(self, config: Config):
+        self.config = config
+        self.instance_id = uuid.uuid4()
+        self.thread_id = threading.current_thread().ident
+
+
+class TestContext:
+    """Per-test context — intended as ContextLocal (one per execution context).
+
+    In a real app this would be a request context, unit-of-work, or
+    transaction that should be the same instance within one test
+    but fresh for each test.  Any function can resolve it from the
+    container without receiving it as a parameter.
+    """
+
+    def __init__(self, config: Config):
+        self.config = config
+        self.instance_id = uuid.uuid4()
+        self.data: dict = {}
+
+
+class RequestHandler:
+    """Request handler — intended as Factory (fresh instance per injection).
+
+    In a real app this would be a use-case, service, or controller object
+    that gets a fresh instance per test / per request.
+    """
+
+    def __init__(self, db: DbConnection, config: Config):
+        self.db = db
+        self.config = config
+        self.instance_id = uuid.uuid4()

pytest_threadpool-0.3.4/examples/test_di/test_factory.py

@@ -0,0 +1,19 @@
+"""Factory scope: fresh RequestHandler for every injection."""
+
+import threading
+from typing import ClassVar
+
+import pytest
+
+
+class TestFactory:
+    """RequestHandler is a Factory — every injection must be a fresh instance."""
+
+    _seen_ids: ClassVar[set] = set()
+    _lock = threading.Lock()
+
+    @pytest.mark.parametrize("_worker", range(6))
+    def test_handler_is_fresh(self, request_handler, _worker):
+        with self._lock:
+            assert request_handler.instance_id not in self._seen_ids, "Factory reused an instance"
+            self._seen_ids.add(request_handler.instance_id)