kaparoo-python 0.8.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

kaparoo/data/sequences/composers.py

@@ -150,10 +150,11 @@ class TransformedSequence[T_in, M_in, T_out = T_in, M_out = M_in](
 
     @override
     def get_meta(self, index: int) -> M_out:
-        """Pass `source`'s metadata through unchanged (valid only when `M_out == M_in`)."""
-        # Passthrough -- correct only when M_out == M_in. A subclass with a
-        # different M_out MUST override this; the cast cannot catch a missing
-        # override, since generics are erased at runtime.
+        """Pass `source`'s metadata through unchanged.
+
+        A subclass whose `M_out` differs from `M_in` must override this.
+        """
+        # The cast cannot catch a missing override -- generics are erased at runtime.
         return cast("M_out", self._source.get_meta(index))
 
 

kaparoo/data/sequences/templates.py

@@ -46,7 +46,7 @@ class FileListSequence[T, M = Path](DataSequence[T, M]):
 
     @cached_property
     def files(self) -> tuple[Path, ...]:
-        """Immutable snapshot of the full file paths, in order (built once)."""
+        """Immutable snapshot of the full file paths, in order."""
         return tuple(self.get_file(i) for i in range(len(self)))
 
     def get_file(self, index: int) -> Path:
@@ -130,7 +130,7 @@ class FileFolderSequence[T, M = Path](FileListSequence[T, M]):
 
     @abstractmethod
     def list_files(self, root: Path) -> list[Path]:
-        """Return the full Path of every file to expose, in order.
+        """Return the full `Path` of every file to expose, in order.
 
         Called once from `__init__` after `root` has been validated.
         Every returned path must be under `root`; construction raises

kaparoo/filesystem/__init__.py

@@ -3,6 +3,7 @@ __all__ = (
     "NotAFileError",
     "StagedDirectory",
     "StagedFile",
+    "UnsupportedExtensionError",
     "dir_empty",
     "dir_empty_unsafe",
     "dir_exists",
@@ -21,9 +22,12 @@ __all__ = (
     "ensure_path_exists",
     "ensure_paths_exist",
     "file_exists",
+    "file_extension",
     "files_exist",
     "make_dir",
     "make_dirs",
+    "normalize_extension",
+    "normalize_extensions",
     "path_exists",
     "paths_exist",
     "reserve_path",
@@ -49,7 +53,11 @@ from kaparoo.filesystem.directory import (
     make_dir,
     make_dirs,
 )
-from kaparoo.filesystem.exceptions import DirectoryNotFoundError, NotAFileError
+from kaparoo.filesystem.exceptions import (
+    DirectoryNotFoundError,
+    NotAFileError,
+    UnsupportedExtensionError,
+)
 from kaparoo.filesystem.existence import (
     dir_exists,
     dirs_exist,
@@ -68,6 +76,9 @@ from kaparoo.filesystem.search import search_dirs, search_files, search_paths
 from kaparoo.filesystem.staged import StagedDirectory, StagedFile
 from kaparoo.filesystem.utils import (
     ensure_file_extension,
+    file_extension,
+    normalize_extension,
+    normalize_extensions,
     reserve_path,
     reserve_paths,
     stringify_path,

kaparoo/filesystem/directory.py

@@ -243,7 +243,7 @@ def make_dirs(
 
 
 def dir_empty_unsafe(path: StrPath) -> bool:
-    """Check if a directory is empty, skipping the existence check.
+    """Test whether a directory is empty, skipping the existence check.
 
     The caller must guarantee `path` is an existing directory; otherwise the
     underlying `os.scandir` raises (`FileNotFoundError`, `NotADirectoryError`).
@@ -253,7 +253,7 @@ def dir_empty_unsafe(path: StrPath) -> bool:
 
 
 def dirs_empty_unsafe(paths: StrPaths, *, root: StrPath | None = None) -> bool:
-    """Check if directories are empty, skipping existence checks.
+    """Test whether directories are empty, skipping existence checks.
 
     Each path carries the same caller obligation as `dir_empty_unsafe`.
     """
@@ -261,7 +261,7 @@ def dirs_empty_unsafe(paths: StrPaths, *, root: StrPath | None = None) -> bool:
 
 
 def dir_empty(path: StrPath) -> bool:
-    """Check if a directory is empty.
+    """Test whether a directory is empty.
 
     Args:
         path: The directory path to check.
@@ -278,7 +278,7 @@ def dir_empty(path: StrPath) -> bool:
 
 
 def dirs_empty(paths: StrPaths, *, root: StrPath | None = None) -> bool:
-    """Check if directories are empty.
+    """Test whether directories are empty.
 
     Args:
         paths: A sequence of directory paths to check.
@@ -299,7 +299,7 @@ def dirs_empty(paths: StrPaths, *, root: StrPath | None = None) -> bool:
 
 
 def dir_not_empty_unsafe(path: StrPath) -> bool:
-    """Check if a directory is not empty, skipping the existence check.
+    """Test whether a directory is not empty, skipping the existence check.
 
     Same caller obligation as `dir_empty_unsafe`.
     """
@@ -307,7 +307,7 @@ def dir_not_empty_unsafe(path: StrPath) -> bool:
 
 
 def dirs_not_empty_unsafe(paths: StrPaths, *, root: StrPath | None = None) -> bool:
-    """Check if directories are not empty, skipping existence checks.
+    """Test whether directories are not empty, skipping existence checks.
 
     Each path carries the same caller obligation as `dir_empty_unsafe`.
     """
@@ -315,7 +315,7 @@ def dirs_not_empty_unsafe(paths: StrPaths, *, root: StrPath | None = None) -> bo
 
 
 def dir_not_empty(path: StrPath) -> bool:
-    """Check if a directory is not empty.
+    """Test whether a directory is not empty.
 
     Args:
         path: The directory path to check.
@@ -332,7 +332,7 @@ def dir_not_empty(path: StrPath) -> bool:
 
 
 def dirs_not_empty(paths: StrPaths, *, root: StrPath | None = None) -> bool:
-    """Check if directories are not empty.
+    """Test whether directories are not empty.
 
     Args:
         paths: A sequence of directory paths to check.

kaparoo/filesystem/exceptions.py

@@ -1,8 +1,17 @@
-"""Filesystem exception types (`DirectoryNotFoundError`, `NotAFileError`)."""
+"""Filesystem exception types (`NotAFileError`, `UnsupportedExtensionError`, ...)."""
 
 from __future__ import annotations
 
-__all__ = ("DirectoryNotFoundError", "NotAFileError")
+__all__ = (
+    "DirectoryNotFoundError",
+    "NotAFileError",
+    "UnsupportedExtensionError",
+)
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
 
 
 class DirectoryNotFoundError(FileNotFoundError):
@@ -16,3 +25,43 @@ class DirectoryNotFoundError(FileNotFoundError):
 
 class NotAFileError(OSError):
     """Raised when a path exists but is not a file."""
+
+
+class UnsupportedExtensionError(ValueError):
+    """Raised when an extension is none of the supported ones.
+
+    A `ValueError` subclass, so existing `except ValueError` handlers still
+    catch it. `ext` and each entry of `supported` are normalized alike --
+    surrounding whitespace and leading dots are stripped, with case preserved
+    -- after which `supported` is de-duplicated and empty entries are dropped
+    (so `".jpg"`, `"jpg "`, and `"jpg"` collapse to a single `"jpg"`). The
+    optional `kind` (whitespace-stripped) names what the extension is for and,
+    when given, is woven into the message as `for <kind>`.
+
+    Raises:
+        ValueError: If `supported` names no usable extension -- empty, or
+            every entry normalizes to "".
+    """
+
+    def __init__(self, ext: str, supported: Iterable[str], kind: str = "") -> None:
+        def normalize(ext: str) -> str:
+            return ext.strip().lstrip(".")
+
+        supported = (normalize(ext) for ext in supported)
+        supported = tuple(dict.fromkeys(ext for ext in supported if ext))
+        if not supported:
+            msg = "supported must list at least one extension"
+            raise ValueError(msg)
+
+        self.ext = normalize(ext)
+        self.supported = supported
+        self.kind = kind.strip()
+
+        msg = f"unsupported extension {self.ext!r}"
+
+        if self.kind:
+            msg += f" for {self.kind}"
+
+        msg += f" (supported: {', '.join(repr(ext) for ext in self.supported)})"
+
+        super().__init__(msg)

kaparoo/filesystem/existence.py

@@ -63,7 +63,7 @@ def ensure_path_exists(path: StrPath, *, stringify: bool) -> Path | str: ...
 
 
 def ensure_path_exists(path: StrPath, *, stringify: bool = False) -> Path | str:
-    """Check if a given path exists and return it.
+    """Ensure a given path exists and return it.
 
     Args:
         path: The path to check for existence.
@@ -94,7 +94,7 @@ def ensure_file_exists(path: StrPath, *, stringify: bool) -> Path | str: ...
 
 
 def ensure_file_exists(path: StrPath, *, stringify: bool = False) -> Path | str:
-    """Check if a given path exists and is a file, and return it.
+    """Ensure a given path exists and is a file, and return it.
 
     Args:
         path: The file path to check for existence.
@@ -146,7 +146,7 @@ def ensure_dir_exists(
 def ensure_dir_exists(
     path: StrPath, *, make: bool | int = False, stringify: bool = False
 ) -> Path | str:
-    """Check if a given path exists and is a directory, and return it.
+    """Ensure a given path exists and is a directory, and return it.
 
     Args:
         path: The directory path to check for existence.
@@ -269,7 +269,7 @@ def ensure_paths_exist(
 def ensure_paths_exist(
     paths: StrPaths, *, root: StrPath | None = None, stringify: bool = False
 ) -> list[Path] | list[str]:
-    """Check if all of the given paths exist and return them.
+    """Ensure all of the given paths exist and return them.
 
     Args:
         paths: The paths to check for existence.
@@ -311,7 +311,7 @@ def ensure_files_exist(
 def ensure_files_exist(
     paths: StrPaths, *, root: StrPath | None = None, stringify: bool = False
 ) -> list[Path] | list[str]:
-    """Check if all of the given paths exist and are files, and return them.
+    """Ensure all of the given paths exist and are files, and return them.
 
     Args:
         paths: The file paths to check for existence.
@@ -370,7 +370,7 @@ def ensure_dirs_exist(
     make: bool | int = False,
     stringify: bool = False,
 ) -> list[Path] | list[str]:
-    """Check if all of the given paths exist and are directories, and return them.
+    """Ensure all of the given paths exist and are directories, and return them.
 
     Args:
         paths: The directory paths to check for existence.

kaparoo/filesystem/hierarchy/entry.py

@@ -205,6 +205,16 @@ class Entry(Node, ABC):
         """The deepest level below the parent (`None` is unbounded)."""
         return self._depth[1]
 
+    @property
+    def is_direct_child(self) -> bool:
+        """Whether the entry is pinned to exactly depth 1 (a direct child).
+
+        True only when `min_depth` and `max_depth` are both 1 -- the default,
+        unranged position. Any wider or deeper depth (`depth=2`, `depth=None`,
+        `depth=(1, 3)`, ...) is False.
+        """
+        return self.min_depth == 1 and self.max_depth == 1
+
     @property
     def required(self) -> bool:
         """Whether this entry must be present (vs optional)."""
@@ -256,7 +266,7 @@ class Entry(Node, ABC):
         `Filter` / `Condition` `_payload`, which is the *whole* field set.
         """
         payload: dict[str, Any] = {}
-        if self._depth != (1, 1):
+        if not self.is_direct_child:
             payload["depth"] = list(self._depth)
         if self._required:
             payload["required"] = True

kaparoo/filesystem/hierarchy/scaffold.py

@@ -7,79 +7,101 @@ __all__ = ("scaffold",)
 from pathlib import Path
 from typing import TYPE_CHECKING, cast
 
+from kaparoo.filesystem.exceptions import NotAFileError
 from kaparoo.filesystem.hierarchy.entry import Directory, Entry, File
 from kaparoo.filesystem.hierarchy.group import Exclusive, Group, Together
 from kaparoo.filters import Expandable
 
 if TYPE_CHECKING:
+    from collections.abc import Callable, Iterable
+
     from kaparoo.filesystem.hierarchy.base import Node
     from kaparoo.filesystem.types import StrPath
 
 
 def scaffold(
-    tree: Node, root: StrPath, *, root_as_top: bool = False, dry_run: bool = False
+    tree: Node,
+    root: StrPath,
+    *,
+    on_create: Callable[[Path, File], None] | None = None,
+    dirs_only: bool = False,
+    root_as_top: bool = False,
+    dry_run: bool = False,
 ) -> list[Path]:
     """Create the structure `tree` describes under `root`, returning new paths.
 
-    The write counterpart of `locate` / `validate`: by default `root` is the
-    *container*, so `tree`'s top node is created directly inside it (a
-    nonexistent `root` is created first). Only *enumerable* nodes are
-    materialized -- a node is creatable when its `name` is an `Expandable`
-    filter (`Literal`, `OneOf`, `Template`, `Without`, and the `str` /
-    `list[str]` sugar) **and** it sits at a fixed `depth` of 1. Open-ended
-    names (`Glob`, `Regex`, ...) and non-fixed depths are acceptance patterns,
-    not generators: they are skipped when optional, but a `required` one
-    cannot be satisfied and raises. Files are created empty (scaffold builds
-    the skeleton, not its contents).
-
-    Groups resolve to a single concrete shape: `Together` creates all its
-    members (or, if any is non-creatable, the whole group -- preserving
-    all-or-nothing -- unless `required`, which raises); `Exclusive` creates
-    the first alternative that is fully creatable (declaration order is the
-    priority), skipping non-creatable leading ones and raising only when none
-    is creatable and the group is `required`.
-
-    Creation is idempotent: an existing directory is descended without
-    change and an existing file is left untouched (never clobbered); only the
-    paths newly created are returned, in creation order. A path that exists
-    with the wrong kind (a file where a directory is described, or vice
-    versa) is a conflict and raises.
+    The write counterpart of `locate` / `validate`. Only *creatable* nodes are
+    materialized -- an enumerable `name` (`Literal` / `OneOf` / `Template` /
+    `Without` and the `str` / `list[str]` sugar) at a fixed `depth` of 1; open
+    names (`Glob`, `Regex`) and ranged depths are acceptance patterns, skipped
+    when optional and raising when `required`. Creation is idempotent and never
+    clobbers; files are created empty. Failure is best-effort: a mid-run raise
+    (a conflict, an unsatisfiable `required` node, or an `on_create` that
+    raises) leaves the paths already created in place -- there is no rollback,
+    but an idempotent re-run resumes safely. See the submodule README for the
+    group rules and worked examples.
 
     Args:
-        root_as_top: Treat `root` *itself* as the realized top rather than its
-            container. The top must be an `Entry` (a `Group` raises) and is
-            created only when its name matches `root`'s leaf name -- otherwise
-            it is skipped, or raises when `required`. A `Directory` top creates
-            `root` and its children; a `File` top creates `root` as an empty
-            file.
-        dry_run: When True, touch nothing on disk and return the paths that
-            *would* be created. The same checks run, so an unsatisfiable
-            `required` node or a type conflict still raises -- a faithful
-            preview.
+        on_create: Callback `on_create(path, file_node)` run once per file
+            actually created -- the seam for writing its content. Not called
+            for an untouched existing file, under `dry_run`, or with `dirs_only`.
+        dirs_only: Create only the directory skeleton, skipping every file
+            (including `required` ones). Defaults to False.
+        root_as_top: Treat `root` itself as the top node -- an `Entry` created
+            only when its name matches `root`'s leaf name -- rather than the
+            container holding it. Defaults to False.
+        dry_run: Return the paths that *would* be created without touching disk;
+            the same checks still raise. Defaults to False.
 
     Returns:
-        The newly created paths, in creation order (`dry_run` returns the
-        paths that would be created).
+        The newly created paths, in creation order.
 
     Raises:
-        ValueError: If a `required` node is not creatable, or a target path
-            exists with the wrong kind.
+        ValueError: If a `required` node is not creatable, or `on_create` is
+            combined with `dirs_only`.
+        NotADirectoryError: If the spec describes a directory where a file
+            exists.
+        NotAFileError: If the spec describes a file where a directory exists.
         TypeError: If `root_as_top` is set and `tree`'s top node is a `Group`.
     """
-    worker = Scaffolder(dry_run=dry_run)
+    worker = Scaffolder(dry_run=dry_run, dirs_only=dirs_only, on_create=on_create)
     worker.visit(tree, Path(root), root_as_top=root_as_top)
     return worker.created
 
 
 class Scaffolder:
-    """A single scaffold run: walks a spec, accumulating the paths it makes.
-
-    Bundles the `dry_run` flag and the `created` accumulator so the recursive
-    walk does not thread them through every call.
+    """A single, stateful walk that realizes a hierarchy spec on disk.
+
+    One instance drives one `scaffold` run: `visit` enters at the top -- `root`
+    as the container, or `root` itself with `root_as_top` -- and recurses,
+    dispatching each `Node` to a kind-specific handler. Only *creatable* nodes
+    are materialized: an `Entry` whose `name` is `Expandable` at a fixed depth
+    of 1, a `Together` whose members are all creatable, or an `Exclusive` with
+    at least one fully-creatable alternative (the first such, in order).
+    Non-creatable nodes are skipped, or raise when `required`. The walk assumes
+    `Node` is the closed `Entry` / `Group` world -- `_dispatch` and
+    `_node_creatable` reject anything else.
+
+    The run-wide options (`dry_run`, `dirs_only`, `on_create`) and the `created`
+    accumulator live on the instance so the recursion need not thread them
+    through every call. An instance is single-use: `created` holds the paths
+    made (or, under `dry_run`, that would be made) by its one walk.
     """
 
-    def __init__(self, *, dry_run: bool) -> None:
+    def __init__(
+        self,
+        *,
+        dry_run: bool,
+        dirs_only: bool = False,
+        on_create: Callable[[Path, File], None] | None = None,
+    ) -> None:
+        if dirs_only and on_create is not None:
+            msg = "on_create cannot be combined with dirs_only (no files are created)"
+            raise ValueError(msg)
+
         self.dry_run = dry_run
+        self.dirs_only = dirs_only
+        self.on_create = on_create
         self.created: list[Path] = []
 
     def visit(self, tree: Node, root: Path, *, root_as_top: bool = False) -> None:
@@ -107,31 +129,33 @@ class Scaffolder:
         entry = cast("Entry", tree)
         if not entry.name.matches(root.name):
             if entry.required:
-                msg = (
-                    f"cannot scaffold required {entry!r} at {root}: "
-                    f"its name does not match {root.name!r}"
-                )
+                msg = f"cannot scaffold required {entry!r} at {root}:"
+                msg += f" its name does not match {root.name!r}"
                 raise ValueError(msg)
-            return  # optional top whose name does not match `root`: skip
+            return
 
         self._ensure_dir(root.parent)  # the container that holds `root`
-        if isinstance(entry, Directory):
-            self._make_dir(root)
-            for child in entry.children:
-                self._dispatch(child, root)
-        else:
-            self._make_file(root)
+        match entry:
+            case File() if not self.dirs_only:
+                self._make_file(root, entry)
+            case Directory():
+                self._make_dir(root)
+                for child in entry.children:
+                    self._dispatch(child, root)
 
     def _dispatch(self, node: Node, parent: Path) -> None:
         """Dispatch one node to its kind-specific handler."""
-        if isinstance(node, File):
-            self._file(node, parent)
-        elif isinstance(node, Directory):
-            self._directory(node, parent)
-        elif isinstance(node, Together):
-            self._together(node, parent)
-        else:
-            self._exclusive(cast("Exclusive", node), parent)
+        match node:
+            case File():
+                self._file(node, parent)
+            case Directory():
+                self._directory(node, parent)
+            case Together():
+                self._together(node, parent)
+            case Exclusive():
+                self._exclusive(node, parent)
+            case _:
+                raise self._unexpected(node)
 
     def _ensure_dir(self, container: Path) -> None:
         """Create `container` (with parents) when missing, unless `dry_run`."""
@@ -141,61 +165,79 @@ class Scaffolder:
     def _skip_or_raise(self, node: Node, *, required: bool) -> None:
         """Skip a non-creatable node, or raise when it is `required`."""
         if required:
-            msg = (
-                f"cannot scaffold required {node!r}: its name is not "
-                f"enumerable, or its depth is not fixed at 1."
-            )
+            msg = f"cannot scaffold required {node!r}: it is not creatable."
+            msg += " A creatable node has an enumerable name and a fixed depth of 1."
             raise ValueError(msg)
 
+    def _unexpected(self, node: Node) -> TypeError:
+        """A `TypeError` for a node outside the closed `Entry` / `Group` world."""
+        name = type(node).__name__
+        return TypeError(
+            f"unsupported node type {name!r}: "
+            "expected File, Directory, Together, or Exclusive"
+        )
+
     def _creatable(self, entry: Entry) -> bool:
         """Whether `entry` has a concrete name and a fixed depth of 1."""
-        return (
-            isinstance(entry.name, Expandable)
-            and entry.min_depth == 1
-            and entry.max_depth == 1
-        )
+        return isinstance(entry.name, Expandable) and entry.is_direct_child
+
+    def _all_creatable(self, nodes: Iterable[Node]) -> bool:
+        """Whether every node in `nodes` can be fully materialized."""
+        return all(self._node_creatable(node) for node in nodes)
 
     def _node_creatable(self, node: Node) -> bool:
         """Whether `node` (an entry or nested group) can be fully materialized."""
-        if isinstance(node, Entry):
-            return self._creatable(node)
-        if isinstance(node, Together):
-            return all(self._node_creatable(member) for member in node.members)
-        exclusive = cast("Exclusive", node)
-        return any(
-            all(self._node_creatable(member) for member in side)
-            for side in exclusive.alternatives
-        )
-
-    def _make_file(self, path: Path) -> None:
-        """Create `path` as an empty file (idempotent); record it when new."""
+        match node:
+            case Entry():
+                return self._creatable(node)
+            case Together():
+                return self._all_creatable(node.members)
+            case Exclusive():
+                return any(self._all_creatable(side) for side in node.alternatives)
+            case _:
+                raise self._unexpected(node)
+
+    def _make_file(self, path: Path, node: File) -> None:
+        """Create `path` as an empty file (idempotent); record it when new.
+
+        A file actually created (not an existing one left untouched, and not
+        under `dry_run`) is then passed to the `on_create` hook -- the seam for
+        filling its content.
+        """
         if path.exists():
             if path.is_dir():
                 msg = f"cannot scaffold file {path}: a directory exists there."
-                raise ValueError(msg)
+                raise NotAFileError(msg)
             return  # idempotent: leave the existing file untouched
+
         if not self.dry_run:
             path.touch()
+
         self.created.append(path)
+        if self.on_create is not None and not self.dry_run:
+            self.on_create(path, node)
 
     def _make_dir(self, path: Path) -> None:
         """Create `path` as a directory (idempotent); record it when new."""
         if path.exists():
             if not path.is_dir():
                 msg = f"cannot scaffold directory {path}: a file exists there."
-                raise ValueError(msg)
+                raise NotADirectoryError(msg)
         else:
             if not self.dry_run:
                 path.mkdir()
             self.created.append(path)
 
     def _file(self, node: File, parent: Path) -> None:
+        if self.dirs_only:
+            return  # dirs_only: skip every file, required or not
+
         if not self._creatable(node):
             self._skip_or_raise(node, required=node.required)
             return
 
         for name in cast("Expandable", node.name).expand():
-            self._make_file(parent / name)
+            self._make_file(parent / name, node)
 
     def _directory(self, node: Directory, parent: Path) -> None:
         if not self._creatable(node):
@@ -209,8 +251,8 @@ class Scaffolder:
                 self._dispatch(child, path)
 
     def _together(self, node: Together, parent: Path) -> None:
-        if not all(self._node_creatable(member) for member in node.members):
-            # all-or-nothing: a non-creatable member skips the whole set
+        # all-or-nothing: a non-creatable member skips the whole set
+        if not self._node_creatable(node):
             self._skip_or_raise(node, required=node.required)
             return
 
@@ -219,7 +261,7 @@ class Scaffolder:
 
     def _exclusive(self, node: Exclusive, parent: Path) -> None:
         for side in node.alternatives:
-            if all(self._node_creatable(member) for member in side):
+            if self._all_creatable(side):
                 for member in side:
                     self._dispatch(member, parent)
                 return

kaparoo/filesystem/hierarchy/traverse/_utils.py

@@ -15,9 +15,6 @@ if TYPE_CHECKING:
 def _unique(pairs: Iterable[tuple[Path, Node]]) -> Iterator[tuple[Path, Node]]:
     """Stream `pairs`, suppressing ones already seen.
 
-    Args:
-        pairs: The `(path, node)` pairs to deduplicate.
-
     Yields:
         Each distinct pair in first-seen order (backed by a `seen` set).
     """
@@ -74,7 +71,7 @@ def _walk_depths(
 
 
 def _entry_accepts(entry: Entry, candidate: Path, depth: int) -> bool:
-    """Whether `entry` accepts `candidate` at `depth`.
+    """Test whether `entry` accepts `candidate` at `depth`.
 
     Adds the positional `accepts_depth` gate to `entry.matches` (name + kind) --
     the single source of the gates shared by `locate` and `validate`, run

kaparoo/filesystem/hierarchy/traverse/validate.py

@@ -159,6 +159,10 @@ def validate(
 
     Raises:
         TypeError: If `root_as_top` and `tree`'s top is a `Group`.
+        OSError: If a matched path cannot be read while checking its
+            `condition` (e.g. it was made inaccessible after `locate` matched
+            it). Condition checks read the filesystem, so an I/O error surfaces
+            rather than being absorbed into the report.
     """
     root = Path(root)
     excluder = build_excluder(exclude, root)
@@ -354,7 +358,7 @@ def _scan_under(
 def _ignores_extra(
     name: str, *, allow_extra: bool | Filter, extra_level: bool | Filter
 ) -> bool:
-    """Whether the directory's `allow_extra` or the blanket `extra_level` ignores `name`.
+    """Test whether `allow_extra` or the blanket `extra_level` ignores `name`.
 
     For each setting, `True` / `False` ignore all / none and a `Filter` ignores
     only matching names; the two are combined with OR.
@@ -386,7 +390,8 @@ def _scan_entries(
     setting) ignores a candidate matching no entry, it is kept out of `seen`,
     so it (and its subtree) is ignored rather than reported `unexpected`; each
     matched `Directory` is descended with its own `allow_extra` but the same
-    `extra_level`, so a strict subdirectory stays strict unless `extra_level` overrides it.
+    `extra_level`, so a strict subdirectory stays strict unless `extra_level`
+    overrides it.
 
     Args:
         entries: The leaf entries expected at or below `parent` (flattened).
@@ -593,7 +598,8 @@ def conformer(
             extra, unspecified entries.
 
     Returns:
-        A predicate that is `True` for a path realizing `spec`'s top.
+        A predicate that is `True` for a path realizing `spec`'s top. Like
+        `validate`, it surfaces a condition's filesystem errors as `OSError`.
     """
     tops = flatten_entries(spec)
     excluder = None  # conformer judges each candidate strictly; no exclusions

kaparoo/filesystem/utils.py

@@ -4,6 +4,9 @@ from __future__ import annotations
 
 __all__ = (
     "ensure_file_extension",
+    "file_extension",
+    "normalize_extension",
+    "normalize_extensions",
     "reserve_path",
     "reserve_paths",
     "stringify_path",
@@ -16,6 +19,8 @@ import os
 from pathlib import Path
 from typing import TYPE_CHECKING, overload
 
+from kaparoo.filesystem.exceptions import UnsupportedExtensionError
+
 if TYPE_CHECKING:
     from collections.abc import Iterable
     from typing import Literal
@@ -57,10 +62,6 @@ def stringify_path(
 ) -> str:
     """Convert a path to a string and optionally trim shared head/tail parts.
 
-    The result is normalized to POSIX form (`/` separators) on every platform;
-    a path left with no components (e.g. trimmed against itself) stringifies to
-    `"."`.
-
     Args:
         path: The path to be converted to a string.
         after: The leading base path to make `path` relative to. If provided,
@@ -68,6 +69,10 @@ def stringify_path(
         before: The trailing path to trim from `path`. If provided, returns
             only the part of `path` before `before`. Defaults to None.
 
+    Returns:
+        A POSIX-form string (`/` separators on every platform); `"."` when
+        nothing remains after trimming.
+
     Raises:
         ValueError: If `path` does not start with `after`,
             or does not end with `before`.
@@ -81,9 +86,6 @@ def stringify_paths(
 ) -> list[str]:
     """Convert a sequence of paths to strings and optionally trim shared parts.
 
-    Each result is normalized to POSIX form (`/` separators) on every platform;
-    see `stringify_path` for the per-path behavior.
-
     Args:
         paths: The sequence of paths to be converted to strings.
         after: The leading base path to make each path relative to. If provided,
@@ -91,6 +93,10 @@ def stringify_paths(
         before: The trailing path to trim from each path. If provided, returns
             only the part of each path before `before`. Defaults to None.
 
+    Returns:
+        A sequence of POSIX-form strings (`/` separators on every platform);
+        `"."` when nothing remains after trimming.
+
     Raises:
         ValueError: If any of `paths` does not start with `after`,
             or does not end with `before`.
@@ -379,52 +385,79 @@ def reserve_paths(
 # ========================== #
 
 
+def normalize_extension(ext: str, *, lowercase: bool = False) -> str:
+    """Strip surrounding whitespace and leading dots from an extension; lower-case when asked."""
+    ext = ext.strip().lstrip(".")
+    return ext.lower() if lowercase else ext
+
+
+def normalize_extensions(exts: Iterable[str], *, lowercase: bool = False) -> list[str]:
+    """Strip surrounding whitespace and leading dots from each extension; lower-case when asked."""
+    return [normalize_extension(ext, lowercase=lowercase) for ext in exts]
+
+
+def file_extension(path: StrPath, *, level: int = 1, lowercase: bool = True) -> str:
+    """Return the last (up to) `level` suffix(es) of `path`, dot-joined and normalized.
+
+    Args:
+        path: The path to read the extension from.
+        level: How many trailing suffixes to join. `level=2` turns `data.tar.gz`
+            into `"tar.gz"`. Defaults to 1.
+        lowercase: Whether to lower-case the result. Defaults to True.
+
+    Returns:
+        The dot-joined suffixes without a leading dot, or `""` when `path` has
+            no suffix.
+
+    Raises:
+        ValueError: If `level` is less than 1.
+    """
+    if level < 1:
+        msg = f"level must be >= 1, got {level}"
+        raise ValueError(msg)
+    suffix = "".join(Path(path).suffixes[-level:])
+    return normalize_extension(suffix, lowercase=lowercase)
+
+
 def ensure_file_extension(
     path: StrPath, ext: str | Iterable[str], *, add: bool = False
 ) -> Path:
     """Return `path` as a `Path`, requiring a case-insensitive `.<ext>` suffix.
 
-    A pure path check that never touches the filesystem. `ext` is a single
-    extension or an iterable of acceptable ones (e.g. `("jpg", "jpeg")`); the
-    leading dot on each is optional, so `"bin"` and `".bin"` behave the same.
-    Only the final suffix is considered: `archive.tar.gz` matches `ext="gz"`,
-    not `ext="tar.gz"`.
-
-    `add` mirrors `make` on `ensure_dir_exists`: when False (the default) a
-    path with no suffix raises like any other mismatch; when True, the missing
-    suffix is appended -- the *first* of `ext` when several are given, so pass
-    an ordered list/tuple if that matters. A *wrong* suffix always raises,
-    regardless of `add`.
+    A pure path check that never touches the filesystem. Only the final suffix
+    is considered, so `archive.tar.gz` matches `ext="gz"`, not `ext="tar.gz"`.
+    A wrong suffix always raises; `add` only fills in a missing one.
 
     Args:
         path: The path to check.
         ext: The required extension, or an iterable of acceptable ones, each
-            with or without a leading dot.
-        add: Whether to append the (first) extension when `path` has no
-            suffix, instead of raising. Defaults to False.
+            with or without a leading dot. Compared case-insensitively.
+        add: Whether to append the first of `ext` when `path` has no suffix,
+            instead of raising. Defaults to False.
 
     Returns:
         The path as a Path object, guaranteed to end in an accepted `.<ext>`.
 
     Raises:
-        ValueError: If `ext` is empty, or `path`'s final suffix is none of the
-            accepted extensions -- except the no-suffix case resolved by
-            `add=True`.
+        ValueError: If `ext` is empty.
+        UnsupportedExtensionError: If `path`'s final suffix is none of the
+            accepted extensions, except the no-suffix case resolved by
+            `add=True`. A `ValueError` subclass.
     """
     exts = [ext] if isinstance(ext, str) else list(ext)
-    exts = [e.removeprefix(".") for e in exts]
+    exts = list(dict.fromkeys(normalize_extensions(exts, lowercase=True)))
 
     if not exts:
         msg = "ext must name at least one extension"
         raise ValueError(msg)
 
     path = Path(path)
-    if add and not path.suffix:
+    path_ext = file_extension(path, lowercase=True)
+
+    if add and not path_ext:
         return path.with_suffix(f".{exts[0]}")
 
-    if path.suffix.lower() not in {f".{e.lower()}" for e in exts}:
-        wanted = " / ".join(f".{e}" for e in exts)
-        msg = f"{path.name} must have a {wanted} extension (got {path.suffix!r})"
-        raise ValueError(msg)
+    if path_ext not in exts:
+        raise UnsupportedExtensionError(path_ext, exts)
 
     return path

kaparoo/filters/enumerable.py

@@ -147,12 +147,12 @@ class OneOfFilter(Expandable):
 
 
 def _axis_repr(axis: tuple[object, ...]) -> str:
-    """Render a materialized axis, compacting an integer arithmetic
-    progression (three or more terms) to the equivalent `range(...)`.
+    """Render a materialized axis, compacting an integer progression to `range(...)`.
 
-    `range` is a valid axis input, so the compact form re-creates the same
-    axis. Anything else -- too short, irregular, or non-integer -- is shown
-    as its plain tuple.
+    An arithmetic progression of three or more integers becomes the
+    equivalent `range(...)` (a valid axis input, so it re-creates the same
+    axis); anything too short, irregular, or non-integer shows as its plain
+    tuple.
     """
     if len(axis) >= 3 and all(type(v) is int for v in axis):
         values = cast("tuple[int, ...]", axis)

kaparoo/filters/logical.py

@@ -64,7 +64,7 @@ class NaryLogicalFilter(LogicalFilter, ABC):
 @register_filter("and")
 @dataclass(frozen=True, repr=False)
 class AndFilter(NaryLogicalFilter):
-    """A filter matching strings that satisfy ALL of `children` (logical conjunction)."""
+    """A filter matching strings that satisfy ALL of `children`."""
 
     @override
     def matches(self, target: str) -> bool:
@@ -74,7 +74,7 @@ class AndFilter(NaryLogicalFilter):
 @register_filter("or")
 @dataclass(frozen=True, repr=False)
 class OrFilter(NaryLogicalFilter):
-    """A filter matching strings that satisfy AT LEAST ONE of `children` (disjunction)."""
+    """A filter matching strings that satisfy AT LEAST ONE of `children`."""
 
     @override
     def matches(self, target: str) -> bool:
@@ -84,7 +84,7 @@ class OrFilter(NaryLogicalFilter):
 @register_filter("not")
 @dataclass(frozen=True, repr=False)
 class NotFilter(LogicalFilter):
-    """A filter matching strings that do NOT satisfy `child` (logical negation)."""
+    """A filter matching strings that do NOT satisfy `child`."""
 
     child: Filter
 

kaparoo/utils/timer.py

@@ -30,7 +30,7 @@ class SpanRecord(TypedDict):
     lap) or by `measure` (the span of a wrapped block).
 
     Attributes:
-        label: The span's name. May carry a " (N)" suffix when produced
+        label: The span's name. May carry a `" (N)"` suffix when produced
             under `on_same_label="separate"`.
         duration: Length of this span, in the timer's `unit` and rounded
             by `ndigits` if given. For `lap`, the time since the previous
@@ -78,8 +78,8 @@ class Timer(ContextDecorator):
         """Initialize the timer with a reporting unit and optional precision.
 
         Args:
-            unit: The time unit for reported values. One of "s", "ms", "us",
-                "ns". Defaults to "s".
+            unit: The time unit for reported values. One of `"s"`, `"ms"`,
+                `"us"`, `"ns"`. Defaults to `"s"`.
             ndigits: The number of decimal places to round reported values to.
                 If None, no rounding is applied. Defaults to None.
 
@@ -236,7 +236,7 @@ class Timer(ContextDecorator):
             self._started = False
 
     def _finalize(self) -> None:
-        """Store the elapsed time in `elapsed`."""
+        """Capture the block's final elapsed duration on `with`-block exit."""
         elapsed_ns = time.perf_counter_ns() - self._start_time
         self._elapsed = self._format_time(elapsed_ns)
 
@@ -290,15 +290,15 @@ class SpanTimer(Timer):
         """Initialize the span timer.
 
         Args:
-            unit: The time unit for reported values. One of "s", "ms", "us",
-                "ns". Defaults to "s".
+            unit: The time unit for reported values. One of `"s"`, `"ms"`,
+                `"us"`, `"ns"`. Defaults to `"s"`.
             ndigits: The number of decimal places to round reported values
                 to. If None, no rounding is applied. Defaults to None.
             on_same_label: Behavior when a label passed to `lap` has been
-                used before in the same `with` block. "merge" records the
+                used before in the same `with` block. `"merge"` records the
                 label verbatim so duplicates aggregate in `summary`,
-                "separate" appends a " (N)" suffix so repeats stay distinct,
-                "reject" raises `ValueError`. Defaults to "merge".
+                `"separate"` appends a `" (N)"` suffix so repeats stay distinct,
+                `"reject"` raises `ValueError`. Defaults to `"merge"`.
 
         Raises:
             ValueError: If `unit` or `on_same_label` is not one of the
@@ -335,10 +335,6 @@ class SpanTimer(Timer):
         not included. Each record's `duration` is already rounded by
         `ndigits` (when set); this property sums those rounded values and
         rounds the sum once more.
-
-        Returns:
-            A mapping from label to total `duration` for that label, in the
-            timer's `unit`.
         """
         grouped: dict[str, float] = defaultdict(float)
         for record in self._records:
@@ -412,7 +408,7 @@ class SpanTimer(Timer):
 
         Raises:
             RuntimeError: If the timer has not been started, or is paused.
-            ValueError: If `on_same_label` is "reject" and `label` has
+            ValueError: If `on_same_label` is `"reject"` and `label` has
                 already been used in this `with` block.
         """
         self._ensure_started()
@@ -428,9 +424,12 @@ class SpanTimer(Timer):
 
         Unlike `lap`, which splits the timeline into contiguous spans,
         `measure` times only the wrapped region; time spent outside any
-        `measure` block is attributed to no span. Pauses inside the
-        block are excluded. A span is recorded only on clean exit -- if
-        the block raises, nothing is recorded and the exception propagates.
+        `measure` block is attributed to no span. Paused intervals inside the
+        block are excluded, but pause/resume must balance within it: a bare
+        `pause()` left open at the block's end raises -- wrap the excluded
+        region in `suspend()` instead. A span is recorded only on clean exit
+        -- if the block raises, nothing is recorded and the exception
+        propagates.
         Repeated labels follow `on_same_label`, exactly as `lap`. Do not
         nest `measure` blocks: each resets the shared baseline, so an outer
         block would record only the span after its inner block ends.
@@ -446,9 +445,9 @@ class SpanTimer(Timer):
             None. The wrapped block runs while the span is timed.
 
         Raises:
-            RuntimeError: If the timer has not been started, or is paused on
-                entry.
-            ValueError: If `on_same_label` is "reject" and `label` has
+            RuntimeError: If the timer has not been started, is paused on
+                entry, or is still paused at the block's end.
+            ValueError: If `on_same_label` is `"reject"` and `label` has
                 already been used in this `with` block.
         """
         self._ensure_started()
@@ -458,4 +457,10 @@ class SpanTimer(Timer):
 
         self._last_time = time.perf_counter_ns()
         yield
+        if self._paused:
+            msg = (
+                "measure() block ended while paused; balance pause/resume "
+                "inside it, or wrap the excluded part in `suspend()`."
+            )
+            raise RuntimeError(msg)
         self.lap(label)

{kaparoo_python-0.8.0.dist-info → kaparoo_python-0.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kaparoo-python
-Version: 0.8.0
+Version: 0.9.0
 Summary: Personally common and useful Python features
 Keywords: filesystem,pathlib,paths,glob,filters,pattern-matching,dataset,sequence,batching,timer,aggregation,metrics,utilities,typed
 Author: Jaewoo Park
@@ -61,7 +61,8 @@ Each submodule ships its own README with focused examples.
 `ensure_*` validators, `make_dir(s)` (with a destructive `clean` reset
 option), `dir_empty(s)`, `reserve_path(s)` guards for not-yet-existing
 destinations, `StagedFile` / `StagedDirectory` for safe (atomic) writes,
-path stringification, and a small exception hierarchy.
+path stringification, extension helpers (`ensure_file_extension`,
+`file_extension`, `normalize_extension(s)`), and a small exception hierarchy.
 
 ### [`kaparoo.filesystem.search`](https://github.com/kaparoo/kaparoo-python/tree/main/kaparoo/filesystem/search)
 

{kaparoo_python-0.8.0.dist-info → kaparoo_python-0.9.0.dist-info}/RECORD

@@ -2,24 +2,24 @@ kaparoo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kaparoo/data/__init__.py,sha256=dgbmVOVq_As2ovxRw_JQRdVjQ8d1UTkMFt_A50YfCfM,508
 kaparoo/data/sequences/__init__.py,sha256=3WPq8yDzGvGFXRxu0Dtbp0WPLga32qMDDkL_CZlmFpE,674
 kaparoo/data/sequences/base.py,sha256=dOCrhL-m3Mp2ZJmBYLKdlhgp4n05-zu0B_jcTlt6BPM,3313
-kaparoo/data/sequences/composers.py,sha256=dRweL9sTbdJSBE2nG0MYGEAyooB76FXnwXvZZomV4UM,16497
-kaparoo/data/sequences/templates.py,sha256=KVqNKaCYMlGIW4h5NZeQf9iMDLqP8YJTPhgOQoT4-XE,7237
+kaparoo/data/sequences/composers.py,sha256=ZiOphwjuJc-VcVlDcp4bWBi18lLEA2Dg1I_tvei8UO8,16420
+kaparoo/data/sequences/templates.py,sha256=YJnEBHU62ChwU-lc1U06iAZBCK1fNDSW5KBJmLqWeHU,7226
 kaparoo/data/sequences/utils.py,sha256=D5sa7431EZkTJ9k3m2-YKopNxl5Tt0Kyv_XjcrXIryQ,2344
-kaparoo/filesystem/__init__.py,sha256=SScOaANqX9Nagy_Bl_RPDoEYdM-DBjfUt6pB4H-gIHI,1729
-kaparoo/filesystem/directory.py,sha256=4ZR13SncBV6t1n1zy1gZHujHB3qOdyYNHJO5bKGO9Lc,11434
-kaparoo/filesystem/exceptions.py,sha256=JX9DebAKMlnowZqsDFC3HQkSRDisKp5ruGaWLRNNa-U,503
+kaparoo/filesystem/__init__.py,sha256=jBfSbMMMSpAlhkYrm6weR-jxlBZnAjwG1g--THa0PFU,1954
+kaparoo/filesystem/directory.py,sha256=tV3pv_b7xIxx9TqMLB_z_r60cw8VoH5S0gI8CvaM6UI,11466
+kaparoo/filesystem/exceptions.py,sha256=VfDrjzj28ERorJtVfyJPDSXKTiYuCl6aNz8gWGFfUsA,2171
 kaparoo/filesystem/exclude.py,sha256=3z0EkM0IQHJyBuVn8cRMKDvXBTNy4yNr6D9hmXjYZjo,3947
-kaparoo/filesystem/existence.py,sha256=o5bHXBvAEQHIpj6ElWa8KHyvuz_QllDbcpcXHXhV_mE,12822
+kaparoo/filesystem/existence.py,sha256=fRqo9UnMIAQhnpF4e7jtcNovuszLVdRFFw0rVSg86tQ,12810
 kaparoo/filesystem/hierarchy/__init__.py,sha256=Z4FVrYdrjNJnNjRUBrFrAwTIV8UruDMWaZ6j7C_rY2U,757
 kaparoo/filesystem/hierarchy/base.py,sha256=i1xVcdOrRoQ_lYdOILI1LznJIaJ8HpQm9SuBb6BrgZo,3624
 kaparoo/filesystem/hierarchy/conditions.py,sha256=IaIudfpeAbs9ZRM48xmmGETv7P50kXjyd1NLzEpW4IM,15652
-kaparoo/filesystem/hierarchy/entry.py,sha256=6wXKBs3SxDBDrx6GAOm-SUgLr87YS8zV0TTyw7VvHo4,14513
+kaparoo/filesystem/hierarchy/entry.py,sha256=NSrdPXhMLyepts0LBl9f_Kjpx8heOrQ_oLpolKxl788,14914
 kaparoo/filesystem/hierarchy/group.py,sha256=L4mx86VK_QdRi9eeEplEKCDlf1-VPe8Z1uxL_xrK5OQ,10421
-kaparoo/filesystem/hierarchy/scaffold.py,sha256=UbvNnKKca3QT2nnrORPmINUIFcA1yqsErO1YBpuAHlI,9431
+kaparoo/filesystem/hierarchy/scaffold.py,sha256=WNJEvt_oTlp0gNFIkwkYSw915mz-FsGDBQmkon2jdYo,11141
 kaparoo/filesystem/hierarchy/traverse/__init__.py,sha256=_jLWdaC7H1vz3iZGz7BoFpEuXy9WuTEKHBqdzTTQqAg,443
-kaparoo/filesystem/hierarchy/traverse/_utils.py,sha256=gE0DWFO7FV5yZdY85XlcQkmnknTBFTMCK-KgUSxUEHw,2965
+kaparoo/filesystem/hierarchy/traverse/_utils.py,sha256=7bJhvm2e3mIKaxcP0M4biCWKKVfrbRoSDaIrQUAjWcs,2903
 kaparoo/filesystem/hierarchy/traverse/locate.py,sha256=e-raO5m7bXLp8FUmaXb9lqSlO5Ay-Tv1tPh_b_z4bnM,6493
-kaparoo/filesystem/hierarchy/traverse/validate.py,sha256=dZHhnXAtQ5Uyp2j2FDzTiHGCuHcKQena5bphownKJug,21722
+kaparoo/filesystem/hierarchy/traverse/validate.py,sha256=LRTrP5UpI2Z8iXRH0qOvELq7eIPusw5BkgZysKm8MJM,22081
 kaparoo/filesystem/hierarchy/utils.py,sha256=4WEyu3-1gBb6YNQI1ODpGGdJ5X1btPs8Z3YFrnR-40g,1289
 kaparoo/filesystem/search/__init__.py,sha256=ypByMvVrUG96S37Efo-TuYko3UN9VJGejwQq6PoSsHQ,182
 kaparoo/filesystem/search/classes.py,sha256=z76J2mQExAr5ah47Qau4bemVPnUNmKxRXTPzWT9hJv0,7384
@@ -27,11 +27,11 @@ kaparoo/filesystem/search/wrappers.py,sha256=OE8C_TxauBuEprhKnMBKZSDG4flFHVilZxI
 kaparoo/filesystem/staged.py,sha256=fLQsh-YtCy6-KNUROMhhLEXnoVfuKDSEPxu1pJVLI9M,19743
 kaparoo/filesystem/types.py,sha256=BWTstlVTrdF4503E2wiXco0SN_pDJ_KTXhC1gXcNmvI,265
 kaparoo/filesystem/units.py,sha256=Bpk2aA-FGFR1d3He9Vl4J5R8MhcYg71Qd6E4th3qd8E,615
-kaparoo/filesystem/utils.py,sha256=qXrckMZg_WWY9hnQdT3SHL0evB__u--KnpoN__2Tx1s,13112
+kaparoo/filesystem/utils.py,sha256=rFN0lmD5goxinPCVmp6b6lIXq-7p1R4NAuiS-ZyHQd8,14140
 kaparoo/filters/__init__.py,sha256=XaRcOqt6UmmRFN6d_HHjLuDOvrEXjg3z_awfKYDQj10,1671
 kaparoo/filters/base.py,sha256=Nn8ufDXgPrN5aptqR6GzRgFlt3Ss4gHgLvc3LxhNHxE,4073
-kaparoo/filters/enumerable.py,sha256=QE3vPOLiO2A8OlLQ4hBiSfdfGA5pijgAf4M1SIr5v3U,11865
-kaparoo/filters/logical.py,sha256=TCcBWlw_gMbVqCQsj-Iwely8UNyZw1yBeO9GqfL8HZM,3385
+kaparoo/filters/enumerable.py,sha256=y2RRK_r3CmjGD7GDUlXo-gFmrmHHOQJPCjWrkdNgW78,11868
+kaparoo/filters/logical.py,sha256=XVTshFYkLPqz6B3E8gvyuRB8Di6bvU18XoGaRp4ncfU,3330
 kaparoo/filters/multi_pattern.py,sha256=k75J8k-ZK9nYRFPTqEQQr8lO9f19T8DA9n9gFFivQHA,4743
 kaparoo/filters/pattern.py,sha256=ty3k1tB2hmLNABfzQj79vZiL5fLc-PuE6167Dq5NXfY,6289
 kaparoo/filters/types.py,sha256=aNPYPimM9pr1Z9dUGuPHyk_457Q32vFSvjLWrzQrHU0,2185
@@ -41,8 +41,8 @@ kaparoo/utils/__init__.py,sha256=GHOu3smf_16ugrnYzICCGC9H7PwyOuPRYHNnK4lCXBg,100
 kaparoo/utils/aggregate.py,sha256=OG359CMn3mQLV_Wh_ODiuJXsg0Fi1RuCGQMrcMFvEiA,24290
 kaparoo/utils/checks.py,sha256=4Th2zfC-AkESmyLjUYBLx-iCkBbNNCm9gO4LEjIP2Wo,3756
 kaparoo/utils/optional.py,sha256=zXy_AkfrhsO8ziRSjO_i4kH9XRziGxzj-LVKA90mFPI,3535
-kaparoo/utils/timer.py,sha256=EfRYVa1ar-WSAj7lgBhYBVFzRzczOOXfMsghFU_k4ys,16791
-kaparoo_python-0.8.0.dist-info/licenses/LICENSE,sha256=hb6LWYP2rtcoz4V2HpawmblDfHwjwsg9N3cz0c5JQJE,1067
-kaparoo_python-0.8.0.dist-info/WHEEL,sha256=8ZlpUMJ7mlDirmlHRhDirEx_nPnARrwDjeE92mlk68E,81
-kaparoo_python-0.8.0.dist-info/METADATA,sha256=6yHnQwLztaGTwq6zETowszZJFWWp5RAMSAonPkmc_zM,6301
-kaparoo_python-0.8.0.dist-info/RECORD,,
+kaparoo/utils/timer.py,sha256=UOTJYNdBXE8ovaBjDeyU1hQxynD9kkno-Vq51wNZtdc,17191
+kaparoo_python-0.9.0.dist-info/licenses/LICENSE,sha256=hb6LWYP2rtcoz4V2HpawmblDfHwjwsg9N3cz0c5JQJE,1067
+kaparoo_python-0.9.0.dist-info/WHEEL,sha256=oBsDExVIEya4llboy9Ce1l6on8xt3GrtT29y6pYVypw,81
+kaparoo_python-0.9.0.dist-info/METADATA,sha256=aYgplAxb9DJU2A_JIu4wSRlhPIJV-bqtTzUgKJhAE2Y,6390
+kaparoo_python-0.9.0.dist-info/RECORD,,

{kaparoo_python-0.8.0.dist-info → kaparoo_python-0.9.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.11.21
+Generator: uv 0.11.23
 Root-Is-Purelib: true
 Tag: py3-none-any