pytest-subproc 0.1.0__tar.gz

pytest_subproc-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,57 @@
+name: CI
+
+on:
+  push:
+    branches: [main, master]
+  pull_request:
+    branches: [main, master]
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.13"
+      - run: pip install pre-commit
+      - run: pre-commit run --all-files --show-diff-on-failure
+
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+        python-version: ["3.8", "3.13"]
+
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: |
+          pip install -e ".[test]"
+          pip install pytest-timeout pytest-xdist
+
+      - name: Run tests
+        run: python -m pytest tests/ -v --timeout=60
+
+      - name: Coverage
+        if: matrix.python-version == '3.13' && matrix.os == 'ubuntu-latest'
+        run: |
+          pip install coverage
+          COVERAGE_PROCESS_START=pyproject.toml \
+            coverage run -m pytest tests/ --timeout=60 -x
+          coverage combine
+          coverage report --include="src/pytest_subproc/*" --show-missing
+          coverage xml --include="src/pytest_subproc/*"
+
+      # - name: Upload coverage
+      #   if: matrix.python-version == '3.13' && matrix.os == 'ubuntu-latest'
+      #   uses: codecov/codecov-action@v6
+      #   with:
+      #     files: coverage.xml
+      #     fail_ci_if_error: false

pytest_subproc-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,34 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.13"
+
+      - name: Build package
+        run: |
+          pip install build
+          python -m build
+
+      - name: Publish to PyPI
+        env:
+          TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }}
+          TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }}
+        run: |
+          pip install twine
+          twine upload dist/*

pytest_subproc-0.1.0/.gitignore

@@ -0,0 +1,39 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg
+*.egg-info/
+
+# Build artifacts
+dist/
+build/
+
+# Testing / coverage
+.coverage
+.coverage.*
+.cov_subproc_rc
+.cov_subproc_test
+coverage.xml
+htmlcov/
+.tox
+nosetests.xml
+.cache
+.pytest*
+
+# Virtual environments
+.venv/
+venv/
+env/
+
+# Editor / OS
+*.swp
+*.swo
+.DS_Store
+nohup.out
+
+# AI assistants
+.agents/
+.claude/
+
+# Windows-unacceptable file names
+\\*

pytest_subproc-0.1.0/.pre-commit-config.yaml

@@ -0,0 +1,61 @@
+minimum_pre_commit_version: 2.15.0
+default_stages: [commit, merge-commit, push]
+ci:
+  autofix_prs: false
+repos:
+- repo: local
+  hooks:
+  - id: check-yaml
+    name: check-yaml
+    entry: check-yaml
+    language: python
+    types_or: [yaml]
+    additional_dependencies: [pre-commit-hooks==4.4.0]
+  - id: end-of-file-fixer
+    name: end-of-file-fixer
+    entry: end-of-file-fixer
+    language: python
+    additional_dependencies: [pre-commit-hooks==4.4.0]
+  - id: trailing-whitespace
+    name: trailing-whitespace
+    entry: trailing-whitespace-fixer
+    language: python
+    additional_dependencies: [pre-commit-hooks==4.4.0]
+  - id: check-illegal-windows-names
+    name: check illegal windows names
+    entry: Illegal windows filenames detected
+    language: fail
+    files: '(?i)((^|/)(\\|CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])(\.|/|$)|:)'
+- repo: local
+  hooks:
+  - id: flake8
+    name: flake8
+    description: "Flake8"
+    entry: flake8
+    language: python
+    require_serial: true
+    types_or: [python, pyi]
+    additional_dependencies: [
+      'flake8==6.1.0; python_version>="3.8"',
+    ]
+- repo: local
+  hooks:
+  - id: black
+    name: black
+    description: "Black"
+    entry: black
+    language: python
+    require_serial: true
+    types_or: [python, pyi]
+    additional_dependencies: [black==23.3.0]
+- repo: local
+  hooks:
+    - id: isort
+      name: isort
+      description: "isort"
+      entry: isort
+      language: python
+      require_serial: true
+      types_or: [python, pyi]
+      args: [--profile, black]
+      additional_dependencies: [isort==5.11.0]

pytest_subproc-0.1.0/AGENTS.md

@@ -0,0 +1,40 @@
+# pytest-subproc — AGENTS.md
+
+## Commands
+
+```bash
+pip install -e ".[test]"          # editable + test deps
+pytest tests/ -v --timeout=60     # run all tests
+pytest tests/ -k "xfail" -v       # single topic
+pre-commit run --all-files        # lint: flake8 + black + isort
+```
+
+Coverage (requires `pip install coverage`):
+
+```bash
+COVERAGE_PROCESS_START=pyproject.toml \
+  coverage run -m pytest tests/ --timeout=60 -x
+coverage combine
+coverage report --include="src/pytest_subproc/*" --show-missing
+```
+
+Mark subprocess tests: `@pytest.mark.subproc(timeout=N, condition=bool_or_callable)`.
+
+## Architecture
+
+- Entry point: `src/pytest_subproc/__init__.py` — `pytest_runtest_protocol` (tryfirst) intercepts `subproc`-marked items.
+- Subprocess runner: `src/pytest_subproc/_subproc_runner.py`. Runs `pytest.main([nodeid])` — conftest loading, fixture resolution, setup/call/teardown all happen inside the child.
+- No `_pytest` private imports outside a single `_pytest.skipping` call (xfailed_key/evaluate).
+- Result: exception is pickled from child, re-raised in parent so `xfail(raises=...)` works.
+
+## Coverage quirk
+
+`_subproc_runner.py` runs as `python _subproc_runner.py` (script, not module import). Coverage with `source = [...]` won't capture it because it's `__main__`. Must use `include = ["src/pytest_subproc/*"]` (path-based) in the coverage config, and set `COVERAGE_PROCESS_START` so the `.pth`-file auto-start mechanism fires in the child. The CI coverage step shows how.
+
+## Testing quirks
+
+- All tests use `pytester` fixture (built-in, just `pytest_plugins = "pytester"` in the test file).
+- `assert_outcomes(passed=N, failed=N, xfailed=N)` is preferred over `fnmatch_lines`.
+- Coverage integration test (`test_coverage_collected_from_subprocess`) uses isolated file names (`.cov_subproc_*`) to avoid polluting the parent coverage run.
+- `pytest-flaky` on PyPI is called `flaky` — the dependency name is `flaky`, import is `from flaky import flaky`.
+- Windows CI uses a reduced Python version matrix (3.8, 3.13) to stay within runner time limits.

pytest_subproc-0.1.0/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/MANIFEST.in

@@ -0,0 +1,4 @@
+include LICENSE
+include README.md
+include pyproject.toml
+recursive-include src/pytest_subproc *.py

pytest_subproc-0.1.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,147 @@
+# 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/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["setuptools>=64", "setuptools-scm>=8"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pytest-subproc"
+dynamic = ["version"]
+description = "A pytest plugin to run marked tests in a subprocess"
+readme = "README.md"
+requires-python = ">=3.7"
+dependencies = ["pytest>=7.0.0"]
+
+[tool.setuptools_scm]
+
+[project.entry-points.pytest11]
+pytest_subproc = "pytest_subproc"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"
+
+[tool.coverage.run]
+include = ["src/pytest_subproc/*"]
+data_file = ".coverage"
+branch = true
+parallel = true
+cover_pylib = false
+concurrency = ["multiprocessing", "thread"]
+relative_files = true
+
+[tool.coverage.paths]
+source = ["src"]
+
+[tool.coverage.report]
+show_missing = true
+skip_empty = true
+
+[project.optional-dependencies]
+test = [
+    "pytest-asyncio>=0.21",
+    "pytest-cov>=4.0",
+    "flaky>=3.8",
+    "pytest-timeout>=1.4",
+]

pytest_subproc-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+