cot.tmppath 0.1.0__py3-none-any.whl

cot/tmppath/__init__.py

@@ -0,0 +1,31 @@
+"""Hardened, fast management of related temporary folders."""
+
+from __future__ import annotations
+
+from ._api import (
+    KEEP_EVERYTHING,
+    FlatLayout,
+    Layout,
+    Outcome,
+    PrunePlan,
+    PruneReport,
+    PytestLayout,
+    Retention,
+    Root,
+    Run,
+    UnsafeRootError,
+)
+
+__all__ = [
+    "KEEP_EVERYTHING",
+    "FlatLayout",
+    "Layout",
+    "Outcome",
+    "PrunePlan",
+    "PruneReport",
+    "PytestLayout",
+    "Retention",
+    "Root",
+    "Run",
+    "UnsafeRootError",
+]

cot/tmppath/__main__.py

@@ -0,0 +1,118 @@
+"""``python -m cot.tmppath prune``: remove old runs, asking first.
+
+This is the application side, so unlike the library it prints and exits.
+It removes only what the library would: folders cot.tmppath created, owned
+by the current user, whose runs are not live.
+
+By default it lists what it would remove and asks for confirmation.
+``--dry-run`` only lists. Removing without asking needs a flag that is long
+on purpose, so nobody types it by accident or copies it without reading.
+"""
+
+from __future__ import annotations
+
+import argparse
+import re
+import sys
+from collections.abc import Sequence
+from pathlib import Path
+from typing import TextIO
+
+from ._api import Root
+
+NO_CONFIRMATION_FLAG = "--delete-without-asking-i-have-read-the-dry-run"
+
+_UNITS = {"s": 1, "m": 60, "h": 3600, "d": 86400, "w": 604800}
+
+
+def parse_duration(text: str) -> float:
+    """``30s``, ``15m``, ``12h``, ``7d`` or ``2w`` in seconds."""
+    match = re.fullmatch(r"(\d+)([smhdw])", text.strip())
+    if match is None:
+        msg = f"not a duration: {text!r} (use e.g. 30m, 12h, 7d)"
+        raise argparse.ArgumentTypeError(msg)
+    return int(match[1]) * _UNITS[match[2]]
+
+
+def _parser() -> argparse.ArgumentParser:
+    # no abbreviations: "--delete" must not expand to the long flag
+    parser = argparse.ArgumentParser(prog="python -m cot.tmppath", allow_abbrev=False)
+    commands = parser.add_subparsers(dest="command", required=True)
+    prune = commands.add_parser(
+        "prune", help="remove runs that retention no longer keeps", allow_abbrev=False
+    )
+    prune.add_argument("roots", nargs="*", type=Path, metavar="ROOT")
+    prune.add_argument(
+        "--all-projects",
+        action="store_true",
+        help="every project of the current user under the default location",
+    )
+    prune.add_argument(
+        "--older-than",
+        type=parse_duration,
+        metavar="DURATION",
+        help="also remove runs unused for this long (30m, 12h, 7d, 2w)",
+    )
+    mode = prune.add_mutually_exclusive_group()
+    mode.add_argument(
+        "--dry-run", action="store_true", help="only list what would be removed"
+    )
+    mode.add_argument(
+        NO_CONFIRMATION_FLAG,
+        dest="no_confirmation",
+        action="store_true",
+        help="remove without asking; for scripts, after checking --dry-run",
+    )
+    return parser
+
+
+def main(
+    argv: Sequence[str] | None = None,
+    *,
+    stdin: TextIO | None = None,
+    stdout: TextIO | None = None,
+) -> int:
+    stdin = sys.stdin if stdin is None else stdin
+    stdout = sys.stdout if stdout is None else stdout
+    parser = _parser()
+    args = parser.parse_args(argv)
+    if not args.roots and not args.all_projects:
+        parser.error("name at least one ROOT, or pass --all-projects")
+    asking = not (args.dry_run or args.no_confirmation)
+    if asking and not stdin.isatty():
+        parser.error(
+            "cannot ask for confirmation, stdin is not a terminal;"
+            f" use --dry-run, or {NO_CONFIRMATION_FLAG}"
+        )
+
+    roots = [Root(path) for path in args.roots]
+    if args.all_projects:
+        roots.extend(Root.all_projects())
+    plans = [root.plan_prune(older_than=args.older_than) for root in roots]
+    paths = [path for plan in plans for path in plan.paths]
+    if not paths:
+        print("nothing to remove", file=stdout)
+        return 0
+    for path in paths:
+        print(path, file=stdout)
+    if args.dry_run:
+        print(f"{len(paths)} folders would be removed (dry run)", file=stdout)
+        return 0
+    if asking:
+        print(f"remove these {len(paths)} folders? type 'yes': ", end="", file=stdout)
+        stdout.flush()
+        if stdin.readline().strip() != "yes":
+            print("nothing removed", file=stdout)
+            return 1
+
+    failed = 0
+    for plan in plans:
+        report = plan.apply()
+        for path, reason in report.failed:
+            failed += 1
+            print(f"could not remove {path}: {reason}", file=stdout)
+    return 1 if failed else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

cot/tmppath/_api.py

@@ -0,0 +1,205 @@
+"""The intended public API, as stubs.
+
+Nothing here is built yet: every entry point raises ``NotImplementedError``.
+The shapes exist so that ``testing/`` can state what the library is for
+(``docs/goals.md``) against real names, and so the tests flip from xfail to
+pass one by one as the core lands.
+"""
+
+from __future__ import annotations
+
+import enum
+from contextlib import AbstractContextManager
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import TYPE_CHECKING, Protocol
+
+if TYPE_CHECKING:
+    # typing_extensions is only needed by the type checker: no runtime deps
+    from typing_extensions import Self
+
+_NOT_BUILT = "cot.tmppath: not built yet, see docs/goals.md"
+
+
+class UnsafeRootError(OSError):
+    """A root, or a folder at a shared level, is not safe to use.
+
+    Raised for a symlink, a folder owned by another user, permissions
+    others can use, or an existing folder this library did not create.
+    """
+
+
+class Outcome(enum.Enum):
+    """What a host reports about an item when it is done with it."""
+
+    PASSED = "passed"
+    FAILED = "failed"
+
+
+@dataclass(frozen=True)
+class Retention:
+    """Which runs and items survive.
+
+    ``keep_failed_only`` removes an item's folder when its whole outcome
+    passed. ``keep_runs`` and ``max_age`` bound the runs kept per root.
+    ``KEEP_EVERYTHING`` deletes nothing at all.
+    """
+
+    keep_failed_only: bool = False
+    keep_runs: int | None = 3  # None: no limit
+    max_age: float | None = None
+
+
+_DEFAULT_RETENTION = Retention()
+KEEP_EVERYTHING = Retention(keep_failed_only=False, keep_runs=None)
+
+
+@dataclass(frozen=True)
+class PruneReport:
+    """What a prune removed, and what it could not remove, with why."""
+
+    removed: tuple[Path, ...] = ()
+    failed: tuple[tuple[Path, str], ...] = field(default=())
+
+
+@dataclass(frozen=True)
+class PrunePlan:
+    """Runs a prune selected, to show before anything is removed."""
+
+    paths: tuple[Path, ...] = ()
+
+    def apply(self) -> PruneReport:
+        """Remove exactly the planned paths that are still safe to remove.
+
+        Each one is checked again (marker, owner, owner dead), so a run that
+        came alive since the plan was made is skipped and reported.
+        """
+        raise NotImplementedError(_NOT_BUILT)
+
+
+class Layout(Protocol):
+    """Where runs and items go below a root. Layouts are policies."""
+
+    def run_name(self, root: Path) -> str: ...
+
+    def item_name(self, run: Path, name: str) -> str: ...
+
+
+class FlatLayout:
+    """The default: ``{root}/{run}/{item}``, items side by side."""
+
+    def run_name(self, root: Path) -> str:
+        raise NotImplementedError(_NOT_BUILT)
+
+    def item_name(self, run: Path, name: str) -> str:
+        raise NotImplementedError(_NOT_BUILT)
+
+
+class PytestLayout:
+    """Example policy: pytest's ``pytest-{N}/{testname}{M}`` layout."""
+
+    def run_name(self, root: Path) -> str:
+        raise NotImplementedError(_NOT_BUILT)
+
+    def item_name(self, run: Path, name: str) -> str:
+        raise NotImplementedError(_NOT_BUILT)
+
+
+class Run:
+    """One invocation's folder. Several processes may join the same run."""
+
+    path: Path
+    id: str
+
+    def item(self, name: str) -> Path:
+        """Create a new folder for ``name`` directly in the run folder."""
+        raise NotImplementedError(_NOT_BUILT)
+
+    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).
+
+        Unlike ``item``, the name is used exactly, and asking twice gives the
+        same folder. This is what ``getbasetemp()`` returns under pytest, so
+        ``getbasetemp().parent`` stays the run's shared folder.
+        """
+        raise NotImplementedError(_NOT_BUILT)
+
+    def finish_item(self, path: Path, outcome: Outcome) -> None:
+        """Report an item's whole outcome; retention decides its fate."""
+        raise NotImplementedError(_NOT_BUILT)
+
+    def place(self, destination: Path) -> AbstractContextManager[Path]:
+        """Give a staging path; move it to ``destination`` atomically on
+        success, discard it on error."""
+        raise NotImplementedError(_NOT_BUILT)
+
+    def close(self) -> PruneReport:
+        """Release this process's hold on the run and apply retention."""
+        raise NotImplementedError(_NOT_BUILT)
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(self, *exc_info: object) -> None:
+        self.close()
+
+
+class Root:
+    """The folder that holds one project's runs."""
+
+    path: Path
+
+    def __init__(
+        self,
+        path: Path,
+        *,
+        retention: Retention = _DEFAULT_RETENTION,
+        layout: Layout | None = None,
+    ) -> None:
+        raise NotImplementedError(_NOT_BUILT)
+
+    @classmethod
+    def for_project(
+        cls,
+        project: str,
+        *,
+        temproot: Path | None = None,
+        retention: Retention = _DEFAULT_RETENTION,
+        layout: Layout | None = None,
+    ) -> Root:
+        """The default root for ``project`` under the system temp folder.
+
+        The root is ``{temproot}/cot.tmppath-{user}/{project}``, with the
+        user as the uid on POSIX and the user name on Windows. The per-user
+        folder is private and owner-checked, so another user cannot block or
+        read a project's runs by creating its folder first. Touches nothing
+        on disk until the first run starts.
+        """
+        raise NotImplementedError(_NOT_BUILT)
+
+    def start_run(self) -> Run:
+        """Create a new run folder, locked by this process."""
+        raise NotImplementedError(_NOT_BUILT)
+
+    def join_run(self, run_id: str) -> Run:
+        """Join a run another process started, sharing its folder."""
+        raise NotImplementedError(_NOT_BUILT)
+
+    @classmethod
+    def all_projects(cls, *, temproot: Path | None = None) -> tuple[Root, ...]:
+        """Every project root of the current user under the default location."""
+        raise NotImplementedError(_NOT_BUILT)
+
+    def plan_prune(self, *, older_than: float | None = None) -> PrunePlan:
+        """What a prune would remove, without removing anything.
+
+        ``older_than`` (seconds) also selects runs unused for that long,
+        whatever retention says. Live runs are never selected.
+        """
+        raise NotImplementedError(_NOT_BUILT)
+
+    def prune(self) -> PruneReport:
+        """Remove runs that retention no longer keeps and whose owners are
+        gone: ``plan_prune().apply()``."""
+        raise NotImplementedError(_NOT_BUILT)

cot/tmppath/overtake_pytest.py

@@ -0,0 +1,251 @@
+"""Opt-in: replace pytest's tmp fixtures with cot.tmppath.
+
+Enable it per project with::
+
+    [pytest]
+    addopts = -p cot.tmppath.overtake_pytest
+
+Loaded with ``-p``, it unregisters pytest's ``tmpdir`` plugin and provides
+``tmp_path``, ``tmp_path_factory``, ``tmpdir`` and ``tmpdir_factory`` itself.
+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.
+
+This module imports pytest; the rest of cot.tmppath never does.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import stat
+import time
+import warnings
+from collections.abc import Generator
+from pathlib import Path
+from typing import Any
+
+import pytest
+from _pytest.compat import legacy_path
+
+from ._api import KEEP_EVERYTHING, Outcome, Retention, Root, Run
+
+_RUN_ID = "cot_tmppath_run"
+_ROOT = "cot_tmppath_root"
+_PROCESS = "cot_tmppath_process"
+_item_path = pytest.StashKey[Path]()
+_item_failed = pytest.StashKey[bool]()
+_state = pytest.StashKey["_State"]()
+
+
+def pytest_addoption(parser: pytest.Parser, pluginmanager: Any) -> None:
+    tmpdir = pluginmanager.get_plugin("tmpdir")
+    if tmpdir is not None:
+        # The tmpdir plugin already registered the retention ini options, so
+        # existing configurations stay valid under --strict-config.
+        pluginmanager.unregister(tmpdir)
+    else:
+        # Blocked by the user with -p no:tmpdir: its ini options are missing.
+        parser.addini(
+            "tmp_path_retention_count",
+            help="How many runs to keep (cot.tmppath).",
+            default="3",
+        )
+        parser.addini(
+            "tmp_path_retention_policy",
+            help="Which item folders to keep: all/failed/none (cot.tmppath).",
+            default="all",
+        )
+    pluginmanager.set_blocked("tmpdir")
+
+
+def _retention(config: pytest.Config) -> Retention:
+    count = int(config.getini("tmp_path_retention_count"))
+    policy = config.getini("tmp_path_retention_policy")
+    if count < 0 or policy not in ("all", "failed", "none"):
+        msg = (
+            "tmp_path_retention_count must be >= 0 and tmp_path_retention_policy"
+            f" all, failed or none; got {count!r} and {policy!r}"
+        )
+        raise pytest.UsageError(msg)
+    return Retention(
+        keep_failed_only=policy == "failed",
+        keep_runs=0 if policy == "none" else count,
+    )
+
+
+class _State:
+    """The run, started or joined on first use, never at configure time."""
+
+    def __init__(self, config: pytest.Config) -> None:
+        self._config = config
+        self._run: Run | None = None
+
+    def _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)
+        temproot = os.environ.get("PYTEST_DEBUG_TEMPROOT")
+        return Root.for_project(
+            self._config.rootpath.name,
+            temproot=Path(temproot) if temproot else None,
+            retention=retention,
+        )
+
+    @property
+    def process(self) -> str:
+        worker = getattr(self._config, "workerinput", None)
+        return str(worker[_PROCESS]) if worker is not None else "main"
+
+    @property
+    def run(self) -> Run:
+        if self._run is None:
+            root = self._root()
+            worker = getattr(self._config, "workerinput", None)
+            if worker is not None:
+                self._run = root.join_run(worker[_RUN_ID])
+            else:
+                self._run = root.start_run()
+            self._config.add_cleanup(self._close)
+        return self._run
+
+    def _close(self) -> None:
+        assert self._run is not None
+        for path, reason in self._run.close().failed:
+            # reported, never swallowed (docs/goals.md, G4)
+            warnings.warn(
+                pytest.PytestWarning(f"cot.tmppath could not remove {path}: {reason}"),
+                stacklevel=1,
+            )
+
+
+# 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"):
+        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)
+
+
+def pytest_configure(config: pytest.Config) -> None:
+    _check_basetemp(config)
+    config.stash[_state] = _State(config)
+
+
+@pytest.hookimpl(optionalhook=True)
+def pytest_configure_node(node: Any) -> None:
+    run = node.config.stash[_state].run
+    node.workerinput[_ROOT] = str(run.path.parent)
+    node.workerinput[_RUN_ID] = run.id
+    # the manager names each process's folder, workers never pick their own
+    node.workerinput[_PROCESS] = node.gateway.id
+
+
+class TempPathFactory:
+    """What ``tmp_path_factory`` returns.
+
+    It offers the part of pytest's factory that pytester, plugins and
+    conftests use: ``mktemp`` and ``getbasetemp``.
+    """
+
+    def __init__(self, state: _State) -> None:
+        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)
+
+    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)
+
+
+@pytest.fixture(scope="session")
+def tmp_path_factory(request: pytest.FixtureRequest) -> TempPathFactory:
+    return TempPathFactory(request.config.stash[_state])
+
+
+class TempdirFactory:
+    """What ``tmpdir_factory`` returns: the same, with ``py.path`` results."""
+
+    def __init__(self, factory: TempPathFactory) -> None:
+        self._factory = factory
+
+    def getbasetemp(self) -> Any:
+        return legacy_path(self._factory.getbasetemp())
+
+    def mktemp(self, basename: str, numbered: bool = True) -> Any:
+        return legacy_path(self._factory.mktemp(basename, numbered))
+
+
+@pytest.fixture(scope="session")
+def tmpdir_factory(tmp_path_factory: TempPathFactory) -> TempdirFactory:
+    return TempdirFactory(tmp_path_factory)
+
+
+@pytest.fixture
+def tmp_path(request: pytest.FixtureRequest, tmp_path_factory: TempPathFactory) -> Path:
+    path = tmp_path_factory.mktemp(re.sub(r"\W", "_", request.node.name))
+    request.node.stash[_item_path] = path
+    return path
+
+
+@pytest.fixture
+def tmpdir(tmp_path: Path) -> Any:
+    return legacy_path(tmp_path)
+
+
+@pytest.hookimpl(wrapper=True)
+def pytest_runtest_makereport(
+    item: pytest.Item, call: pytest.CallInfo[None]
+) -> Generator[None, pytest.TestReport, pytest.TestReport]:
+    report = yield
+    failed = item.stash.get(_item_failed, False) or report.failed
+    item.stash[_item_failed] = failed
+    # The fixture's own teardown runs before this report, so only here is
+    # the whole outcome (setup, call and teardown) known.
+    if report.when == "teardown" and _item_path in item.stash:
+        outcome = Outcome.FAILED if failed else Outcome.PASSED
+        item.config.stash[_state].run.finish_item(item.stash[_item_path], outcome)
+    return report

cot_tmppath-0.1.0.dist-info/METADATA

@@ -0,0 +1,54 @@
+Metadata-Version: 2.5
+Name: cot.tmppath
+Version: 0.1.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>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 1 - Planning
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# cot.tmppath
+
+A hardened, fast building block for related temporary folders: one folder
+per run, items side by side inside it, kept or removed by policy, safe with
+concurrent processes. For test runners (a pytest binding) and for
+cot.runsomewhere's bootstrap staging and worker scratch.
+
+Not built yet. The goals are in [docs/goals.md](docs/goals.md) and the
+background in [docs/research.md](docs/research.md). `src/cot/tmppath` holds
+the intended API as stubs that raise `NotImplementedError`, and `testing/`
+states the goals as tests, marked xfail until each behaviour lands.
+
+```bash
+uv run pytest -q
+uv run mypy
+uv run --group bench pytest benchmarks
+```
+
+pytest projects can opt in to having pytest's `tmp_path`, `tmp_path_factory`,
+`tmpdir` and `tmpdir_factory` replaced:
+
+```ini
+[pytest]
+addopts = -p cot.tmppath.overtake_pytest
+```
+
+How and why is in [docs/pytest-replacement.md](docs/pytest-replacement.md).
+
+Old runs can be removed by hand; it lists them and asks before removing:
+
+```bash
+python -m cot.tmppath prune --all-projects --older-than 7d
+```

cot_tmppath-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+cot/tmppath/__init__.py,sha256=kuKNVfx_DbvhHRHxYeaNsW_Oq6qPOldXd1_yna1wVe0,492
+cot/tmppath/__main__.py,sha256=WidLehvXI0Q-yAD0Xb38WZ-f_Jl0lsq8aOL7M7zAEgk,4038
+cot/tmppath/_api.py,sha256=6CCJGdgASVotS4hCu2kH-LWHeLos_0ZMF5gvwb_6Z1A,6568
+cot/tmppath/overtake_pytest.py,sha256=mTWKRXGyHkPgbtohBLqcn7PteNXVWkncB3NSgPiJ4JA,8684
+cot/tmppath/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cot_tmppath-0.1.0.dist-info/METADATA,sha256=ObujnRq2R19Huq5cnVOmfqqCUsTkYvpG0tVly8Sqn9I,1891
+cot_tmppath-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+cot_tmppath-0.1.0.dist-info/entry_points.txt,sha256=zgYeyXOz6EGmEqwr6gPrscBV2cL2EOu3o2Us34fxigI,58
+cot_tmppath-0.1.0.dist-info/licenses/LICENSE,sha256=ulVKrMFItPd1VE61kn5I5vjx5Ix4VCYeikZlwHcF6YQ,1085
+cot_tmppath-0.1.0.dist-info/RECORD,,

cot_tmppath-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

cot_tmppath-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cot-tmppath = cot.tmppath.__main__:main

cot_tmppath-0.1.0.dist-info/licenses/LICENSE

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