cot.tmppath 0.2.0__tar.gz → 0.3.0__tar.gz

cot_tmppath-0.3.0/CHANGELOG.md

@@ -0,0 +1,25 @@
+# Changelog
+
+<!-- towncrier release notes start -->
+
+## 0.3.0 (2026-10-08)
+
+### Added
+
+- The pytest binding replaces pytest's basetemp handling as a whole: `getbasetemp()` is the run folder (an xdist worker's own folder in the run), `tmp_path` and `mktemp()` folders are made inside it, and `config._tmp_path_factory` is the cot.tmppath factory. `--basetemp` names a root that holds the runs; it is reused when cot.tmppath made it, so repeated `pytester.runpytest()` calls work, and a folder cot.tmppath did not make is refused and never touched. New: `Root.ensure()`, and `Run.item(name, process=...)`.
+
+## 0.2.1 (2026-10-07)
+
+### Fixed
+
+- A crashed run whose pid was reused by another process is collected: holder files record the process start time on Linux and Windows. Before, the run counted as alive until that other process ended. macOS still relies on the pid alone.
+
+## 0.2.0 (2026-10-07)
+
+### Removed
+
+- The pytest plugin no longer provides the `py.path` fixtures `tmpdir` and `tmpdir_factory`; use `tmp_path` and `tmp_path_factory`.
+
+### Added
+
+- Build the core: `Root`, `Run`, the flat and pytest layouts, retention, pruning, liveness and atomic placement now work instead of raising `NotImplementedError`, so `-p cot.tmppath.overtake_pytest` provides working `tmp_path` and `tmp_path_factory` fixtures.

{cot_tmppath-0.2.0 → cot_tmppath-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cot.tmppath
-Version: 0.2.0
+Version: 0.3.0
 Summary: Hardened, fast management of related temporary folders
 Project-URL: Source, https://github.com/cogs-of-testing/cot.tmppath
 Author-email: Ronny Pfannschmidt <opensource@ronnypfannschmidt.de>

{cot_tmppath-0.2.0 → cot_tmppath-0.3.0}/docs/core.md

@@ -16,7 +16,8 @@ What `src/cot/tmppath/_api.py` does to keep the goals in
     .cot-trash-{pid}-{token}/  removed items of one process, until it closes
     test_foo/                  items, side by side
     test_foo-1/
-    gw0/                       process folders
+    gw0/                       process folders (one per xdist worker)
+      test_bar/                items made with process="gw0"
 ```
 
 Every name starting with `.cot-` is the library's; item names never do.
@@ -58,13 +59,14 @@ The default root adds two levels above this:
 ## Liveness and retention (G4, G5)
 
 - A process that starts or joins a run writes a holder file with its pid,
-  host and Linux boot id, and removes it when it closes the run. A run is
-  live while any holder may be alive: same host and boot, and the pid
-  exists. A holder from another host always counts as alive, so a run is
+  host, Linux boot id and process start time, and removes it when it closes
+  the run. A run is live while any holder may be alive: same host and boot,
+  the pid exists, and the process with that pid started when the holder
+  says. A holder from another host always counts as alive, so a run is
   never collected on a guess.
-- **Open:** a pid that is reused by an unrelated process keeps a crashed
-  run alive until that process ends. Recording the process start time would
-  close that gap.
+- The start time comes from `/proc` on Linux and `GetProcessTimes` on
+  Windows. **Open:** macOS has neither, so there a pid reused by an
+  unrelated process keeps a crashed run alive until that process ends.
 - Closing a run applies retention to the whole root: the newest
   `keep_runs` runs stay, older ones that are not live go, and so do runs
   older than `max_age`. The run being closed counts as the newest. A

{cot_tmppath-0.2.0 → cot_tmppath-0.3.0}/docs/goals.md

@@ -107,9 +107,9 @@ Time is a goal, not an afterthought, and it is measured.
   which today discards the folders of tests that error in setup or teardown.
 - Retention works with any root a caller gives the library, which
   `--basetemp` cannot do
-  ([#10829](https://github.com/pytest-dev/pytest/issues/10829)). For pytest's
-  `--basetemp` itself the rule is the opposite: it must name a new folder,
-  and nothing under it is ever deleted.
+  ([#10829](https://github.com/pytest-dev/pytest/issues/10829)). pytest's
+  `--basetemp` becomes such a root: it holds the runs, and only folders
+  cot.tmppath made there are ever removed.
 - Retention is kept per project, so one project's runs never push out
   another's (in pytest today, every project shares one `pytest-of-{user}`
   counter).

{cot_tmppath-0.2.0 → cot_tmppath-0.3.0}/docs/pytest-replacement.md

@@ -72,12 +72,12 @@ is not worth relying on.
    `Path`), or deliberately leaves them out to push a suite off `py.path`.
 2. **`tmp_path_factory` duck type.** `mktemp(basename, numbered=True)` and
    `getbasetemp()`, as pytester and existing plugins and conftests call them.
-3. **`--basetemp`.** It is still parsed and validated by pytest. The
-   replacement reads `config.option.basetemp` and treats it as a new folder
-   to create: an existing path is refused, because pytest's `--basetemp`
-   deletes whatever is there. Nothing under a `--basetemp` is ever deleted,
-   whatever the retention settings say; cleaning it up is the user's job.
-   xdist hands workers the controller's options, so workers skip the check.
+3. **`--basetemp`.** It is still parsed and validated by pytest, which
+   deletes whatever is there. The replacement reads `config.option.basetemp`
+   and uses it as a cot.tmppath root that holds the runs: it is created if
+   missing, adopted if empty, reused if cot.tmppath made it, and refused
+   otherwise, so nothing it did not make is ever touched. xdist hands
+   workers the controller's options, so workers skip the check.
 4. **xdist workers join the controller's run.** With A, xdist's `hasattr`
    check fails silently and workers get no basetemp at all. The replacement
    implements `pytest_configure_node` (as an `optionalhook`) to put the run's
@@ -115,8 +115,11 @@ above:
 - In its `pytest_addoption` it unregisters the `tmpdir` plugin and blocks the
   name, so `-p no:tmpdir` is not needed. A plugin given with `-p` is loaded
   while the command line is pre-parsed, before any `pytest_configure`, so the
-  tmpdir plugin never configures itself, `config._tmp_path_factory` never
-  exists, and legacypath skips its `tmpdir` fixtures **(verified)**.
+  tmpdir plugin never configures itself and legacypath skips its `tmpdir`
+  fixtures **(verified)**. The plugin sets `config._tmp_path_factory` to its
+  own factory, so plugins that use it (pytest-xdist among them) get
+  cot.tmppath's folders, and pytest's basetemp handling is replaced as a
+  whole.
 - The tmpdir plugin's ini options were already registered by then, so
   `tmp_path_retention_count` and `tmp_path_retention_policy` stay valid under
   `--strict-config`. If the user also passes `-p no:tmpdir`, the plugin
@@ -125,29 +128,24 @@ above:
   `getbasetemp`. It deliberately leaves out the `py.path` fixtures `tmpdir`
   and `tmpdir_factory` (point 1), so a suite that still uses them fails with
   "fixture not found" and has to move to `tmp_path`.
-- `getbasetemp()` is the process's own folder in the run, named by the
-  xdist controller (`gw0`, ...) or `main` without xdist, so
-  `getbasetemp().parent` is the run's shared folder, as with pytest under
-  xdist. Unlike pytest, `tmp_path` folders are not inside `getbasetemp()`:
-  items sit flat in the run.
+- `getbasetemp()` is the run folder. In an xdist worker it is the worker's
+  own folder in the run, named by the controller (`gw0`, ...), so
+  `getbasetemp().parent` is the run, as with pytest under xdist. As with
+  pytest, `tmp_path` and `mktemp` folders are made inside `getbasetemp()`
+  (`Run.item(name, process=...)`).
 - The run is started on first use, not at configure time, so a session that
   asks for no temporary folder creates nothing **(verified)**.
-- `--basetemp` must name a folder that does not exist yet; the plugin
-  refuses an existing one with a usage error **(verified)**, creates the new
-  one, and deletes nothing under it (`KEEP_EVERYTHING`).
+- `--basetemp` names the root that holds the runs. A non-empty folder that
+  cot.tmppath did not make, a symlink, or another user's folder is refused
+  with a usage error and left untouched **(verified)**. Retention applies
+  inside it as anywhere else, to runs cot.tmppath made.
 - Without `--basetemp`, the root is `Root.for_project(rootdir name)`, and
   pytest's retention settings map onto `Retention`: `failed` keeps only
   failed items, `none` keeps no runs.
-- **An existing folder that is empty and less than 10 seconds old** is used
-  with a `PytestWarning` instead of refused: it was made for this run by
-  whoever started pytest, and holds nothing to lose. This is what
-  `pytester.runpytest_subprocess` does: it always creates the `--basetemp`
-  folder just before starting pytest **(verified)**.
-- **Intentional break:** `pytester.runpytest` passes the same `--basetemp`
-  on every call in a test, so from the second call on the folder is neither
-  empty nor fresh and the run is refused. Tests that rely on that, and any
-  other caller that reuses a `--basetemp`, break on purpose; they must pass
-  a new path.
+- `pytester` works unchanged: `runpytest_subprocess` hands over a fresh empty
+  `--basetemp`, which is adopted, and inline `runpytest` passes the same
+  `--basetemp` on every call, which is reused because cot.tmppath made it
+  **(verified)**.
 - xdist workers get the root and run id through `pytest_configure_node` and
   join the controller's run.
 - An item's fate is decided at its `teardown` report from setup, call and

{cot_tmppath-0.2.0 → cot_tmppath-0.3.0}/src/cot/tmppath/_api.py

@@ -269,6 +269,7 @@ class Run:
         self._dir = folder
         self._token = f"{os.getpid()}-{secrets.token_hex(4)}"
         self._trash: Dir | None = None
+        self._processes: dict[str, Dir] = {}
         self._closed = False
 
     def _hold(self) -> None:
@@ -282,19 +283,27 @@ class Run:
             msg = f"run {self.path} is closed"
             raise ValueError(msg)
 
-    def item(self, name: str) -> Path:
-        """Create a new folder for ``name`` directly in the run folder."""
+    def item(self, name: str, *, process: str | None = None) -> Path:
+        """Create a new folder for ``name`` in the run folder, or inside
+        the process folder ``process`` when one is named."""
         self._check_open()
+        folder = self._dir if process is None else self._process_dir(process)
         layout = self._root.layout
         for _ in range(100_000):
-            candidate = _check_name(layout.item_name(self.path, name), "item")
+            candidate = _check_name(layout.item_name(folder.path, name), "item")
             try:
-                return self._dir.mkdir(candidate)
+                return folder.mkdir(candidate)
             except FileExistsError:
                 continue
-        msg = f"no free item name for {name!r} in {self.path}"
+        msg = f"no free item name for {name!r} in {folder.path}"
         raise FileExistsError(errno.EEXIST, msg)
 
+    def _process_dir(self, name: str) -> Dir:
+        if name not in self._processes:
+            self.process_folder(name)
+            self._processes[name] = self._dir.open_dir(name)
+        return self._processes[name]
+
     def process_folder(self, name: str) -> Path:
         """The folder of one process in this run, named by whoever manages
         the processes (for pytest-xdist, the controller names its workers).
@@ -321,7 +330,11 @@ class Run:
         """
         self._check_open()
         path = Path(path)
-        if path.parent != self.path:
+        if path.parent == self.path:
+            folder = self._dir
+        elif path.parent.parent == self.path and path.parent.name in self._processes:
+            folder = self._processes[path.parent.name]
+        else:
             msg = f"{path} is not an item of run {self.path}"
             raise ValueError(msg)
         if outcome is Outcome.FAILED or not self._root.retention.keep_failed_only:
@@ -332,7 +345,7 @@ class Run:
                 self._dir.mkdir(trash)
             self._trash = self._dir.open_dir(trash)
         with suppress(FileNotFoundError):
-            self._dir.rename(path.name, secrets.token_hex(8), into=self._trash)
+            folder.rename(path.name, secrets.token_hex(8), into=self._trash)
 
     @contextmanager
     def place(self, destination: Path) -> Iterator[Path]:
@@ -362,6 +375,9 @@ class Run:
                 holders.unlink(self._token)
         except FileNotFoundError:
             pass
+        for process in self._processes.values():
+            process.close()
+        self._processes.clear()
         if self._trash is not None:
             self._trash.close()
             reason = self._dir.rmtree(_TRASH + self._token)
@@ -551,6 +567,17 @@ class Root:
             folder = child
         return folder
 
+    def ensure(self) -> None:
+        """Create the root, or check an existing one, without starting a run.
+
+        Raises ``UnsafeRootError`` for anything the root may not use: a
+        symlink, another user's folder, or a non-empty folder cot.tmppath
+        did not create. Nothing in such a folder is touched.
+        """
+        folder = self._open(create=True)
+        assert folder is not None
+        folder.close()
+
     def start_run(self) -> Run:
         """Create a new run folder, held by this process."""
         root = self._open(create=True)

cot_tmppath-0.3.0/src/cot/tmppath/_owner.py

@@ -0,0 +1,141 @@
+"""Who holds a run, and whether they are still alive (G5)."""
+
+from __future__ import annotations
+
+import json
+import os
+import socket
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+
+def _boot_id() -> str:
+    # Linux names each boot; elsewhere a pid alone has to do
+    try:
+        return Path("/proc/sys/kernel/random/boot_id").read_text().strip()
+    except OSError:
+        return ""
+
+
+@dataclass(frozen=True)
+class Owner:
+    """A process: its pid, host, boot and start time, so a pid reused by
+    another process, after a reboot or on another machine is not mistaken
+    for it. ``boot`` and ``started`` are empty where the platform cannot
+    tell (macOS); the pid alone decides there."""
+
+    pid: int
+    host: str
+    boot: str
+    started: str = ""
+
+    @classmethod
+    def current(cls) -> Owner:
+        pid = os.getpid()
+        return cls(pid, socket.gethostname(), _BOOT, _process_start(pid))
+
+    def to_bytes(self) -> bytes:
+        return json.dumps(
+            {
+                "pid": self.pid,
+                "host": self.host,
+                "boot": self.boot,
+                "started": self.started,
+            }
+        ).encode()
+
+    @classmethod
+    def from_bytes(cls, data: bytes) -> Owner | None:
+        try:
+            raw = json.loads(data)
+            return cls(
+                int(raw["pid"]),
+                str(raw["host"]),
+                str(raw["boot"]),
+                # holder files written by 0.2.0 have no start time
+                str(raw.get("started", "")),
+            )
+        except (ValueError, KeyError, TypeError, AttributeError):
+            return None
+
+    def is_alive(self) -> bool:
+        """False only when this process is known to be gone.
+
+        An owner on another host cannot be checked from here, so it counts
+        as alive: a run is never collected on a guess.
+        """
+        here = Owner.current()
+        if self.host != here.host:
+            return True
+        if self.boot and here.boot and self.boot != here.boot:
+            return False
+        if not _pid_alive(self.pid):
+            return False
+        if self.started:
+            # a process with this pid exists; is it the one that wrote this?
+            now = _process_start(self.pid)
+            if now and now != self.started:
+                return False
+        return True
+
+
+_BOOT = _boot_id()
+
+if sys.platform == "win32":
+    import ctypes
+
+    _kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
+    _PROCESS_QUERY_LIMITED_INFORMATION = 0x1000
+    _STILL_ACTIVE = 259
+    _ERROR_ACCESS_DENIED = 5
+
+    class _FileTime(ctypes.Structure):
+        _fields_ = (("low", ctypes.c_ulong), ("high", ctypes.c_ulong))
+
+    def _process_start(pid: int) -> str:
+        handle = _kernel32.OpenProcess(_PROCESS_QUERY_LIMITED_INFORMATION, False, pid)
+        if not handle:
+            return ""
+        try:
+            times = [_FileTime() for _ in range(4)]
+            if not _kernel32.GetProcessTimes(
+                handle, *(ctypes.byref(time) for time in times)
+            ):
+                return ""
+            return str(times[0].high << 32 | times[0].low)
+        finally:
+            _kernel32.CloseHandle(handle)
+
+    def _pid_alive(pid: int) -> bool:
+        handle = _kernel32.OpenProcess(_PROCESS_QUERY_LIMITED_INFORMATION, False, pid)
+        if not handle:
+            return bool(ctypes.get_last_error() == _ERROR_ACCESS_DENIED)
+        try:
+            code = ctypes.c_ulong()
+            if not _kernel32.GetExitCodeProcess(handle, ctypes.byref(code)):
+                return True
+            return code.value == _STILL_ACTIVE
+        finally:
+            _kernel32.CloseHandle(handle)
+
+else:
+
+    def _process_start(pid: int) -> str:
+        # Linux: field 22 of /proc/{pid}/stat, in clock ticks since boot;
+        # the name before it can hold spaces and parentheses
+        try:
+            stat = Path(f"/proc/{pid}/stat").read_text()
+        except OSError:
+            return ""
+        fields = stat.rpartition(")")[2].split()
+        return fields[19] if len(fields) > 19 else ""
+
+    def _pid_alive(pid: int) -> bool:
+        try:
+            os.kill(pid, 0)
+        except ProcessLookupError:
+            return False
+        except PermissionError:
+            return True
+        return True

{cot_tmppath-0.2.0 → cot_tmppath-0.3.0}/src/cot/tmppath/overtake_pytest.py

@@ -9,10 +9,15 @@ Loaded with ``-p``, it unregisters pytest's ``tmpdir`` plugin and provides
 ``tmp_path`` and ``tmp_path_factory`` itself. The ``py.path`` fixtures
 ``tmpdir`` and ``tmpdir_factory`` are left out on purpose: with the plugin
 on, a test that asks for them fails with "fixture not found".
-pytest's ``tmp_path_retention_count`` and ``tmp_path_retention_policy``
-settings keep working, and pytest-xdist workers join the controller's run.
-``--basetemp`` must name a folder that does not exist yet; it is created and
-nothing under it is ever deleted. See docs/pytest-replacement.md.
+It also sets ``config._tmp_path_factory``, so pytest's basetemp handling is
+replaced as a whole. pytest's ``tmp_path_retention_count`` and
+``tmp_path_retention_policy`` settings keep working.
+
+Layout: ``getbasetemp()`` is the run folder, and ``tmp_path`` folders are
+made inside it. An xdist worker's ``getbasetemp()`` is its own folder in the
+controller's run. ``--basetemp`` names the root that holds the runs; it is
+used only if it is missing, empty, or made by cot.tmppath, and only folders
+cot.tmppath made there are ever removed. See docs/pytest-replacement.md.
 
 This module imports pytest; the rest of cot.tmppath never does.
 """
@@ -21,8 +26,6 @@ from __future__ import annotations
 
 import os
 import re
-import stat
-import time
 import warnings
 from collections.abc import Generator
 from pathlib import Path
@@ -30,7 +33,7 @@ from typing import Any
 
 import pytest
 
-from ._api import KEEP_EVERYTHING, Outcome, Retention, Root, Run
+from ._api import Outcome, Retention, Root, Run, UnsafeRootError
 
 _RUN_ID = "cot_tmppath_run"
 _ROOT = "cot_tmppath_root"
@@ -81,17 +84,25 @@ class _State:
 
     def __init__(self, config: pytest.Config) -> None:
         self._config = config
+        self._root: Root | None = None
         self._run: Run | None = None
 
-    def _root(self) -> Root:
+    @property
+    def root(self) -> Root:
+        if self._root is None:
+            self._root = self._make_root()
+        return self._root
+
+    def _make_root(self) -> Root:
         retention = _retention(self._config)
         worker = getattr(self._config, "workerinput", None)
         if worker is not None:
             return Root(Path(worker[_ROOT]), retention=retention)
         basetemp = self._config.option.basetemp
         if basetemp:
-            # a folder the user named is never pruned, whatever retention says
-            return Root(Path(basetemp), retention=KEEP_EVERYTHING)
+            # a root like any other: runs go inside it, and only folders
+            # cot.tmppath made there are ever removed
+            return Root(Path(basetemp), retention=retention)
         temproot = os.environ.get("PYTEST_DEBUG_TEMPROOT")
         return Root.for_project(
             self._config.rootpath.name,
@@ -100,14 +111,16 @@ class _State:
         )
 
     @property
-    def process(self) -> str:
+    def process(self) -> str | None:
+        """The xdist worker's folder name; None for the controller and
+        for a run without xdist, whose folders go in the run itself."""
         worker = getattr(self._config, "workerinput", None)
-        return str(worker[_PROCESS]) if worker is not None else "main"
+        return str(worker[_PROCESS]) if worker is not None else None
 
     @property
     def run(self) -> Run:
         if self._run is None:
-            root = self._root()
+            root = self.root
             worker = getattr(self._config, "workerinput", None)
             if worker is not None:
                 self._run = root.join_run(worker[_RUN_ID])
@@ -126,50 +139,23 @@ class _State:
             )
 
 
-# An empty folder this young was made by whoever started pytest, for this
-# run, the way pytester's runpytest_subprocess does it.
-_FRESH_SECONDS = 10.0
-
-
 def _check_basetemp(config: pytest.Config) -> None:
-    basetemp = config.option.basetemp
-    # xdist hands workers the controller's options, by then the folder exists
-    if not basetemp or hasattr(config, "workerinput"):
+    # xdist hands workers the controller's options; the controller checked
+    if not config.option.basetemp or hasattr(config, "workerinput"):
         return
-    path = Path(basetemp)
     try:
-        info = path.lstat()
-    except FileNotFoundError:
-        return
-    # lstat, never stat: a symlink to a fresh empty folder is not fresh
-    owned = not hasattr(os, "getuid") or info.st_uid == os.getuid()
-    fresh = (
-        stat.S_ISDIR(info.st_mode)
-        and owned
-        and time.time() - info.st_mtime < _FRESH_SECONDS
-        and not any(path.iterdir())
-    )
-    if fresh:
-        config.issue_config_time_warning(
-            pytest.PytestWarning(
-                f"--basetemp={basetemp} already exists; using it because it is"
-                f" empty and less than {_FRESH_SECONDS:.0f}s old. Pass a path"
-                " that does not exist yet."
-            ),
-            stacklevel=2,
-        )
-        return
-    msg = (
-        f"--basetemp={basetemp} already exists. cot.tmppath only creates a"
-        " new folder there and never deletes one; remove it yourself or"
-        " name a path that does not exist yet."
-    )
-    raise pytest.UsageError(msg)
+        config.stash[_state].root.ensure()
+    except UnsafeRootError as error:
+        msg = f"--basetemp={config.option.basetemp}: {error.strerror}"
+        raise pytest.UsageError(msg) from None
 
 
 def pytest_configure(config: pytest.Config) -> None:
+    state = config.stash[_state] = _State(config)
     _check_basetemp(config)
-    config.stash[_state] = _State(config)
+    # what pytest's own tmpdir plugin sets: pytest-xdist and other plugins
+    # look for it, and get the cot.tmppath factory
+    config._tmp_path_factory = TempPathFactory(state)  # type: ignore[attr-defined]
 
 
 @pytest.hookimpl(optionalhook=True)
@@ -192,19 +178,21 @@ class TempPathFactory:
         self._state = state
 
     def getbasetemp(self) -> Path:
-        # per process, so getbasetemp().parent is the run's shared folder,
-        # as it is for pytest under xdist
-        return self._state.run.process_folder(self._state.process)
+        # the run; in an xdist worker its own folder in the run, so
+        # getbasetemp().parent is the run there, as it is for pytest
+        run, process = self._state.run, self._state.process
+        return run.path if process is None else run.process_folder(process)
 
     def mktemp(self, basename: str, numbered: bool = True) -> Path:
-        # Every item gets a unique name; numbered=False cannot promise the
-        # exact name in a run that other processes share.
-        return self._state.run.item(basename)
+        # Inside getbasetemp(), as pytest does. Every item gets a unique
+        # name; numbered=False cannot promise the exact name.
+        return self._state.run.item(basename, process=self._state.process)
 
 
 @pytest.fixture(scope="session")
 def tmp_path_factory(request: pytest.FixtureRequest) -> TempPathFactory:
-    return TempPathFactory(request.config.stash[_state])
+    factory: TempPathFactory = request.config._tmp_path_factory  # type: ignore[attr-defined]
+    return factory
 
 
 @pytest.fixture

{cot_tmppath-0.2.0 → cot_tmppath-0.3.0}/testing/test_concurrency.py

@@ -11,6 +11,7 @@ import pytest
 
 from conftest import run_python
 from cot.tmppath import Retention, Root
+from cot.tmppath._owner import Owner
 
 
 def test_another_process_can_join_a_run(root_path: Path) -> None:
@@ -87,3 +88,17 @@ def test_place_is_atomic(root_path: Path) -> None:
             staging.write_bytes(b"whole")
     assert destination.read_bytes() == b"whole"
     assert list(destination.parent.iterdir()) == [destination]
+
+
+@pytest.mark.skipif(
+    not Owner.current().started, reason="no process start time on this platform"
+)
+def test_reused_pid_does_not_keep_a_run_alive(root_path: Path) -> None:
+    run = Root(root_path).start_run()
+    # what a crashed holder looks like once its pid went to another process
+    here = Owner.current()
+    reused = Owner(here.pid, here.host, here.boot, started="0")
+    (holder,) = (run.path / ".cot-holders").iterdir()
+    holder.write_bytes(reused.to_bytes())
+    Root(root_path, retention=Retention(keep_runs=0)).prune()
+    assert not run.path.exists()

{cot_tmppath-0.2.0 → cot_tmppath-0.3.0}/testing/test_overtake_pytest.py

@@ -7,9 +7,7 @@ behaviour tests are xfail until the core is built.
 
 from __future__ import annotations
 
-import os
 import sys
-import time
 
 import pytest
 
@@ -31,7 +29,7 @@ def test_addopts_opt_in_takes_over(pytester: pytest.Pytester) -> None:
         def test_takeover(request, tmp_path_factory):
             config = request.config
             assert not config.pluginmanager.has_plugin("tmpdir")
-            assert not hasattr(config, "_tmp_path_factory")
+            assert config._tmp_path_factory is tmp_path_factory
             assert type(tmp_path_factory).__module__ == {PLUGIN!r}
         """
     )
@@ -147,18 +145,27 @@ def test_existing_basetemp_is_refused(pytester: pytest.Pytester) -> None:
     pytester.makepyfile("def test_nothing(): pass")
     result = _run(pytester, "-p", PLUGIN, f"--basetemp={existing}")
     assert result.ret == pytest.ExitCode.USAGE_ERROR
-    result.stderr.fnmatch_lines(["*--basetemp=*existing already exists*"])
+    result.stderr.fnmatch_lines(["*--basetemp=*not created by cot.tmppath*"])
     assert precious.read_text() == "keep me"
+    assert sorted(p.name for p in existing.iterdir()) == ["precious.txt"]
 
 
-def test_new_basetemp_is_created_and_never_pruned(pytester: pytest.Pytester) -> None:
+def test_basetemp_holds_the_runs_and_is_reused(pytester: pytest.Pytester) -> None:
     base = pytester.path / "new"
-    pytester.makeini(
-        "[pytest]\ntmp_path_retention_policy = none\ntmp_path_retention_count = 0\n"
+    pytester.makeini("[pytest]\ntmp_path_retention_count = 2\n")
+    pytester.makepyfile(
+        """
+        def test_layout(tmp_path, tmp_path_factory):
+            run = tmp_path_factory.getbasetemp()
+            assert tmp_path.parent == run
+            assert run.parent.name == "new"
+            (tmp_path / "f").touch()
+        """
     )
-    pytester.makepyfile("def test_passes(tmp_path): (tmp_path / 'f').touch()")
-    _run(pytester, "-p", PLUGIN, f"--basetemp={base}").assert_outcomes(passed=1)
-    assert list(base.rglob("f"))
+    for _ in range(3):
+        _run(pytester, "-p", PLUGIN, f"--basetemp={base}").assert_outcomes(passed=1)
+    # retention applies inside a --basetemp too, to runs cot.tmppath made
+    assert len([p for p in base.iterdir() if p.is_dir()]) == 2
 
 
 def test_xdist_workers_accept_the_new_basetemp(pytester: pytest.Pytester) -> None:
@@ -169,29 +176,24 @@ def test_xdist_workers_accept_the_new_basetemp(pytester: pytest.Pytester) -> Non
     result.assert_outcomes(passed=2)
 
 
-def test_fresh_empty_basetemp_is_used_with_a_warning(pytester: pytest.Pytester) -> None:
-    fresh = pytester.mkdir("fresh")
-    pytester.makepyfile("def test_nothing(): pass")
-    result = _run(pytester, "-p", PLUGIN, f"--basetemp={fresh}")
-    result.assert_outcomes(passed=1, warnings=1)
-    result.stdout.fnmatch_lines(["*--basetemp=*fresh already exists; using it*"])
+def test_empty_basetemp_is_adopted(pytester: pytest.Pytester) -> None:
+    empty = pytester.mkdir("empty")
+    pytester.makepyfile("def test_one(tmp_path): pass")
+    _run(pytester, "-p", PLUGIN, f"--basetemp={empty}").assert_outcomes(passed=1)
+    assert (empty / ".cot-tmppath").is_file()
 
 
-def test_old_empty_basetemp_is_refused(pytester: pytest.Pytester) -> None:
-    old = pytester.mkdir("old")
-    an_hour_ago = time.time() - 3600
-    os.utime(old, (an_hour_ago, an_hour_ago))
-    pytester.makepyfile("def test_nothing(): pass")
-    result = _run(pytester, "-p", PLUGIN, f"--basetemp={old}")
-    assert result.ret == pytest.ExitCode.USAGE_ERROR
-
-
-def test_pytesters_own_subprocess_runs_work_with_a_warning(
-    pytester: pytest.Pytester,
-) -> None:
-    pytester.makepyfile("def test_nothing(): pass")
-    result = pytester.runpytest_subprocess("-p", "no:cacheprovider", "-p", PLUGIN)
-    result.assert_outcomes(passed=1, warnings=1)
+def test_pytesters_runs_work(pytester: pytest.Pytester) -> None:
+    # runpytest_subprocess hands over a fresh empty --basetemp; inline runs
+    # reuse the same --basetemp for every call in a test
+    pytester.makepyfile("def test_one(tmp_path): pass")
+    for _ in range(2):
+        result = pytester.runpytest_subprocess("-p", "no:cacheprovider", "-p", PLUGIN)
+        result.assert_outcomes(passed=1)
+    pytester.makeconftest("")
+    for _ in range(2):
+        result = pytester.runpytest_inprocess("-p", "no:cacheprovider", "-p", PLUGIN)
+        result.assert_outcomes(passed=1)
 
 
 def test_symlink_to_a_fresh_empty_folder_is_refused(pytester: pytest.Pytester) -> None:
@@ -227,3 +229,24 @@ def test_getbasetemp_is_per_process_and_its_parent_is_the_run(
     result.assert_outcomes(passed=4)
     (run,) = [p for p in base.iterdir() if p.is_dir()]
     assert len(list(run.glob("shared-*"))) == 4
+
+
+@pytest.mark.parametrize("workers", [None, "2"])
+def test_folders_are_made_inside_getbasetemp(
+    pytester: pytest.Pytester, workers: str | None
+) -> None:
+    if workers:
+        pytest.importorskip("xdist")
+    pytester.makepyfile(
+        """
+        def test_tmp_path(tmp_path, tmp_path_factory):
+            assert tmp_path.parent == tmp_path_factory.getbasetemp()
+
+        def test_mktemp(tmp_path_factory):
+            made = tmp_path_factory.mktemp("made")
+            assert made.parent == tmp_path_factory.getbasetemp()
+        """
+    )
+    base = pytester.path / "new"
+    args = ["-n", workers] if workers else []
+    _run(pytester, "-p", PLUGIN, f"--basetemp={base}", *args).assert_outcomes(passed=2)

{cot_tmppath-0.2.0 → cot_tmppath-0.3.0}/testing/test_retention.py

@@ -17,6 +17,18 @@ def test_keep_failed_only_keeps_failed_items(root_path: Path) -> None:
     assert failed.is_dir()
 
 
+def test_items_in_a_process_folder_follow_retention(root_path: Path) -> None:
+    root = Root(root_path, retention=Retention(keep_failed_only=True))
+    with root.start_run() as run:
+        passed = run.item("test_ok", process="gw0")
+        failed = run.item("test_bad", process="gw0")
+        assert passed.parent == failed.parent == run.process_folder("gw0")
+        run.finish_item(passed, Outcome.PASSED)
+        run.finish_item(failed, Outcome.FAILED)
+    assert not passed.exists()
+    assert failed.is_dir()
+
+
 def test_custom_root_keeps_the_last_runs(root_path: Path) -> None:
     root = Root(root_path, retention=Retention(keep_runs=3))
     runs = []

cot_tmppath-0.2.0/CHANGELOG.md

@@ -1,13 +0,0 @@
-# Changelog
-
-<!-- towncrier release notes start -->
-
-## 0.2.0 (2026-10-07)
-
-### Removed
-
-- The pytest plugin no longer provides the `py.path` fixtures `tmpdir` and `tmpdir_factory`; use `tmp_path` and `tmp_path_factory`.
-
-### Added
-
-- Build the core: `Root`, `Run`, the flat and pytest layouts, retention, pruning, liveness and atomic placement now work instead of raising `NotImplementedError`, so `-p cot.tmppath.overtake_pytest` provides working `tmp_path` and `tmp_path_factory` fixtures.

cot_tmppath-0.2.0/src/cot/tmppath/_owner.py

@@ -1,92 +0,0 @@
-"""Who holds a run, and whether they are still alive (G5)."""
-
-from __future__ import annotations
-
-import json
-import os
-import socket
-import sys
-from dataclasses import dataclass
-from pathlib import Path
-
-
-def _boot_id() -> str:
-    # Linux names each boot; elsewhere a pid alone has to do
-    try:
-        return Path("/proc/sys/kernel/random/boot_id").read_text().strip()
-    except OSError:
-        return ""
-
-
-@dataclass(frozen=True)
-class Owner:
-    """A process: its pid, host and boot, so a reused pid after a reboot
-    or on another machine is not mistaken for it."""
-
-    pid: int
-    host: str
-    boot: str
-
-    @classmethod
-    def current(cls) -> Owner:
-        return cls(os.getpid(), socket.gethostname(), _BOOT)
-
-    def to_bytes(self) -> bytes:
-        return json.dumps(
-            {"pid": self.pid, "host": self.host, "boot": self.boot}
-        ).encode()
-
-    @classmethod
-    def from_bytes(cls, data: bytes) -> Owner | None:
-        try:
-            raw = json.loads(data)
-            return cls(int(raw["pid"]), str(raw["host"]), str(raw["boot"]))
-        except (ValueError, KeyError, TypeError):
-            return None
-
-    def is_alive(self) -> bool:
-        """False only when this process is known to be gone.
-
-        An owner on another host cannot be checked from here, so it counts
-        as alive: a run is never collected on a guess.
-        """
-        here = Owner.current()
-        if self.host != here.host:
-            return True
-        if self.boot and here.boot and self.boot != here.boot:
-            return False
-        return _pid_alive(self.pid)
-
-
-_BOOT = _boot_id()
-
-if sys.platform == "win32":
-    import ctypes
-
-    _kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
-    _PROCESS_QUERY_LIMITED_INFORMATION = 0x1000
-    _STILL_ACTIVE = 259
-    _ERROR_ACCESS_DENIED = 5
-
-    def _pid_alive(pid: int) -> bool:
-        handle = _kernel32.OpenProcess(_PROCESS_QUERY_LIMITED_INFORMATION, False, pid)
-        if not handle:
-            return bool(ctypes.get_last_error() == _ERROR_ACCESS_DENIED)
-        try:
-            code = ctypes.c_ulong()
-            if not _kernel32.GetExitCodeProcess(handle, ctypes.byref(code)):
-                return True
-            return code.value == _STILL_ACTIVE
-        finally:
-            _kernel32.CloseHandle(handle)
-
-else:
-
-    def _pid_alive(pid: int) -> bool:
-        try:
-            os.kill(pid, 0)
-        except ProcessLookupError:
-            return False
-        except PermissionError:
-            return True
-        return True