type-assert 0.2.0__tar.gz → 0.2.2__tar.gz

{type_assert-0.2.0 → type_assert-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: type-assert
-Version: 0.2.0
+Version: 0.2.2
 Summary: pytest plugin that checks a value static type and its runtime type in one assertion
 Author: user27182
 License-Expression: MIT

{type_assert-0.2.0 → type_assert-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ requires = ['setuptools>=64', 'setuptools_scm>=8']
 
 [dependency-groups]
 dev = ['pre-commit', 'pytest-cov', { include-group = 'test' }]
-test = ['mypy', 'numpy', 'pyrefly', 'pyright', 'pytest']
+test = ['mypy', 'numpy', 'pyrefly', 'pyright', 'pytest', 'pytest-xdist']
 
 [project]
 authors = [{ name = 'user27182' }]

{type_assert-0.2.0 → type_assert-0.2.2}/tests/test_plugin.py

@@ -164,6 +164,20 @@ def test_a_quoted_type_only_a_checker_can_build_is_checked_statically(project, c
     result.stdout.fnmatch_lines(['*cannot be built at runtime*'])
 
 
+def test_a_case_file_named_on_the_command_line_is_collected_once_as_cases(project):
+    # pytest collects an explicitly named `.py` file as a test module whatever its
+    # name; importing this one would run the quoted assertion at import and fail.
+    result = project(QUOTED_NEVER).runpytest('cases/sample.py', '-rs')
+    result.assert_outcomes(passed=2, skipped=1, errors=0)
+    result.stdout.fnmatch_lines(['*cannot be built at runtime*'])
+
+
+def test_a_case_file_named_on_the_command_line_yields_the_same_tests(project):
+    result = project(CLEAN).runpytest('cases/sample.py', '--collect-only', '-q')
+    result.stdout.fnmatch_lines(['*::setup', '*len([[]1[]]) -> int [[]runtime[]]'])
+    assert result.stdout.str().count('[runtime]') == 2
+
+
 def test_a_quoted_type_the_runtime_can_build_is_held_to_by_both_halves(project):
     source = (
         'from type_assert import assert_types\n\n'
@@ -351,3 +365,12 @@ class TestCheckerConfiguration:
         directory.joinpath('sample.py').write_text(CLEAN, encoding='utf-8')
         result = pytester.runpytest()
         result.stdout.fnmatch_lines(['*mypy failed to run*'])
+
+
+def test_the_checker_runs_once_across_xdist_workers(project):
+    # Each worker would otherwise type-check the cases again, into a cache of its own.
+    pytester = project(CLEAN)
+    result = pytester.runpytest_subprocess('-p', 'xdist', '-n', '2')
+    result.assert_outcomes(passed=5)
+    caches = list((pytester.path / '.mypy_cache').glob('type_assert-*'))
+    assert [path.name for path in caches] == ['type_assert-mypy']

type_assert-0.2.2/tests/test_share.py

@@ -0,0 +1,151 @@
+"""Sharing one checker run between pytest-xdist workers."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from type_assert import CheckerError
+from type_assert import Diagnostic
+from type_assert._share import _decode
+from type_assert._share import _encode
+from type_assert._share import run_once
+from type_assert._share import shared_dir
+
+
+class FakeConfig:
+    """Stands in for the pytest config the sharing helper reads."""
+
+    def __init__(self, basetemp=None, worker=None):
+        """Record what the helper looks for."""
+        if worker is not None:
+            self.workerinput = {'workerid': worker}
+        if basetemp is not None:
+            self._tmp_path_factory = FakeFactory(basetemp)
+
+
+class FakeFactory:
+    """Stands in for pytest's tmp path factory."""
+
+    def __init__(self, basetemp):
+        """Record the base directory."""
+        self._basetemp = basetemp
+
+    def getbasetemp(self):
+        """Return the worker's own temporary directory."""
+        return self._basetemp
+
+
+@pytest.fixture
+def worker(tmp_path):
+    """Return a config that looks like an xdist worker."""
+
+    def _worker(name='gw0'):
+        basetemp = tmp_path / f'popen-{name}'
+        basetemp.mkdir(exist_ok=True)
+        return FakeConfig(basetemp=basetemp, worker=name)
+
+    return _worker
+
+
+DIAGNOSTICS = {Path('/a/b.py'): [Diagnostic(path=Path('/a/b.py'), line=3, message='boom')]}
+
+
+def test_round_trips_diagnostics():
+    assert _decode(json.dumps({'diagnostics': json.loads(_encode(DIAGNOSTICS))})) == DIAGNOSTICS
+
+
+def test_no_shared_directory_without_xdist(tmp_path):
+    assert shared_dir(FakeConfig(basetemp=tmp_path)) is None
+
+
+def test_workers_agree_on_one_directory(worker):
+    assert shared_dir(worker('gw0')) == shared_dir(worker('gw1'))
+
+
+def test_runs_directly_when_not_under_xdist(tmp_path):
+    calls = []
+
+    def run():
+        calls.append(1)
+        return DIAGNOSTICS
+
+    assert run_once(FakeConfig(basetemp=tmp_path), 'mypy', run) == DIAGNOSTICS
+    assert run_once(FakeConfig(basetemp=tmp_path), 'mypy', run) == DIAGNOSTICS
+    # Nothing to share without workers, so it runs every time.
+    assert len(calls) == 2
+
+
+def test_only_the_first_worker_runs_the_checker(worker):
+    calls = []
+
+    def run():
+        calls.append(1)
+        return DIAGNOSTICS
+
+    first = run_once(worker('gw0'), 'mypy', run)
+    second = run_once(worker('gw1'), 'mypy', run)
+    third = run_once(worker('gw2'), 'mypy', run)
+
+    assert first == second == third == DIAGNOSTICS
+    assert len(calls) == 1
+
+
+def test_each_checker_runs_once(worker):
+    calls = []
+
+    def run():
+        calls.append(1)
+        return DIAGNOSTICS
+
+    run_once(worker('gw0'), 'mypy', run)
+    run_once(worker('gw1'), 'pyright', run)
+    run_once(worker('gw2'), 'mypy', run)
+    assert len(calls) == 2
+
+
+def test_a_checker_failure_reaches_the_other_workers(worker):
+    def run():
+        msg = 'mypy failed to run'
+        raise CheckerError(msg)
+
+    with pytest.raises(CheckerError, match='mypy failed to run'):
+        run_once(worker('gw0'), 'mypy', run)
+
+    def unreachable():  # pragma: no cover - the stored failure is raised first
+        raise AssertionError
+
+    with pytest.raises(CheckerError, match='mypy failed to run'):
+        run_once(worker('gw1'), 'mypy', unreachable)
+
+
+def test_an_unexpected_failure_also_reaches_the_other_workers(worker):
+    def run():
+        msg = 'something else'
+        raise RuntimeError(msg)
+
+    with pytest.raises(RuntimeError, match='something else'):
+        run_once(worker('gw0'), 'mypy', run)
+
+    def unreachable():  # pragma: no cover - the stored failure is raised first
+        raise AssertionError
+
+    with pytest.raises(CheckerError, match='RuntimeError: something else'):
+        run_once(worker('gw1'), 'mypy', unreachable)
+
+
+def test_waiting_gives_up_rather_than_hanging(worker, monkeypatch):
+    monkeypatch.setattr('type_assert._share.TIMEOUT', 0.0)
+    config = worker('gw0')
+    # A claim with no result is what a worker killed mid-run leaves behind.
+    directory = shared_dir(config)
+    directory.mkdir(parents=True, exist_ok=True)
+    (directory / 'mypy.claim').mkdir()
+
+    def unreachable():  # pragma: no cover - the wait gives up first
+        raise AssertionError
+
+    with pytest.raises(CheckerError, match='Timed out'):
+        run_once(config, 'mypy', unreachable)

type_assert-0.2.2/type_assert/_share.py

@@ -0,0 +1,105 @@
+"""Run a checker once per session when pytest-xdist spreads the cases over workers."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+import time
+from typing import TYPE_CHECKING
+
+from ._checkers import CheckerError
+from ._checkers import Diagnostic
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    import pytest
+
+#: How long a worker waits for whichever worker is running the checker.
+TIMEOUT = 600.0
+POLL = 0.1
+
+
+def shared_dir(config: pytest.Config) -> Path | None:
+    """Return the directory every xdist worker shares, or `None` when not under xdist."""
+    if not hasattr(config, 'workerinput'):
+        return None
+    factory = getattr(config, '_tmp_path_factory', None)
+    if factory is None:  # pragma: no cover - pytest always provides it
+        return None
+    return Path(factory.getbasetemp()).parent / 'type_assert'
+
+
+def _encode(diagnostics: dict[Path, list[Diagnostic]]) -> str:
+    """Return the diagnostics as JSON."""
+    return json.dumps(
+        {
+            str(path): [
+                {'path': str(item.path), 'line': item.line, 'message': item.message}
+                for item in items
+            ]
+            for path, items in diagnostics.items()
+        }
+    )
+
+
+def _decode(payload: str) -> dict[Path, list[Diagnostic]]:
+    """Return the diagnostics read back from JSON."""
+    stored = json.loads(payload)
+    if 'error' in stored:
+        raise CheckerError(stored['error'])
+    return {
+        Path(path): [
+            Diagnostic(path=Path(item['path']), line=item['line'], message=item['message'])
+            for item in items
+        ]
+        for path, items in stored['diagnostics'].items()
+    }
+
+
+def run_once(
+    config: pytest.Config, name: str, run: Callable[[], dict[Path, list[Diagnostic]]]
+) -> dict[Path, list[Diagnostic]]:
+    """Return `run()`, calling it in only one xdist worker and sharing the result.
+
+    Without xdist, or if the workers cannot agree on a directory, `run` is called
+    directly.
+    """
+    directory = shared_dir(config)
+    if directory is None:
+        return run()
+
+    directory.mkdir(parents=True, exist_ok=True)
+    result = directory / f'{name}.json'
+    claim = directory / f'{name}.claim'
+    deadline = time.monotonic() + TIMEOUT
+
+    while True:
+        if result.is_file():
+            return _decode(result.read_text(encoding='utf-8'))
+        try:
+            claim.mkdir()
+        except FileExistsError:
+            if time.monotonic() > deadline:
+                msg = f'Timed out waiting {TIMEOUT:.0f}s for another worker to run {name}.'
+                raise CheckerError(msg) from None
+            time.sleep(POLL)
+            continue
+
+        try:
+            diagnostics = run()
+        except CheckerError as error:
+            _publish(result, json.dumps({'error': str(error)}))
+            raise
+        except BaseException as error:
+            _publish(result, json.dumps({'error': f'{type(error).__name__}: {error}'}))
+            raise
+        _publish(result, json.dumps({'diagnostics': json.loads(_encode(diagnostics))}))
+        return diagnostics
+
+
+def _publish(result: Path, payload: str) -> None:
+    """Write `payload` where the other workers will find it, in one step."""
+    pending = result.with_suffix('.pending')
+    pending.write_text(payload, encoding='utf-8')
+    pending.replace(result)

{type_assert-0.2.0 → type_assert-0.2.2}/type_assert/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.2.0'
-__version_tuple__ = version_tuple = (0, 2, 0)
+__version__ = version = '0.2.2'
+__version_tuple__ = version_tuple = (0, 2, 2)
 
-__commit_id__ = commit_id = 'gd0866227d'
+__commit_id__ = commit_id = 'g1137e2bda'

{type_assert-0.2.0 → type_assert-0.2.2}/type_assert/plugin.py

@@ -23,6 +23,7 @@ from ._cases import CaseSkipped
 from ._cases import collect_case_file
 from ._checkers import CHECKERS
 from ._checkers import get_checker
+from ._share import run_once
 
 if TYPE_CHECKING:
     from ._cases import Case
@@ -85,14 +86,34 @@ def cases_dir(config: pytest.Config) -> Path | None:
     return (Path(config.rootpath) / configured).resolve()
 
 
+def _is_case_file(file_path: Path, config: pytest.Config) -> bool:
+    """Tell whether `file_path` is a `.py` file in the configured cases directory."""
+    directory = cases_dir(config)
+    return directory is not None and file_path.suffix == '.py' and file_path.parent == directory
+
+
 def pytest_collect_file(file_path: Path, parent: pytest.Collector):
     """Collect a `.py` file in the configured cases directory as a case file."""
-    directory = cases_dir(parent.config)
-    if directory is None or file_path.suffix != '.py' or file_path.parent != directory:
+    # A path named on the command line reaches `pytest_pycollect_makemodule` below,
+    # which is where pytest's own Python collector would otherwise pick it up.
+    if not _is_case_file(file_path, parent.config) or parent.session.isinitpath(file_path):
         return None
     return CaseFileCollector.from_parent(parent, path=file_path)
 
 
+@pytest.hookimpl(tryfirst=True)
+def pytest_pycollect_makemodule(module_path: Path, parent: pytest.Collector):
+    """Collect a case file named on the command line as a case file, not a module.
+
+    pytest collects any `.py` path it is given explicitly as a test module whatever
+    its name, which would import the case file and run every assertion at import.
+    Answering this hook first hands the file to the case file collector instead.
+    """
+    if not _is_case_file(module_path, parent.config):
+        return None
+    return CaseFileCollector.from_parent(parent, path=module_path)
+
+
 def _diagnostics(config: pytest.Config, checker_name: str) -> dict[Path, list[Diagnostic]]:
     """Run one checker once per session and cache its result on the config."""
     cache = getattr(config, _DIAGNOSTICS, None)
@@ -104,15 +125,17 @@ def _diagnostics(config: pytest.Config, checker_name: str) -> dict[Path, list[Di
         assert directory is not None  # only reachable from a collected case file
         root = Path(config.rootpath)
         checker = get_checker(checker_name)
-        # A cache directory per checker and per xdist worker: the run is cheap once
-        # warm, and sharing one between concurrent workers is what makes it stale.
-        worker = getattr(config, 'workerinput', {}).get('workerid', 'master')
-        cache[checker_name] = checker.run(
-            '.'.join(directory.relative_to(root).parts),
-            root=root,
-            cache_dir=root / '.mypy_cache' / f'type_assert-{checker_name}-{worker}',
-            extra_args=[str(arg) for arg in config.getini(checker_args_ini(checker_name))],
-        )
+
+        def run() -> dict[Path, list[Diagnostic]]:
+            """Type-check the cases with this checker."""
+            return checker.run(
+                '.'.join(directory.relative_to(root).parts),
+                root=root,
+                cache_dir=root / '.mypy_cache' / f'type_assert-{checker_name}',
+                extra_args=[str(arg) for arg in config.getini(checker_args_ini(checker_name))],
+            )
+
+        cache[checker_name] = run_once(config, checker_name, run)
     return cache[checker_name]
 
 

{type_assert-0.2.0 → type_assert-0.2.2}/type_assert.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: type-assert
-Version: 0.2.0
+Version: 0.2.2
 Summary: pytest plugin that checks a value static type and its runtime type in one assertion
 Author: user27182
 License-Expression: MIT

{type_assert-0.2.0 → type_assert-0.2.2}/type_assert.egg-info/SOURCES.txt

@@ -11,11 +11,13 @@ tests/test_assertions.py
 tests/test_cases.py
 tests/test_checkers.py
 tests/test_plugin.py
+tests/test_share.py
 tools/check_without_checker.py
 type_assert/__init__.py
 type_assert/_assertions.py
 type_assert/_cases.py
 type_assert/_exact.py
+type_assert/_share.py
 type_assert/_version.py
 type_assert/plugin.py
 type_assert/py.typed

{type_assert-0.2.0 → type_assert-0.2.2}/type_assert.egg-info/scm_file_list.json

@@ -13,6 +13,7 @@
     "tests/test_cases.py",
     "tests/test_checkers.py",
     "tests/test_plugin.py",
+    "tests/test_share.py",
     "tools/check_without_checker.py",
     "type_assert/__init__.py",
     "type_assert/_assertions.py",
@@ -23,6 +24,7 @@
     "type_assert/_checkers/_pyrefly.py",
     "type_assert/_checkers/_pyright.py",
     "type_assert/_exact.py",
+    "type_assert/_share.py",
     "type_assert/plugin.py",
     "type_assert/py.typed"
   ]

{type_assert-0.2.0 → type_assert-0.2.2}/type_assert.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.2.0",
+  "tag": "0.2.2",
   "distance": 0,
-  "node": "gd0866227dda697e3746b9f598708149b1e630bc0",
+  "node": "g1137e2bda7f3404391196296360e318d223606ec",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-05"