temper-python 0.1.0__tar.gz

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

@@ -0,0 +1,26 @@
+name: ci
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python: ["3.10", "3.11", "3.12", "3.13", "3.14", "3.15"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
+        with:
+          go-version: stable
+      - run: go install github.com/turbolytics/temper/cmd/temper@v0.1.0
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python }}
+      - run: pip install -e '.[dev]'
+      - run: temper check
+      - run: temper run --level unit -- python -m pytest -q
+      - run: temper matrix --check

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

@@ -0,0 +1,40 @@
+name: release
+on:
+  push:
+    tags: ["v*"]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.13"
+      - name: The tag is the package version
+        run: |
+          version=$(python -c 'import tomllib; print(tomllib.load(open("pyproject.toml","rb"))["project"]["version"])')
+          if [ "v$version" != "$GITHUB_REF_NAME" ]; then
+            echo "tag $GITHUB_REF_NAME does not match pyproject.toml version $version" >&2
+            exit 1
+          fi
+      - run: pip install -e '.[dev]' build
+      - run: python -m pytest -q
+      - run: python -m build
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write   # PyPI trusted publishing; no stored token
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1

temper_python-0.1.0/.gitignore

@@ -0,0 +1,6 @@
+.venv/
+__pycache__/
+*.egg-info/
+/.temper/
+/dist/
+.pytest_cache/

temper_python-0.1.0/LICENSE

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

temper_python-0.1.0/MATRIX.md

@@ -0,0 +1,51 @@
+<!-- Generated by temper. Do not edit by hand. -->
+# temper-python matrix
+
+Every row is a claim this project declares in `temper/`. A cell is covered only by a
+passing evidence record from a test that ran at that level; a skip proves nothing.
+Exempt cells are excused by a passing proof. Regenerate with `temper matrix`.
+
+✅ covered · ☑️ exempt · ❌ failing · ⬜ missing · ⏳ unenforced · — not required
+
+## Summary
+
+| covered | exempt | failing | missing | unenforced |
+| ---: | ---: | ---: | ---: | ---: |
+| 10 | 0 | 0 | 0 | 0 |
+
+## Features
+
+| Feature | What it does | unit |
+| --- | --- | --- |
+| `adapter.python` | Records what each pytest test proves and how it ended, as Temper evidence. | ✅ |
+
+## Invariants
+
+### adapter
+
+| Invariant | Subject | unit |
+| --- | --- | --- |
+| `adapter.failure_never_passes` | `adapter.python` | ✅ |
+| `adapter.level_from_runner` | `adapter.python` | ✅ |
+| `adapter.never_truncates` | `adapter.python` | ✅ |
+| `adapter.silent_without_runner` | `adapter.python` | ✅ |
+| `adapter.skip_records_skip` | `adapter.python` | ✅ |
+
+- `adapter.failure_never_passes` — A test that fails, errors or panics never records pass.
+- `adapter.level_from_runner` — The level a record carries comes only from TEMPER_LEVEL; no test can set it.
+- `adapter.never_truncates` — The adapter only appends, to a file unique to its process; it never truncates or removes evidence.
+- `adapter.silent_without_runner` — Without TEMPER_LEVEL and TEMPER_EVIDENCE the adapter records nothing and changes nothing.
+- `adapter.skip_records_skip` — A skipped test records skip.
+
+## Lattices
+
+### `outcomes`
+
+Every outcome an evidence record can carry, from the spec's record format. An adapter answers for each one it can produce.
+
+| Member | `adapter.python` |
+| --- | --- |
+| `pass` | ✅ |
+| `fail` | ✅ |
+| `skip` | ✅ |
+| `error` | ✅ |

temper_python-0.1.0/Makefile

@@ -0,0 +1,19 @@
+PYTHON ?= python
+TEMPER ?= temper
+
+.PHONY: test matrix check-matrix
+
+test:
+	$(PYTHON) -m pytest -q
+
+matrix:
+	$(TEMPER) check
+	$(TEMPER) clean
+	$(TEMPER) run --level unit -- $(PYTHON) -m pytest -q
+	$(TEMPER) matrix --all-levels
+
+check-matrix:
+	$(TEMPER) check
+	$(TEMPER) clean
+	$(TEMPER) run --level unit -- $(PYTHON) -m pytest -q
+	$(TEMPER) matrix --check

temper_python-0.1.0/PKG-INFO

@@ -0,0 +1,135 @@
+Metadata-Version: 2.5
+Name: temper-python
+Version: 0.1.0
+Summary: pytest adapter for Temper: tests state what they prove, and write evidence.
+Project-URL: Homepage, https://github.com/turbolytics/temper-python
+Project-URL: Temper, https://github.com/turbolytics/temper
+License: MIT
+License-File: LICENSE
+Classifier: Framework :: Pytest
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Requires-Dist: pytest>=7
+Provides-Extra: dev
+Requires-Dist: pytest-xdist; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# temper-python
+
+The [Temper](https://github.com/turbolytics/temper) adapter for pytest. A test
+states what it proves; the adapter records how it ended; `temper matrix` turns
+those records into a matrix of what is proven and what is not.
+
+## Getting started
+
+You need the `temper` CLI ([install](https://github.com/turbolytics/temper#install))
+and a project with `temper.yml` and a `temper/` directory of declarations.
+`temper guide` explains both.
+
+**1. Install the adapter.**
+
+```sh
+pip install temper-python
+```
+
+It is a pytest plugin: nothing to import or enable.
+
+**2. Mark each test with what it proves.**
+
+```python
+import pytest
+
+@pytest.mark.covers("store.reserve.never_negative", subject="store.file")
+def test_reserve_never_goes_negative(): ...
+
+@pytest.mark.exempts("store.persists_across_restart", subject="store.memory")
+def test_memory_store_forgets_on_restart(): ...
+```
+
+**3. Run the tests through `temper run`, then build the matrix.**
+
+```sh
+temper clean
+temper run --level unit -- pytest
+temper matrix --all-levels
+```
+
+That is the whole integration. Plain `pytest` behaves exactly as before: without
+the variables `temper run` sets, the plugin records nothing.
+
+## What a test can say
+
+| Mark | Meaning |
+|---|---|
+| `@pytest.mark.covers(ref)` | The test proves a feature or lattice member (`lattice/key`). |
+| `@pytest.mark.covers(ref, subject=id)` | The test proves an invariant or lattice member for that subject. |
+| `@pytest.mark.exempts(ref, subject=id)` | The test proves the subject is excused. Use it only in the test a declaration names in `proven_by`. |
+| `scenario=id` (on either) | The claim came from that declared scenario. |
+
+Marks on a class or a module apply to every test inside. A test may carry many
+marks; each is one record with the same outcome.
+
+A scenario runner that parametrizes one test over many scenarios claims from
+inside the test, where the scenario is known:
+
+```python
+import temper
+
+@pytest.mark.parametrize("sid", SCENARIOS)
+def test_scenario(request, sid):
+    temper.covers(request, "alerts.low_stock", scenario=sid)
+    temper.covers(request, sid, scenario=sid)
+    ...
+```
+
+`temper.exempts(request, ref, subject=...)` is the same for exemptions.
+
+There is no way to set a level. The runner does (`temper run --level`), and a
+test that changes `TEMPER_LEVEL` in its own environment changes nothing: the
+environment is read once, when pytest starts.
+
+A malformed mark (no reference, a stray keyword such as `level=`, a non-string)
+stops the run with a message naming the test, when the runner is active.
+
+## How outcomes are recorded
+
+A record is written once the test is final, after fixtures have torn down.
+
+| Outcome | When |
+|---|---|
+| `pass` | The test, its setup and its teardown all passed. The only outcome that counts. |
+| `fail` | An assertion failed, `pytest.fail` was called, or the test was `xfail` (whether it failed or passed). |
+| `skip` | The test was skipped, in any phase. |
+| `error` | An exception other than a failed assertion, or any failure in setup or teardown. |
+
+A test that fails and then skips records `fail`. Evidence goes to one new file
+per process, `<level>-<pid>-<8 hex>.jsonl`, opened for append, one write per
+line. Existing evidence is never truncated, so `pytest-xdist` works without
+configuration. The contract every adapter follows is
+[docs/adapters.md](https://github.com/turbolytics/temper/blob/main/docs/adapters.md).
+
+Not verified: retry plugins such as `pytest-rerunfailures`.
+
+## Development
+
+```sh
+python -m venv .venv && .venv/bin/pip install -e '.[dev]'
+make matrix        # clean, run the tests through temper, rebuild MATRIX.md
+make check-matrix  # fail if the committed matrix is stale
+```
+
+This project is declared with Temper in `temper/`, and its own tests prove the
+adapter claims with the adapter: see [MATRIX.md](MATRIX.md).
+
+## Releasing
+
+Set `version` in `pyproject.toml`, merge, then push the matching tag:
+
+```sh
+git tag v0.1.0 && git push origin v0.1.0
+```
+
+The release workflow checks the tag matches the version, runs the tests, builds,
+and publishes to PyPI through trusted publishing.

temper_python-0.1.0/README.md

@@ -0,0 +1,117 @@
+# temper-python
+
+The [Temper](https://github.com/turbolytics/temper) adapter for pytest. A test
+states what it proves; the adapter records how it ended; `temper matrix` turns
+those records into a matrix of what is proven and what is not.
+
+## Getting started
+
+You need the `temper` CLI ([install](https://github.com/turbolytics/temper#install))
+and a project with `temper.yml` and a `temper/` directory of declarations.
+`temper guide` explains both.
+
+**1. Install the adapter.**
+
+```sh
+pip install temper-python
+```
+
+It is a pytest plugin: nothing to import or enable.
+
+**2. Mark each test with what it proves.**
+
+```python
+import pytest
+
+@pytest.mark.covers("store.reserve.never_negative", subject="store.file")
+def test_reserve_never_goes_negative(): ...
+
+@pytest.mark.exempts("store.persists_across_restart", subject="store.memory")
+def test_memory_store_forgets_on_restart(): ...
+```
+
+**3. Run the tests through `temper run`, then build the matrix.**
+
+```sh
+temper clean
+temper run --level unit -- pytest
+temper matrix --all-levels
+```
+
+That is the whole integration. Plain `pytest` behaves exactly as before: without
+the variables `temper run` sets, the plugin records nothing.
+
+## What a test can say
+
+| Mark | Meaning |
+|---|---|
+| `@pytest.mark.covers(ref)` | The test proves a feature or lattice member (`lattice/key`). |
+| `@pytest.mark.covers(ref, subject=id)` | The test proves an invariant or lattice member for that subject. |
+| `@pytest.mark.exempts(ref, subject=id)` | The test proves the subject is excused. Use it only in the test a declaration names in `proven_by`. |
+| `scenario=id` (on either) | The claim came from that declared scenario. |
+
+Marks on a class or a module apply to every test inside. A test may carry many
+marks; each is one record with the same outcome.
+
+A scenario runner that parametrizes one test over many scenarios claims from
+inside the test, where the scenario is known:
+
+```python
+import temper
+
+@pytest.mark.parametrize("sid", SCENARIOS)
+def test_scenario(request, sid):
+    temper.covers(request, "alerts.low_stock", scenario=sid)
+    temper.covers(request, sid, scenario=sid)
+    ...
+```
+
+`temper.exempts(request, ref, subject=...)` is the same for exemptions.
+
+There is no way to set a level. The runner does (`temper run --level`), and a
+test that changes `TEMPER_LEVEL` in its own environment changes nothing: the
+environment is read once, when pytest starts.
+
+A malformed mark (no reference, a stray keyword such as `level=`, a non-string)
+stops the run with a message naming the test, when the runner is active.
+
+## How outcomes are recorded
+
+A record is written once the test is final, after fixtures have torn down.
+
+| Outcome | When |
+|---|---|
+| `pass` | The test, its setup and its teardown all passed. The only outcome that counts. |
+| `fail` | An assertion failed, `pytest.fail` was called, or the test was `xfail` (whether it failed or passed). |
+| `skip` | The test was skipped, in any phase. |
+| `error` | An exception other than a failed assertion, or any failure in setup or teardown. |
+
+A test that fails and then skips records `fail`. Evidence goes to one new file
+per process, `<level>-<pid>-<8 hex>.jsonl`, opened for append, one write per
+line. Existing evidence is never truncated, so `pytest-xdist` works without
+configuration. The contract every adapter follows is
+[docs/adapters.md](https://github.com/turbolytics/temper/blob/main/docs/adapters.md).
+
+Not verified: retry plugins such as `pytest-rerunfailures`.
+
+## Development
+
+```sh
+python -m venv .venv && .venv/bin/pip install -e '.[dev]'
+make matrix        # clean, run the tests through temper, rebuild MATRIX.md
+make check-matrix  # fail if the committed matrix is stale
+```
+
+This project is declared with Temper in `temper/`, and its own tests prove the
+adapter claims with the adapter: see [MATRIX.md](MATRIX.md).
+
+## Releasing
+
+Set `version` in `pyproject.toml`, merge, then push the matching tag:
+
+```sh
+git tag v0.1.0 && git push origin v0.1.0
+```
+
+The release workflow checks the tag matches the version, runs the tests, builds,
+and publishes to PyPI through trusted publishing.

temper_python-0.1.0/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "temper-python"
+version = "0.1.0"
+description = "pytest adapter for Temper: tests state what they prove, and write evidence."
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+dependencies = ["pytest>=7"]
+classifiers = [
+  "Framework :: Pytest",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Topic :: Software Development :: Testing",
+]
+
+[project.urls]
+Homepage = "https://github.com/turbolytics/temper-python"
+Temper = "https://github.com/turbolytics/temper"
+
+[project.entry-points.pytest11]
+temper = "temper.plugin"
+
+[project.optional-dependencies]
+dev = ["pytest-xdist"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/temper"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

temper_python-0.1.0/src/temper/__init__.py

@@ -0,0 +1,26 @@
+"""Temper adapter for pytest.
+
+Mark a test with what it proves::
+
+    @pytest.mark.covers("store.reserve.never_negative", subject="store.file")
+    def test_reserve(): ...
+
+or claim from inside it, which is how a parametrized scenario runner names its
+scenario::
+
+    temper.covers(request, "alerts.low_stock", scenario="alerts.sold_out")
+"""
+
+from .plugin import add_claim
+
+__all__ = ["covers", "exempts"]
+
+
+def covers(request, ref, *, subject=None, scenario=None):
+    """The running test proves ``ref`` (for ``subject``, when it applies per subject)."""
+    add_claim(request, "covers", ref, subject, scenario)
+
+
+def exempts(request, ref, *, subject=None, scenario=None):
+    """The running test proves ``subject`` is excused from ``ref``."""
+    add_claim(request, "exempts", ref, subject, scenario)

temper_python-0.1.0/src/temper/_evidence.py

@@ -0,0 +1,60 @@
+"""The evidence file: append-only, one file per process, one write per line."""
+
+import json
+import os
+import re
+import secrets
+from pathlib import Path
+
+_SEPARATORS = (",", ":")
+
+
+def encode(record):
+    """One record as one UTF-8 line, keys in the order given, compact."""
+    try:
+        return (json.dumps(record, separators=_SEPARATORS, ensure_ascii=False) + "\n").encode("utf-8")
+    except UnicodeEncodeError:
+        # A lone surrogate (an odd test id) cannot be UTF-8; JSON can still escape it.
+        return (json.dumps(record, separators=_SEPARATORS, ensure_ascii=True) + "\n").encode("utf-8")
+
+
+class Writer:
+    """Appends records to ``<level>-<pid>-<8 hex>.jsonl`` in a directory.
+
+    The file is created on the first record, never opened for truncation, and
+    never shared: a forked child opens its own.
+    """
+
+    def __init__(self, directory, level):
+        self._dir = Path(directory)
+        self._level = level
+        self._fd = None
+        self._pid = None
+
+    def ensure_directory(self):
+        self._dir.mkdir(parents=True, exist_ok=True)
+
+    def write(self, record):
+        data = encode(record)
+        fd = self._open()
+        written = os.write(fd, data)
+        while written < len(data):  # a short write is rare; finish the line
+            written += os.write(fd, data[written:])
+
+    def close(self):
+        if self._fd is not None and self._pid == os.getpid():
+            os.close(self._fd)
+        self._fd = None
+
+    def _open(self):
+        pid = os.getpid()
+        if self._fd is not None and self._pid == pid:
+            return self._fd
+        self._fd = None  # inherited across a fork: leave the parent's file alone
+        self.ensure_directory()
+        safe = re.sub(r"[^A-Za-z0-9._-]", "_", self._level)
+        name = f"{safe}-{pid}-{secrets.token_hex(4)}.jsonl"
+        flags = os.O_WRONLY | os.O_APPEND | os.O_CREAT | os.O_EXCL
+        self._fd = os.open(self._dir / name, flags, 0o644)
+        self._pid = pid
+        return self._fd

temper_python-0.1.0/src/temper/plugin.py

@@ -0,0 +1,140 @@
+"""The pytest plugin: reads what each test claims, records how it ended.
+
+The level and the evidence directory come from ``TEMPER_LEVEL`` and
+``TEMPER_EVIDENCE``, read once when pytest starts. Without both, the plugin
+does nothing.
+"""
+
+import os
+from datetime import datetime, timezone
+
+import pytest
+
+from ._evidence import Writer
+
+CLAIM_KINDS = ("covers", "exempts")
+_KEYWORDS = ("subject", "scenario")
+
+_CLAIMS = pytest.StashKey()  # runtime claims made through temper.covers / temper.exempts
+_OUTCOMES = pytest.StashKey()  # one outcome per phase report
+_STATE = pytest.StashKey()
+
+_PRECEDENCE = ("error", "fail", "skip", "pass")  # first one present wins
+
+
+class _State:
+    def __init__(self, level, directory, run):
+        self.level = level
+        self.run = run
+        self.writer = Writer(directory, level)
+
+
+def _claim(kind, args, kwargs, where):
+    """Validate one claim and return (kind, ref, subject, scenario)."""
+    if len(args) != 1 or not isinstance(args[0], str) or not args[0]:
+        raise ValueError(f"{where}: {kind} takes one non-empty reference, as a string")
+    for key in kwargs:
+        if key not in _KEYWORDS:
+            hint = " (the level comes from the runner, never the test)" if key == "level" else ""
+            raise ValueError(f"{where}: {kind} has no keyword {key!r}{hint}; use subject or scenario")
+    for key in _KEYWORDS:
+        value = kwargs.get(key)
+        if value is not None and (not isinstance(value, str) or not value):
+            raise ValueError(f"{where}: {kind} {key} must be a non-empty string")
+    return kind, args[0], kwargs.get("subject"), kwargs.get("scenario")
+
+
+def add_claim(request, kind, ref, subject=None, scenario=None):
+    """Claim from inside a test; the claim follows the test's outcome."""
+    node = getattr(request, "node", None)
+    if not isinstance(node, pytest.Item):
+        raise TypeError(f"temper.{kind} needs the `request` fixture of a test")
+    kwargs = {k: v for k, v in (("subject", subject), ("scenario", scenario)) if v is not None}
+    claim = _claim(kind, (ref,), kwargs, node.nodeid)
+    node.stash.setdefault(_CLAIMS, []).append(claim)
+
+
+def _claims(item):
+    seen, out = set(), []
+    marked = [_claim(m.name, m.args, m.kwargs, item.nodeid) for m in item.iter_markers() if m.name in CLAIM_KINDS]
+    for claim in marked + item.stash.get(_CLAIMS, []):
+        if claim not in seen:
+            seen.add(claim)
+            out.append(claim)
+    return out
+
+
+def pytest_configure(config):
+    config.addinivalue_line("markers", "covers(ref, subject=None, scenario=None): the test proves this Temper claim")
+    config.addinivalue_line("markers", "exempts(ref, subject=None, scenario=None): the test proves this exemption")
+    level = os.environ.get("TEMPER_LEVEL", "")
+    directory = os.environ.get("TEMPER_EVIDENCE", "")
+    if not level or not directory:
+        return
+    state = _State(level, directory, os.environ.get("TEMPER_RUN", ""))
+    try:
+        state.writer.ensure_directory()
+    except OSError as err:
+        raise pytest.UsageError(f"temper: cannot write evidence to TEMPER_EVIDENCE={directory!r}: {err}")
+    config.stash[_STATE] = state
+
+
+def pytest_unconfigure(config):
+    state = config.stash.get(_STATE, None)
+    if state is not None:
+        state.writer.close()
+
+
+def pytest_collection_modifyitems(config, items):
+    if config.stash.get(_STATE, None) is None:
+        return
+    for item in items:
+        try:
+            _claims(item)
+        except ValueError as err:
+            raise pytest.UsageError(f"temper: {err}")
+
+
+def _outcome(report, call):
+    if hasattr(report, "wasxfail"):
+        return "fail"  # an expected failure never proves anything, whichever way it went
+    if report.skipped:
+        return "skip"
+    if report.passed:
+        return "pass"
+    if report.when != "call":
+        return "error"  # setup or teardown broke
+    excinfo = call.excinfo
+    if excinfo is None or isinstance(excinfo.value, (AssertionError, pytest.fail.Exception)):
+        return "fail"
+    return "error"
+
+
+@pytest.hookimpl(hookwrapper=True, tryfirst=True)
+def pytest_runtest_makereport(item, call):
+    outcome = yield
+    if item.config.stash.get(_STATE, None) is None:
+        return
+    item.stash.setdefault(_OUTCOMES, []).append(_outcome(outcome.get_result(), call))
+
+
+@pytest.hookimpl(hookwrapper=True)
+def pytest_runtest_protocol(item, nextitem):
+    yield
+    state = item.config.stash.get(_STATE, None)
+    outcomes = item.stash.get(_OUTCOMES, None)
+    if state is None or not outcomes:
+        return
+    final = next(o for o in _PRECEDENCE if o in outcomes)
+    at = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+    for kind, ref, subject, scenario in _claims(item):
+        record = {kind: ref}
+        if subject:
+            record["subject"] = subject
+        if scenario:
+            record["scenario"] = scenario
+        record.update(test=item.nodeid, level=state.level, outcome=final)
+        if state.run:
+            record["run"] = state.run
+        record["at"] = at
+        state.writer.write(record)

temper_python-0.1.0/temper/features.yml

@@ -0,0 +1,4 @@
+features:
+  - id: adapter.python
+    description: Records what each pytest test proves and how it ended, as Temper evidence.
+    requires: [unit]

temper_python-0.1.0/temper/invariants.yml

@@ -0,0 +1,35 @@
+invariants:
+  - id: adapter.failure_never_passes
+    claim: A test that fails, errors or panics never records pass.
+    applies_to: adapter
+    class: safety
+    family: adapter
+    requires: [unit]
+
+  - id: adapter.skip_records_skip
+    claim: A skipped test records skip.
+    applies_to: adapter
+    class: safety
+    family: adapter
+    requires: [unit]
+
+  - id: adapter.level_from_runner
+    claim: The level a record carries comes only from TEMPER_LEVEL; no test can set it.
+    applies_to: adapter
+    class: safety
+    family: adapter
+    requires: [unit]
+
+  - id: adapter.silent_without_runner
+    claim: Without TEMPER_LEVEL and TEMPER_EVIDENCE the adapter records nothing and changes nothing.
+    applies_to: adapter
+    class: safety
+    family: adapter
+    requires: [unit]
+
+  - id: adapter.never_truncates
+    claim: The adapter only appends, to a file unique to its process; it never truncates or removes evidence.
+    applies_to: adapter
+    class: safety
+    family: adapter
+    requires: [unit]

temper_python-0.1.0/temper/lattices/outcomes.yml

@@ -0,0 +1,11 @@
+id: outcomes
+description: >
+  Every outcome an evidence record can carry, from the spec's record format.
+  An adapter answers for each one it can produce.
+applies_to: adapter
+requires: [unit]
+members:
+  - key: pass
+  - key: fail
+  - key: skip
+  - key: error

temper_python-0.1.0/temper/status/features.yml

@@ -0,0 +1,3 @@
+# Generated by temper. Do not edit by hand.
+# One line per feature, sorted by id: the status at each level.
+adapter.python: {unit: covered}

temper_python-0.1.0/temper/status/subjects/adapter.python.yml

@@ -0,0 +1,11 @@
+# Generated by temper. Do not edit by hand.
+# One line per invariant or lattice member that applies to adapter.python, sorted by id: the status at each level.
+adapter.failure_never_passes: {unit: covered}
+adapter.level_from_runner: {unit: covered}
+adapter.never_truncates: {unit: covered}
+adapter.silent_without_runner: {unit: covered}
+adapter.skip_records_skip: {unit: covered}
+outcomes/error: {unit: covered}
+outcomes/fail: {unit: covered}
+outcomes/pass: {unit: covered}
+outcomes/skip: {unit: covered}

temper_python-0.1.0/temper/subjects/adapter.python.yml

@@ -0,0 +1,9 @@
+id: adapter.python
+kind: adapter
+feature: adapter.python
+answers:
+  outcomes:
+    pass: supported
+    fail: supported
+    skip: supported
+    error: supported

temper_python-0.1.0/temper.yml

@@ -0,0 +1,6 @@
+temper: "0.1"
+project: temper-python
+
+levels:
+  - name: unit
+    description: pytest; every test runs the plugin in a fresh pytest process

temper_python-0.1.0/tests/conftest.py

@@ -0,0 +1,51 @@
+"""Helpers for running an inner pytest, as a runner would, and reading what it wrote."""
+
+import json
+from pathlib import Path
+
+import pytest
+
+pytest_plugins = ["pytester"]
+
+VARS = ("TEMPER_LEVEL", "TEMPER_EVIDENCE", "TEMPER_RUN")
+
+
+class Inner:
+    """Runs a test file in a fresh pytest process with an explicit Temper environment."""
+
+    def __init__(self, pytester, monkeypatch, tmp_path):
+        self.pytester = pytester
+        self.monkeypatch = monkeypatch
+        self.dir = tmp_path / "evidence"
+
+    def run(self, source, *args, level="unit", run=None, runner=True, evidence=None):
+        for name in VARS:
+            self.monkeypatch.delenv(name, raising=False)
+        if runner:
+            self.monkeypatch.setenv("TEMPER_LEVEL", level)
+            self.monkeypatch.setenv("TEMPER_EVIDENCE", str(evidence or self.dir))
+            if run:
+                self.monkeypatch.setenv("TEMPER_RUN", run)
+        self.pytester.makepyfile(test_inner=source)
+        return self.pytester.runpytest_subprocess(*args)
+
+    def files(self):
+        return sorted(self.dir.glob("*.jsonl")) if self.dir.exists() else []
+
+    def lines(self):
+        out = []
+        for f in self.files():
+            out.extend(f.read_bytes().decode("utf-8").splitlines(keepends=True))
+        return out
+
+    def records(self):
+        return [json.loads(line) for line in self.lines()]
+
+    def outcomes(self):
+        """test name -> outcome, for inner files with one claim per test."""
+        return {r["test"].split("::", 1)[1]: r["outcome"] for r in self.records()}
+
+
+@pytest.fixture
+def inner(pytester, monkeypatch, tmp_path):
+    return Inner(pytester, monkeypatch, tmp_path)

temper_python-0.1.0/tests/test_adapter.py

@@ -0,0 +1,423 @@
+"""The adapter contract (docs/adapters.md in turbolytics/temper), proven through real pytest runs."""
+
+import json
+import re
+from pathlib import Path
+
+import pytest
+
+SUBJECT = "adapter.python"
+CLAIM = '@pytest.mark.covers("demo.claim")\n'
+
+
+def inner_test(body, mark=CLAIM, name="test_it"):
+    return "import pytest\n\n" + mark + f"def {name}():\n" + "".join(
+        f"    {line}\n" for line in body.strip().splitlines()
+    )
+
+
+@pytest.mark.covers("adapter.python")
+@pytest.mark.covers("outcomes/pass", subject=SUBJECT)
+def test_pass_writes_one_exact_record(inner):
+    inner.run(
+        "import pytest\n\n"
+        '@pytest.mark.covers("sink.flush.keeps_batch", subject="sink.kafka")\n'
+        "def test_flush():\n    assert True\n",
+        run="ci-1",
+    )
+    (line,) = inner.lines()
+    assert line.endswith("\n") and not line.endswith("\n\n")
+    rec = json.loads(line)
+    assert list(rec) == ["covers", "subject", "test", "level", "outcome", "run", "at"]
+    assert rec["covers"] == "sink.flush.keeps_batch"
+    assert rec["subject"] == "sink.kafka"
+    assert rec["test"] == "test_inner.py::test_flush"
+    assert (rec["level"], rec["outcome"], rec["run"]) == ("unit", "pass", "ci-1")
+    assert re.fullmatch(r"\d{4}-\d\d-\d\dT\d\d:\d\d:\d\dZ", rec["at"])
+    assert line == json.dumps(rec, separators=(",", ":"), ensure_ascii=False) + "\n"
+
+
+@pytest.mark.covers("adapter.python")
+def test_empty_optional_keys_are_left_out(inner):
+    inner.run(inner_test("pass"))
+    (rec,) = inner.records()
+    assert list(rec) == ["covers", "test", "level", "outcome", "at"]
+
+
+@pytest.mark.covers("adapter.python")
+def test_unmarked_tests_record_nothing(inner):
+    inner.run("def test_plain():\n    assert True\n")
+    assert inner.files() == []
+
+
+# --- adapter.failure_never_passes ------------------------------------------------
+
+FAILURES = {
+    "assert": ("assert 1 == 2", "fail"),
+    "pytest_fail": ("pytest.fail('no')", "fail"),
+    "exception": ("raise ValueError('boom')", "error"),
+    "xfail_fails": ("pytest.xfail('expected')", "fail"),
+}
+
+
+@pytest.mark.covers("adapter.failure_never_passes", subject=SUBJECT)
+@pytest.mark.covers("outcomes/fail", subject=SUBJECT)
+@pytest.mark.covers("outcomes/error", subject=SUBJECT)
+@pytest.mark.parametrize("name", sorted(FAILURES))
+def test_a_failing_body_never_records_pass(inner, name):
+    body, want = FAILURES[name]
+    inner.run(inner_test(body))
+    (rec,) = inner.records()
+    assert rec["outcome"] == want
+
+
+@pytest.mark.covers("adapter.failure_never_passes", subject=SUBJECT)
+@pytest.mark.covers("outcomes/error", subject=SUBJECT)
+def test_a_setup_error_records_error(inner):
+    inner.run(
+        "import pytest\n\n"
+        "@pytest.fixture\ndef broken():\n    raise RuntimeError('setup')\n\n"
+        '@pytest.mark.covers("demo.claim")\n'
+        "def test_it(broken):\n    assert True\n"
+    )
+    (rec,) = inner.records()
+    assert rec["outcome"] == "error"
+
+
+@pytest.mark.covers("adapter.failure_never_passes", subject=SUBJECT)
+@pytest.mark.covers("outcomes/error", subject=SUBJECT)
+def test_a_teardown_error_after_a_passing_body_records_error_not_pass(inner):
+    inner.run(
+        "import pytest\n\n"
+        "@pytest.fixture\ndef leaky():\n    yield\n    raise RuntimeError('teardown')\n\n"
+        '@pytest.mark.covers("demo.claim")\n'
+        "def test_it(leaky):\n    assert True\n"
+    )
+    (rec,) = inner.records()  # exactly one record, written after teardown
+    assert rec["outcome"] == "error"
+
+
+@pytest.mark.covers("adapter.failure_never_passes", subject=SUBJECT)
+@pytest.mark.covers("outcomes/fail", subject=SUBJECT)
+@pytest.mark.parametrize(
+    "mark",
+    ["@pytest.mark.xfail", "@pytest.mark.xfail(strict=True)"],
+    ids=["xfail", "strict"],
+)
+def test_xfail_never_records_pass(inner, mark):
+    # fails as expected -> fail; passes unexpectedly -> fail
+    for body in ("assert False", "assert True"):
+        inner.run(inner_test(body, mark=mark + "\n" + CLAIM), "-p", "no:cacheprovider")
+    assert [r["outcome"] for r in inner.records()] == ["fail", "fail"]
+
+
+@pytest.mark.covers("adapter.failure_never_passes", subject=SUBJECT)
+def test_fail_then_skip_records_fail(inner):
+    inner.run(
+        "import pytest\n\n"
+        "@pytest.fixture\ndef skipper():\n    yield\n    pytest.skip('late')\n\n"
+        '@pytest.mark.covers("demo.claim")\n'
+        "def test_it(skipper):\n    assert False\n"
+    )
+    (rec,) = inner.records()
+    assert rec["outcome"] == "fail"
+
+
+@pytest.mark.covers("adapter.failure_never_passes", subject=SUBJECT)
+def test_a_crashing_run_is_never_recorded_as_pass(inner):
+    # the process dies mid-test: nothing is written for it (no record, so no pass)
+    inner.run(
+        "import os\nimport pytest\n\n" + CLAIM + "def test_it():\n    os._exit(7)\n"
+    )
+    assert inner.records() == []
+
+
+@pytest.mark.covers("adapter.failure_never_passes", subject=SUBJECT)
+@pytest.mark.covers("outcomes/error", subject=SUBJECT)
+@pytest.mark.parametrize("phase", ["setup", "teardown"])
+def test_an_assertion_in_setup_or_teardown_is_an_error_not_a_test_failure(inner, phase):
+    fixture = (
+        "    assert False\n    yield\n" if phase == "setup" else "    yield\n    assert False\n"
+    )
+    inner.run(
+        "import pytest\n\n@pytest.fixture\ndef fx():\n" + fixture + "\n"
+        '@pytest.mark.covers("demo.claim")\n'
+        "def test_it(fx):\n    assert True\n"
+    )
+    (rec,) = inner.records()
+    assert rec["outcome"] == "error"
+
+
+# --- adapter.skip_records_skip ---------------------------------------------------
+
+SKIPS = {
+    "runtime": inner_test("pytest.skip('later')"),
+    "skipif": inner_test("assert True", mark='@pytest.mark.skipif(True, reason="x")\n' + CLAIM),
+    "skip_mark": inner_test("assert True", mark='@pytest.mark.skip\n' + CLAIM),
+    "importorskip": inner_test("pytest.importorskip('no_such_module_xyz')"),
+}
+
+
+@pytest.mark.covers("adapter.skip_records_skip", subject=SUBJECT)
+@pytest.mark.covers("outcomes/skip", subject=SUBJECT)
+@pytest.mark.parametrize("name", sorted(SKIPS))
+def test_a_skipped_test_records_skip(inner, name):
+    inner.run(SKIPS[name])
+    (rec,) = inner.records()
+    assert rec["outcome"] == "skip"
+
+
+@pytest.mark.covers("adapter.skip_records_skip", subject=SUBJECT)
+def test_a_skip_in_setup_records_skip(inner):
+    inner.run(
+        "import pytest\n\n"
+        "@pytest.fixture\ndef need():\n    pytest.skip('no service')\n\n"
+        '@pytest.mark.covers("demo.claim")\n'
+        "def test_it(need):\n    assert True\n"
+    )
+    (rec,) = inner.records()
+    assert rec["outcome"] == "skip"
+
+
+# --- adapter.level_from_runner ---------------------------------------------------
+
+
+@pytest.mark.covers("adapter.level_from_runner", subject=SUBJECT)
+def test_the_level_is_the_runners_verbatim(inner):
+    inner.run(inner_test("pass"), level="integration")
+    (rec,) = inner.records()
+    assert rec["level"] == "integration"
+
+
+@pytest.mark.covers("adapter.level_from_runner", subject=SUBJECT)
+def test_a_test_that_changes_its_environment_cannot_change_level_or_place(inner, tmp_path):
+    elsewhere = tmp_path / "elsewhere"
+    inner.run(
+        inner_test(
+            "import os\n"
+            "os.environ['TEMPER_LEVEL'] = 'release'\n"
+            f"os.environ['TEMPER_EVIDENCE'] = {str(elsewhere)!r}\n"
+            "os.environ['TEMPER_RUN'] = 'forged'"
+        ),
+        run="real",
+    )
+    (rec,) = inner.records()
+    assert (rec["level"], rec["run"]) == ("unit", "real")
+    assert not elsewhere.exists()
+
+
+@pytest.mark.covers("adapter.level_from_runner", subject=SUBJECT)
+def test_a_mark_cannot_set_a_level(inner):
+    result = inner.run(
+        "import pytest\n\n"
+        '@pytest.mark.covers("demo.claim", level="release")\n'
+        "def test_it():\n    assert True\n"
+    )
+    assert result.ret != 0
+    result.stderr.fnmatch_lines(["*level*"])
+    assert inner.records() == []
+
+
+# --- adapter.silent_without_runner -----------------------------------------------
+
+
+@pytest.mark.covers("adapter.silent_without_runner", subject=SUBJECT)
+@pytest.mark.parametrize("missing", ["TEMPER_LEVEL", "TEMPER_EVIDENCE", "both", "empty"])
+def test_without_the_runner_environment_nothing_is_recorded(inner, tmp_path, monkeypatch, missing):
+    src = inner_test("assert True") + "\n" + inner_test("assert False", name="test_bad")
+    inner.pytester.makepyfile(test_inner=src)
+    for name in ("TEMPER_LEVEL", "TEMPER_EVIDENCE", "TEMPER_RUN"):
+        monkeypatch.delenv(name, raising=False)
+    if missing in ("TEMPER_EVIDENCE",):
+        monkeypatch.setenv("TEMPER_LEVEL", "unit")
+    if missing == "TEMPER_LEVEL":
+        monkeypatch.setenv("TEMPER_EVIDENCE", str(inner.dir))
+    if missing == "empty":
+        monkeypatch.setenv("TEMPER_LEVEL", "")
+        monkeypatch.setenv("TEMPER_EVIDENCE", "")
+    with_plugin = inner.pytester.runpytest_subprocess()
+    without = inner.pytester.runpytest_subprocess("-p", "no:temper")
+    assert not inner.dir.exists()
+    assert with_plugin.ret == without.ret
+    # Without the plugin the marks are unknown and pytest warns; the results are the same.
+    def results(r):
+        return {k: v for k, v in r.parseoutcomes().items() if k != "warnings"}
+
+    assert results(with_plugin) == results(without)
+
+
+@pytest.mark.covers("adapter.silent_without_runner", subject=SUBJECT)
+def test_a_malformed_mark_is_ignored_without_the_runner(inner):
+    result = inner.run(
+        "import pytest\n\n"
+        '@pytest.mark.covers(42)\n'
+        "def test_it():\n    assert True\n",
+        runner=False,
+    )
+    assert result.ret == 0
+
+
+# --- adapter.never_truncates -----------------------------------------------------
+
+
+@pytest.mark.covers("adapter.never_truncates", subject=SUBJECT)
+def test_existing_evidence_is_untouched_and_each_process_has_its_own_file(inner):
+    inner.dir.mkdir()
+    old = inner.dir / "unit-1-deadbeef.jsonl"
+    old.write_bytes(b'{"covers":"old.claim","test":"t","level":"unit","outcome":"pass"}\n')
+    stray = inner.dir / "notes.txt"
+    stray.write_bytes(b"keep me")
+    inner.run(inner_test("pass"))
+    inner.run(inner_test("pass"))
+    assert old.read_bytes().startswith(b'{"covers":"old.claim"')
+    assert old.read_bytes().count(b"\n") == 1
+    assert stray.read_bytes() == b"keep me"
+    new = [f for f in inner.files() if f != old]
+    assert len(new) == 2
+    for f in new:
+        assert re.fullmatch(r"unit-\d+-[0-9a-f]{8}\.jsonl", f.name)
+
+
+@pytest.mark.covers("adapter.never_truncates", subject=SUBJECT)
+def test_the_evidence_directory_is_created_when_missing(inner, tmp_path):
+    deep = tmp_path / "a" / "b" / "evidence"
+    inner.run(inner_test("pass"), evidence=deep)
+    assert len(list(deep.glob("*.jsonl"))) == 1
+
+
+# --- claims ----------------------------------------------------------------------
+
+
+@pytest.mark.covers("adapter.python")
+def test_each_claim_is_its_own_record_with_the_same_outcome(inner):
+    inner.run(
+        "import pytest\n\n"
+        '@pytest.mark.covers("a.one")\n'
+        '@pytest.mark.covers("b.two", subject="s.x")\n'
+        '@pytest.mark.exempts("c.three", subject="s.y")\n'
+        "def test_it():\n    assert False\n"
+    )
+    recs = inner.records()
+    assert len(recs) == 3
+    assert {r["outcome"] for r in recs} == {"fail"}
+    by = {r.get("covers") or r["exempts"]: r for r in recs}
+    assert "exempts" in by["c.three"] and "covers" not in by["c.three"]
+    assert by["c.three"]["subject"] == "s.y"
+    assert "subject" not in by["a.one"]
+
+
+@pytest.mark.covers("adapter.python")
+def test_class_and_module_marks_apply_to_each_test_inside(inner):
+    inner.run(
+        "import pytest\n\n"
+        'pytestmark = pytest.mark.covers("mod.claim")\n\n'
+        '@pytest.mark.covers("cls.claim", subject="s")\n'
+        "class TestGroup:\n"
+        "    def test_a(self):\n        assert True\n"
+        "    def test_b(self):\n        assert True\n"
+    )
+    seen = sorted((r["test"].split("::")[-1], r["covers"]) for r in inner.records())
+    assert seen == [
+        ("test_a", "cls.claim"),
+        ("test_a", "mod.claim"),
+        ("test_b", "cls.claim"),
+        ("test_b", "mod.claim"),
+    ]
+
+
+@pytest.mark.covers("adapter.python")
+def test_the_same_claim_twice_is_one_record(inner):
+    inner.run(
+        "import pytest\n\n"
+        'pytestmark = pytest.mark.covers("same.claim", subject="s")\n\n'
+        '@pytest.mark.covers("same.claim", subject="s")\n'
+        "def test_it():\n    assert True\n"
+    )
+    assert len(inner.records()) == 1
+
+
+@pytest.mark.covers("adapter.python")
+def test_a_scenario_is_recorded_for_parametrized_scenario_runners(inner):
+    inner.run(
+        "import pytest\nimport temper\n\n"
+        '@pytest.mark.parametrize("sid", ["alerts.sold_out", "alerts.low"])\n'
+        "def test_scenario(request, sid):\n"
+        '    temper.covers(request, "alerts.low_stock", scenario=sid)\n'
+        '    temper.covers(request, sid, scenario=sid)\n'
+    )
+    recs = inner.records()
+    assert len(recs) == 4
+    assert {(r["covers"], r["scenario"]) for r in recs} == {
+        ("alerts.low_stock", "alerts.sold_out"),
+        ("alerts.sold_out", "alerts.sold_out"),
+        ("alerts.low_stock", "alerts.low"),
+        ("alerts.low", "alerts.low"),
+    }
+    assert list(recs[0]) == ["covers", "scenario", "test", "level", "outcome", "at"]
+
+
+@pytest.mark.covers("adapter.python")
+def test_a_runtime_claim_follows_the_tests_outcome(inner):
+    inner.run(
+        "import temper\n\n"
+        "def test_it(request):\n"
+        '    temper.covers(request, "late.claim")\n'
+        "    assert False\n"
+    )
+    (rec,) = inner.records()
+    assert (rec["covers"], rec["outcome"]) == ("late.claim", "fail")
+
+
+@pytest.mark.covers("adapter.python")
+def test_exempts_has_a_runtime_form_too(inner):
+    inner.run(
+        "import temper\n\n"
+        "def test_it(request):\n"
+        '    temper.exempts(request, "inv.x", subject="s")\n'
+    )
+    (rec,) = inner.records()
+    assert (rec["exempts"], rec["subject"], rec["outcome"]) == ("inv.x", "s", "pass")
+
+
+MALFORMED = {
+    "no reference": "@pytest.mark.covers()",
+    "empty reference": '@pytest.mark.covers("")',
+    "non-string reference": "@pytest.mark.covers(42)",
+    "second positional": '@pytest.mark.covers("a.b", "c")',
+    "unknown keyword": '@pytest.mark.covers("a.b", subjcet="s")',
+    "non-string subject": '@pytest.mark.covers("a.b", subject=3)',
+    "empty subject": '@pytest.mark.covers("a.b", subject="")',
+}
+
+
+@pytest.mark.covers("adapter.python")
+@pytest.mark.parametrize("name", sorted(MALFORMED))
+def test_a_malformed_mark_stops_the_run_loudly(inner, name):
+    result = inner.run(
+        "import pytest\n\n" + MALFORMED[name] + "\ndef test_it():\n    assert True\n"
+    )
+    assert result.ret != 0
+    result.stderr.fnmatch_lines(["*test_inner.py::test_it*"])
+    assert inner.records() == []
+
+
+@pytest.mark.covers("adapter.python")
+def test_an_unwritable_evidence_directory_stops_the_run_loudly(inner, tmp_path):
+    blocker = tmp_path / "file"
+    blocker.write_text("x")
+    result = inner.run(inner_test("pass"), evidence=blocker / "evidence")
+    assert result.ret != 0
+
+
+@pytest.mark.covers("adapter.python")
+def test_parallel_workers_write_separate_whole_lines(inner):
+    body = "".join(
+        f'@pytest.mark.covers("demo.claim")\ndef test_{i}():\n    assert True\n\n'
+        for i in range(40)
+    )
+    result = inner.run("import pytest\n\n" + body, "-n", "3")
+    assert result.ret == 0
+    assert len(inner.files()) >= 2
+    assert len(inner.records()) == 40
+    for line in inner.lines():
+        assert line.endswith("\n")

temper_python-0.1.0/tests/test_writer.py

@@ -0,0 +1,91 @@
+"""The evidence file writer, directly."""
+
+import json
+import os
+import re
+
+import pytest
+
+from temper import _evidence
+
+
+@pytest.mark.covers("adapter.never_truncates", subject="adapter.python")
+def test_each_record_is_one_write_in_append_mode(tmp_path, monkeypatch):
+    writes = []
+    real = os.write
+    monkeypatch.setattr(os, "write", lambda fd, data: (writes.append(data), real(fd, data))[1])
+    w = _evidence.Writer(tmp_path, "unit")
+    for i in range(5):
+        w.write({"covers": f"c.{i}", "test": "t", "level": "unit", "outcome": "pass"})
+    w.close()
+    assert len(writes) == 5
+    assert all(d.endswith(b"\n") and d.count(b"\n") == 1 for d in writes)
+    (f,) = tmp_path.glob("*.jsonl")
+    assert re.fullmatch(r"unit-%d-[0-9a-f]{8}\.jsonl" % os.getpid(), f.name)
+    assert len(f.read_bytes().splitlines()) == 5
+
+
+@pytest.mark.covers("adapter.never_truncates", subject="adapter.python")
+def test_two_writers_never_share_a_file(tmp_path):
+    a = _evidence.Writer(tmp_path, "unit")
+    b = _evidence.Writer(tmp_path, "unit")
+    a.write({"test": "t", "level": "unit", "outcome": "pass"})
+    b.write({"test": "t", "level": "unit", "outcome": "pass"})
+    a.close()
+    b.close()
+    assert len(list(tmp_path.glob("*.jsonl"))) == 2
+
+
+@pytest.mark.covers("adapter.never_truncates", subject="adapter.python")
+def test_nothing_is_created_until_the_first_record(tmp_path):
+    target = tmp_path / "evidence"
+    w = _evidence.Writer(target, "unit")
+    w.close()
+    assert not target.exists()
+
+
+@pytest.mark.covers("adapter.python")
+def test_a_forked_child_writes_to_its_own_file(tmp_path):
+    if not hasattr(os, "fork"):
+        pytest.skip("no fork on this platform")
+    w = _evidence.Writer(tmp_path, "unit")
+    w.write({"test": "parent", "level": "unit", "outcome": "pass"})
+    pid = os.fork()
+    if pid == 0:
+        try:
+            w.write({"test": "child", "level": "unit", "outcome": "pass"})
+        finally:
+            os._exit(0)
+    os.waitpid(pid, 0)
+    w.close()
+    files = sorted(tmp_path.glob("*.jsonl"))
+    assert len(files) == 2
+    for f in files:
+        assert len(f.read_bytes().splitlines()) == 1
+
+
+@pytest.mark.covers("adapter.python")
+def test_a_lone_surrogate_in_a_test_id_is_escaped_not_fatal(tmp_path):
+    w = _evidence.Writer(tmp_path, "unit")
+    w.write({"test": "bad\ud800id", "level": "unit", "outcome": "pass"})
+    w.close()
+    (f,) = tmp_path.glob("*.jsonl")
+    assert json.loads(f.read_bytes())["test"] == "bad\ud800id"
+
+
+@pytest.mark.covers("adapter.python")
+def test_non_ascii_is_written_as_utf8_not_escaped(tmp_path):
+    w = _evidence.Writer(tmp_path, "unit")
+    w.write({"test": "héllo日本", "level": "unit", "outcome": "pass"})
+    w.close()
+    (f,) = tmp_path.glob("*.jsonl")
+    assert "héllo日本".encode("utf-8") in f.read_bytes()
+
+
+@pytest.mark.covers("adapter.python")
+def test_a_level_cannot_escape_the_directory_through_the_file_name(tmp_path):
+    w = _evidence.Writer(tmp_path / "ev", "../../x/y")
+    w.write({"test": "t", "level": "../../x/y", "outcome": "pass"})
+    w.close()
+    (f,) = (tmp_path / "ev").glob("*.jsonl")
+    assert "/" not in f.name