pytest-subproc 0.1.0__py3-none-any.whl

pytest_subproc/__init__.py

@@ -0,0 +1,508 @@
+import json
+import os
+import pickle
+import signal
+import subprocess
+import sys
+import tempfile
+import warnings
+
+import pytest
+
+_INI_FORWARD_NAMES = [
+    "asyncio_mode",
+    "asyncio_default_fixture_loop_scope",
+    "xfail_strict",
+    "log_cli",
+]
+
+
+def _forward_ini_overrides(config):
+    overrides = {}
+    for name in _INI_FORWARD_NAMES:
+        try:
+            val = config.getini(name)
+            if val is not None and val != "":
+                if isinstance(val, (list, tuple)):
+                    parts = [str(v) for v in val if v]
+                    val = " ".join(parts) if parts else None
+                elif hasattr(val, "value"):
+                    val = val.value
+                else:
+                    val = str(val)
+                if val is not None and val != "":
+                    overrides[name] = val
+        except (ValueError, KeyError):
+            pass
+    return overrides
+
+
+def _check_skip(item):
+    for marker in item.iter_markers(name="skip"):
+        condition = marker.kwargs.get("condition", True)
+        if callable(condition):
+            if not condition():
+                continue
+        elif not condition:
+            continue
+        reason = marker.kwargs.get(
+            "reason",
+            marker.args[0] if marker.args else "",
+        )
+        return reason
+    for marker in item.iter_markers(name="skipif"):
+        args = marker.args
+        if not args:
+            continue
+        condition = args[0]
+        if callable(condition):
+            if not condition():
+                continue
+        elif not condition:
+            continue
+        return marker.kwargs.get("reason", "")
+    return None
+
+
+def _get_xfail_info(item):
+    for marker in item.iter_markers(name="xfail"):
+        run = marker.kwargs.get("run", True)
+        strict = marker.kwargs.get("strict")
+        if strict is None:
+            strict = item.config.getini("xfail_strict")
+        if strict is None:
+            strict = item.config.getini("strict")
+        raises = marker.kwargs.get("raises", None)
+        if "condition" not in marker.kwargs:
+            conditions = marker.args
+        else:
+            conditions = (marker.kwargs["condition"],)
+        if not conditions:
+            reason = marker.kwargs.get("reason", "")
+            return {
+                "reason": reason,
+                "strict": strict,
+                "raises": raises,
+                "run": run,
+            }
+        for condition in conditions:
+            result = condition() if callable(condition) else condition
+            if result:
+                reason = marker.kwargs.get("reason", "")
+                return {
+                    "reason": reason,
+                    "strict": strict,
+                    "raises": raises,
+                    "run": run,
+                }
+    return None
+
+
+@pytest.hookimpl(tryfirst=True)
+def pytest_runtest_protocol(item, nextitem):
+    if not _should_spawn(item):
+        return None
+
+    reason = _check_skip(item)
+    if reason is not None:
+        item.ihook.pytest_runtest_logstart(
+            nodeid=item.nodeid,
+            location=item.location,
+        )
+        call = pytest.CallInfo.from_call(
+            lambda: pytest.skip(reason),
+            when="setup",
+            reraise=None,
+        )
+        rep = item.ihook.pytest_runtest_makereport(item=item, call=call)
+        item.ihook.pytest_runtest_logreport(report=rep)
+        item.ihook.pytest_runtest_logfinish(
+            nodeid=item.nodeid,
+            location=item.location,
+        )
+        return True
+
+    timeout = _resolve_timeout(item)
+
+    # Cancel pytest-timeout's timeout so its timer does not kill the
+    # parent while we wait for the subprocess.
+    if sys.platform == "win32":
+        _cancel_pytest_timeout(item)
+
+    item.ihook.pytest_runtest_logstart(
+        nodeid=item.nodeid,
+        location=item.location,
+    )
+
+    try:
+        result = run_subprocess_test(item, item.nodeid, timeout)
+    except TimeoutError as exc:
+        msg = str(exc)
+        call = pytest.CallInfo.from_call(
+            lambda: pytest.fail(msg),
+            when="call",
+            reraise=None,
+        )
+        rep = item.ihook.pytest_runtest_makereport(item=item, call=call)
+        item.ihook.pytest_runtest_logreport(report=rep)
+        item.ihook.pytest_runtest_logfinish(
+            nodeid=item.nodeid,
+            location=item.location,
+        )
+        return True
+    except (pytest.fail.Exception, KeyboardInterrupt) as exc:
+        item.ihook.pytest_runtest_logfinish(
+            nodeid=item.nodeid,
+            location=item.location,
+        )
+        msg = str(exc)
+        call = pytest.CallInfo.from_call(
+            lambda: pytest.fail(msg),
+            when="call",
+            reraise=None,
+        )
+        rep = item.ihook.pytest_runtest_makereport(item=item, call=call)
+        item.ihook.pytest_runtest_logreport(report=rep)
+        return True
+    except BaseException:
+        item.ihook.pytest_runtest_logfinish(
+            nodeid=item.nodeid,
+            location=item.location,
+        )
+        raise
+
+    stdout = result.get("_stdout", "")
+    stderr = result.get("_stderr", "")
+
+    if result.get("passed"):
+        call = pytest.CallInfo.from_call(
+            lambda: None,
+            when="call",
+            reraise=None,
+        )
+    elif result.get("xfailed"):
+        exc = result["exception"]
+
+        def _raise_xfail():
+            raise exc
+
+        call = pytest.CallInfo.from_call(
+            _raise_xfail,
+            when="call",
+            reraise=None,
+        )
+    elif "exception" in result:
+        exc = result["exception"]
+        msg = _build_exception_message(exc, stdout, stderr)
+        if msg != str(exc):
+            try:
+                exc.args = (msg, *exc.args[1:])
+            except Exception:
+                pass
+
+        def _raise():
+            raise exc
+
+        call = pytest.CallInfo.from_call(_raise, when="call", reraise=None)
+    else:
+        msg = result.get("message", "Test failed in subprocess")
+        msg = _build_exception_message(Exception(msg), stdout, stderr)
+
+        def _fail():
+            pytest.fail(msg)
+
+        call = pytest.CallInfo.from_call(
+            _fail,
+            when="call",
+            reraise=None,
+        )
+
+    rep = item.ihook.pytest_runtest_makereport(item=item, call=call)
+    item.ihook.pytest_runtest_logreport(report=rep)
+    item.ihook.pytest_runtest_logfinish(
+        nodeid=item.nodeid,
+        location=item.location,
+    )
+    return True
+
+
+@pytest.hookimpl(tryfirst=True, hookwrapper=True)
+def pytest_runtest_makereport(item, call):
+    outcome = yield
+    if call.when != "call":
+        return
+    rep = outcome.get_result()
+    if getattr(rep, "wasxfail", None) is not None:
+        return
+    xfail_info = _get_xfail_info(item)
+    if xfail_info is None or not xfail_info.get("run", True):
+        return
+    if call.excinfo:
+        raises = xfail_info["raises"]
+        if raises is None or isinstance(call.excinfo.value, raises):
+            rep.outcome = "skipped"
+            rep.wasxfail = xfail_info["reason"]
+    elif not rep.skipped:
+        if xfail_info["strict"]:
+            rep.outcome = "failed"
+            rep.longrepr = "[XPASS(strict)] " + xfail_info["reason"]
+        else:
+            rep.outcome = "passed"
+            rep.wasxfail = xfail_info["reason"]
+
+
+def _get_pytest_timeout_marker(item):
+    """Get timeout value from @pytest.mark.timeout marker, if any."""
+    for marker in item.iter_markers(name="timeout"):
+        if marker.args:
+            try:
+                return float(marker.args[0])
+            except (ValueError, TypeError):
+                pass
+        kwargs_timeout = marker.kwargs.get("timeout")
+        if kwargs_timeout is not None:
+            try:
+                return float(kwargs_timeout)
+            except (ValueError, TypeError):
+                pass
+    return None
+
+
+_config_default_timeout = None
+_config_global_enabled = None
+
+
+def config_default_timeout(value=None):
+    if value is not None:
+        global _config_default_timeout
+        _config_default_timeout = float(value)
+
+
+def config_global_enabled(value=None):
+    if value is not None:
+        global _config_global_enabled
+        _config_global_enabled = value
+
+
+def _resolve_timeout(item):
+    candidates = []
+
+    marker = item.get_closest_marker("subproc")
+    if marker is not None:
+        t = marker.kwargs.get("timeout")
+        if t is not None:
+            candidates.append(("subproc marker", float(t)))
+
+    pt = _get_pytest_timeout_marker(item)
+    if pt is not None:
+        candidates.append(("pytest-timeout marker", pt))
+
+    if candidates:
+        candidates.sort(key=lambda x: x[1])
+        return candidates[0][1]
+
+    cli = item.config.getoption("subproc_default_timeout", default=None)
+    if cli is not None and cli != "":
+        try:
+            return float(cli)
+        except ValueError:
+            pass
+
+    ini = item.config.getini("subproc_default_timeout")
+    if ini is not None and ini != "":
+        try:
+            return float(ini)
+        except ValueError:
+            pass
+
+    if _config_default_timeout is not None:
+        return _config_default_timeout
+
+    return None
+
+
+def _should_spawn(item):
+    marker = item.get_closest_marker("subproc")
+    if marker is None:
+        return False
+    if "condition" in marker.kwargs:
+        condition = marker.kwargs["condition"]
+        if callable(condition):
+            return condition()
+        return bool(condition)
+    if _config_global_enabled is not None:
+        if callable(_config_global_enabled):
+            return _config_global_enabled()
+        return _config_global_enabled
+    return True
+
+
+def _get_timeout(item):
+    return _resolve_timeout(item)
+
+
+def _cancel_pytest_timeout(item):
+    """Cancel pytest-timeout's timeout for this test item.
+
+    pytest-timeout stores a ``cancel_timeout`` callable on the item
+    that stops the timer thread.  Calling it prevents the timer from
+    killing the parent while we wait for the subprocess.
+    """
+    try:
+        cancel = getattr(item, "cancel_timeout", None)
+        if cancel is not None:
+            cancel()
+    except Exception:
+        pass
+
+
+def _kill_process_tree(proc):
+    """Kill the subprocess and its entire process group / tree."""
+    try:
+        if sys.platform == "win32":
+            subprocess.run(
+                ["taskkill", "/F", "/T", "/PID", str(proc.pid)],
+                capture_output=True,
+                timeout=5,
+            )
+        else:
+            pgid = os.getpgid(proc.pid)
+            os.killpg(pgid, signal.SIGKILL)
+    except (OSError, subprocess.TimeoutExpired, Exception):
+        try:
+            proc.kill()
+        except Exception:
+            pass
+
+
+def run_subprocess_test(item, nodeid, timeout):
+    runner_path = os.path.join(os.path.dirname(__file__), "_subproc_runner.py")
+
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".pkl") as f:
+        result_path = f.name
+
+    env = os.environ.copy()
+    env["PYTHONPATH"] = os.pathsep.join(sys.path)
+
+    rootdir = str(item.config.rootpath)
+
+    ini_overrides = _forward_ini_overrides(item.config)
+
+    args = [
+        sys.executable,
+        runner_path,
+        nodeid,
+        result_path,
+        rootdir,
+        json.dumps(ini_overrides),
+    ]
+
+    popen_kwargs = dict(
+        args=args,
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        env=env,
+    )
+    if sys.platform != "win32":
+        popen_kwargs["start_new_session"] = True
+
+    proc = subprocess.Popen(**popen_kwargs)
+
+    try:
+        stdout, stderr = proc.communicate(timeout=timeout)
+    except subprocess.TimeoutExpired:
+        _kill_process_tree(proc)
+        stdout, stderr = proc.communicate()
+        try:
+            os.unlink(result_path)
+        except OSError:
+            pass
+        raise TimeoutError(f"Test timed out after {timeout}s")
+    except BaseException:
+        _kill_process_tree(proc)
+        stdout, stderr = proc.communicate()
+        try:
+            os.unlink(result_path)
+        except OSError:
+            pass
+        raise
+
+    try:
+        with open(result_path, "rb") as f:
+            data_bytes = f.read()
+        if data_bytes:
+            result = pickle.loads(data_bytes)
+        else:
+            result = {
+                "failed": True,
+                "message": f"Subprocess crashed (exit code {proc.returncode})",
+            }
+    except FileNotFoundError:
+        result = {
+            "failed": True,
+            "message": f"Subprocess crashed (exit code {proc.returncode})",
+        }
+    except (pickle.UnpicklingError, EOFError, Exception):
+        result = {
+            "failed": True,
+            "message": f"Subprocess crashed (exit code {proc.returncode})",
+        }
+    finally:
+        try:
+            os.unlink(result_path)
+        except OSError:
+            pass
+
+    result["_stdout"] = stdout.decode(errors="replace")
+    result["_stderr"] = stderr.decode(errors="replace")
+
+    return result
+
+
+def _build_exception_message(exc, stdout, stderr):
+    msg = str(exc) if str(exc) else ""
+    if stdout:
+        msg += f"\n[subproc stdout]\n{stdout}"
+    if stderr:
+        msg += f"\n[subproc stderr]\n{stderr}"
+    return msg
+
+
+def pytest_addoption(parser):
+    parser.addini(
+        "subproc_default_timeout",
+        type="string",
+        default=None,
+        help="Default timeout in seconds for subprocess tests (int or float)",
+    )
+    parser.addoption(
+        "--subprocess-timeout",
+        dest="subproc_default_timeout",
+        type=str,
+        default=None,
+        metavar="SECONDS",
+        help="Default timeout in seconds for @pytest.mark.subproc tests",
+    )
+
+
+def pytest_configure(config):
+    config.addinivalue_line(
+        "markers",
+        "subproc(timeout=None, condition=None): "
+        "run the marked test in a subprocess. "
+        "timeout: timeout in seconds. "
+        "condition: bool or callable to decide whether to use subprocess.",
+    )
+
+    raw = config.getini("subproc_default_timeout")
+    if raw is not None and raw != "":
+        try:
+            float(raw)
+        except (ValueError, TypeError):
+            warnings.warn(
+                f"subproc_default_timeout = {raw!r} is not a valid number; "
+                "ignoring.  Set it to a float or int, e.g. "
+                "subproc_default_timeout = 30",
+                pytest.PytestConfigWarning,
+            )

pytest_subproc/_subproc_runner.py

@@ -0,0 +1,118 @@
+"""Subprocess runner for pytest-subproc.
+
+Receives the test nodeid, result path, and rootdir from the parent
+process, runs pytest.main() for that single test, captures the
+outcome, and writes a pickled result to the temp file.
+"""
+import json
+import pickle
+import sys
+
+import pytest
+
+# Enable coverage measurement in subprocess when the parent has requested
+# it via COVERAGE_PROCESS_START / COVERAGE_PROCESS_CONFIG.  The env var
+# is inherited from the parent, which also resolves the config path to an
+# absolute path so the subprocess can find it regardless of its cwd.
+if (
+    "COVERAGE_PROCESS_START" in __import__("os").environ
+    or "COVERAGE_PROCESS_CONFIG" in __import__("os").environ
+):
+    try:
+        import coverage as _coverage
+
+        _coverage.process_startup()
+    except Exception:
+        pass
+
+
+class _SubprocResultPlugin:
+    """Captures the test result from the subprocess pytest run."""
+
+    def __init__(self):
+        self.call_exception = None
+        self.setup_passed = True
+        self.xfailed = False
+        self.xpassed = False
+        self.skipped = False
+
+    @pytest.hookimpl(hookwrapper=True)
+    def pytest_runtest_makereport(self, item, call):
+        outcome = yield
+        if call.when == "call":
+            report = outcome.get_result()
+            self.call_exception = call.excinfo.value if call.excinfo else None
+            if report.skipped:
+                if getattr(report, "wasxfail", None) is not None:
+                    self.xfailed = True
+                else:
+                    self.skipped = True
+        elif call.when == "setup":
+            if call.excinfo:
+                self.setup_passed = False
+
+
+def main():
+    nodeid = sys.argv[1]
+    result_path = sys.argv[2]
+    rootdir = sys.argv[3]
+    ini_overrides = json.loads(sys.argv[4]) if len(sys.argv) > 4 else {}
+
+    plugin = _SubprocResultPlugin()
+
+    pytest_args = [
+        nodeid,
+        "--rootdir",
+        rootdir,
+        "-p",
+        "no:pytest_subproc",
+        "-p",
+        "no:cacheprovider",
+        "-p",
+        "no:flaky",
+        "-p",
+        "no:timeout",
+        "-s",
+    ]
+
+    for name, value in ini_overrides.items():
+        if value is not None and value != "":
+            pytest_args.append(f"--override-ini={name}={value}")
+
+    exit_code = pytest.main(pytest_args, plugins=[plugin])
+
+    result = {"exit_code": exit_code}
+
+    if plugin.xfailed:
+        result["xfailed"] = True
+        result["exception"] = plugin.call_exception
+    elif plugin.call_exception is not None:
+        result["failed"] = True
+        result["exception"] = plugin.call_exception
+    elif not plugin.setup_passed:
+        result["failed"] = True
+        result["message"] = "Test setup failed in subprocess"
+    elif plugin.skipped:
+        result["skipped"] = True
+    else:
+        result["passed"] = True
+
+    _write_result(result_path, result)
+
+
+def _write_result(path, result):
+    # Ensure all values in result are picklable
+    if "exception" in result:
+        exc = result["exception"]
+        try:
+            pickle.dumps(exc)
+        except Exception:
+            result["message"] = str(exc)
+            result["failed"] = True
+            del result["exception"]
+    with open(path, "wb") as f:
+        pickle.dump(result, f)
+
+
+if __name__ == "__main__":
+    main()

pytest_subproc-0.1.0.dist-info/METADATA

@@ -0,0 +1,162 @@
+Metadata-Version: 2.4
+Name: pytest-subproc
+Version: 0.1.0
+Summary: A pytest plugin to run marked tests in a subprocess
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pytest>=7.0.0
+Provides-Extra: test
+Requires-Dist: pytest-asyncio>=0.21; extra == "test"
+Requires-Dist: pytest-cov>=4.0; extra == "test"
+Requires-Dist: flaky>=3.8; extra == "test"
+Requires-Dist: pytest-timeout>=1.4; extra == "test"
+Dynamic: license-file
+
+# pytest-subproc
+
+Run marked pytest test functions in an isolated subprocess to protect the main process from crashes caused by C++ panics, segfaults, or hangs.
+
+## Installation
+
+```bash
+pip install pytest-subproc
+```
+
+## Usage
+
+Mark any test with `@pytest.mark.subproc` to run it in a subprocess:
+
+```python
+import pytest
+
+@pytest.mark.subproc
+def test_isolated():
+    assert True
+```
+
+### Parameters
+
+`@pytest.mark.subproc(timeout=None, condition=None)`
+
+| Parameter | Type | Default | Description |
+|---|---|---|---|
+| `timeout` | `float` | `None` | Timeout in seconds. Kills the subprocess if the test exceeds this limit. Falls back to `subproc_default_timeout` ini option. |
+| `condition` | `bool` or `() -> bool` | `True` | When falsy, the test runs in the main process normally. Useful for conditional isolation (e.g., only in CI). |
+
+```python
+@pytest.mark.subproc(timeout=30)
+def test_with_timeout():
+    ...
+
+@pytest.mark.subproc(condition=lambda: os.environ.get("CI") == "true")
+def test_ci_only():
+    ...
+
+@pytest.mark.subproc(timeout=10, condition=False)
+def test_never_subprocess():
+    ...
+```
+
+### Configuration via `pyproject.toml` / `pytest.ini`
+
+```ini
+[tool.pytest.ini_options]
+subproc_default_timeout = 30
+```
+
+Or on the command line:
+
+```bash
+pytest --subprocess-timeout=30
+```
+
+### Module-level configuration
+
+Set defaults for all `@pytest.mark.subproc` tests in a directory tree by calling `pytest_subproc` methods in a `conftest.py`:
+
+```python
+import pytest_subproc
+
+# Default timeout (lowest priority: marker > CLI > ini > this)
+pytest_subproc.config_default_timeout(30)
+
+# Default condition for spawning (lowest priority: marker > this)
+pytest_subproc.config_global_enabled(True)
+pytest_subproc.config_global_enabled(lambda: os.environ.get("CI") == "true")  # callable
+```
+
+
+### `@pytest.mark.timeout` interaction
+
+When a test has both `@pytest.mark.subproc(timeout=5)` and `@pytest.mark.timeout(3)`,
+the shorter value (3s) is used as the subprocess timeout.  This prevents
+`pytest-timeout` from killing the main process while the subprocess is still
+running — our plugin cancels `pytest-timeout`'s timer and enforces the
+effective timeout on the subprocess itself.
+
+```python
+@pytest.mark.subproc(timeout=5)
+@pytest.mark.timeout(3)       # ← effective timeout (shorter wins)
+def test_obey_the_shorter():
+    ...
+```
+
+
+## How It Works
+
+1. **Interception** — `pytest_runtest_protocol` (tryfirst) takes over the
+   protocol for `subproc`-marked tests.
+
+2. **Isolated run** — The main process spawns a child that runs
+   `pytest.main([nodeid, --rootdir, ...])` for that single test.
+   The **full lifecycle** (conftest loading, fixture resolution, setup,
+   call, teardown) happens inside the subprocess.
+
+3. **Timeout & cleanup** — The child is created with `start_new_session`
+   so the **entire process group** (including test‑spawned children) is
+   killed when the timeout fires.
+
+4. **Result** — A plugin inside the subprocess captures the outcome and
+   exception; these are pickled to a temp file.  The parent re‑raises
+   the exception so `xfail`, `skip`, etc. work as expected.
+
+5. **Config parity** — `asyncio_mode`, `xfail_strict` and other ini
+   settings are forwarded to the subprocess via `--override-ini`.
+
+## Comparison with `pytest-forked`
+
+| | `pytest-subproc` | `pytest-forked` |
+|---|---|---|
+| Mechanism | Spawns a new Python process (`subprocess`) | Forks the existing process (`os.fork`) |
+| Fixtures | Re‑evaluated in the child (full conftest + fixture resolution) | Inherited from parent via copy‑on‑write |
+| Windows | ✅ Supported | ❌ Not available |
+| Crash isolation | Full — the child has its own PID and memory space; a segfault cannot reach the parent | Partial — forked process shares file descriptors and some kernel state with the parent |
+| Timeout | Built‑in `timeout` parameter on the marker, with process‑tree termination | Only via external `pytest-timeout` plugin |
+| Process‑tree cleanup | Kills the entire process group on timeout (`os.killpg` / `taskkill /T`) | No automatic child‑process cleanup |
+| Startup cost | Moderate — a new Python interpreter starts and runs `pytest.main` for one test | Low — fork is (mostly) copy‑on‑write |
+| `pytest-xdist` | ✅ Compatible | ✅ Compatible |
+
+## Feature Compatibility
+
+| Feature | Status |
+|---|---|
+| Python >= 3.7 | ✅ |
+| Function, session, and module-level fixtures | ✅ |
+| stdout/stderr captured and shown on failure | ✅ |
+| `pytest.mark.asyncio` + `asyncio_mode = "auto"` | ✅ |
+| `@pytest.mark.parametrize` | ✅ |
+| `@pytest.mark.xfail(raises=...)` | ✅ |
+| Custom exception pickling / re-raising | ✅ |
+| `flaky` retries | ✅ |
+| `pytest-timeout` signal handling | ✅ |
+| `pytest-cov` coverage passthrough | ✅ |
+
+## Requirements
+
+- Python >= 3.7
+- pytest >= 7.0
+
+## License
+
+MIT

pytest_subproc-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+pytest_subproc/__init__.py,sha256=jMJMZzNXzbcSuMNbKOqwsbZWc-F_vtEhEREDCaSyhr4,14528
+pytest_subproc/_subproc_runner.py,sha256=bqqPzhSNxQgQ9q00H4dNid469qoHFZxEh_Q91gNN_qI,3318
+pytest_subproc-0.1.0.dist-info/licenses/LICENSE,sha256=OIa4XLW8XpGHVL5Bp9rpYVEF3E6QfwtucmHcp1UqElA,1062
+pytest_subproc-0.1.0.dist-info/METADATA,sha256=WM5NeQe1-ctv-wIW_nGVjJTHXNzcx3SREM1lEVu-sJ8,5339
+pytest_subproc-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+pytest_subproc-0.1.0.dist-info/entry_points.txt,sha256=ogni652iMJ7HpLtW5f_XXsbOTuYNxFfhPqBQr9TmMmk,43
+pytest_subproc-0.1.0.dist-info/scm_file_list.json,sha256=sFi6tqxljsghZO1yG3Zxj42s6CkZMxWAxpTF7u4HKV4,365
+pytest_subproc-0.1.0.dist-info/scm_version.json,sha256=R2FlwhSU_yy9Kn7_SNZ7lroeT67orp_DXHrJO1-Qhio,160
+pytest_subproc-0.1.0.dist-info/top_level.txt,sha256=YenaTJgSRX6v80HvW_-16dLCnW0hZWbhf5ZbJTtJRCc,15
+pytest_subproc-0.1.0.dist-info/RECORD,,

pytest_subproc-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pytest_subproc-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pytest11]
+pytest_subproc = pytest_subproc

pytest_subproc-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 WJ SI
+
+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.

pytest_subproc-0.1.0.dist-info/scm_file_list.json

@@ -0,0 +1,17 @@
+{
+  "files": [
+    ".pre-commit-config.yaml",
+    "README.md",
+    "LICENSE",
+    "pyproject.toml",
+    "AGENTS.md",
+    "MANIFEST.in",
+    ".gitignore",
+    "src/pytest_subproc/__init__.py",
+    "src/pytest_subproc/_subproc_runner.py",
+    "tests/conftest.py",
+    "tests/test_subproc.py",
+    ".github/workflows/release.yml",
+    ".github/workflows/ci.yml"
+  ]
+}

pytest_subproc-0.1.0.dist-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.1.0",
+  "distance": 0,
+  "node": "g7b27017b072970cd709b8b7467a66f5816796c84",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-07-11"
+}

pytest_subproc-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pytest_subproc