patchcraft 0.5.1__cp312-abi3-win_amd64.whl

patchcraft/__init__.py

@@ -0,0 +1,56 @@
+"""PatchCraft: image patch extraction, pairing and reconstruction utilities."""
+
+from patchcraft._accel import accel_available
+from patchcraft.cache import Cache
+from patchcraft.extract import Patchify, extract
+from patchcraft.geometry import (
+    PairedTilingSpec,
+    TilingSpec,
+    num_patches,
+    paired_tilings,
+    scale_factor,
+    tilings,
+)
+from patchcraft.metrics import patch_metrics, per_patch_mse, per_patch_psnr
+from patchcraft.pair import PatchMeta, PatchPair, pair
+from patchcraft.reconstruct import reconstruct
+from patchcraft.resize import resize
+from patchcraft.stitch import WeightKind, stitch
+
+try:
+    # The redundant alias is the PEP 484 form for an explicit re-export, so
+    # `mypy --strict` in a consuming project accepts `patchcraft.__version__`.
+    from patchcraft._version import __version__ as __version__
+except ImportError:  # pragma: no cover - source tree that was never built
+    # importlib.metadata is the slow path and is only reached in a checkout
+    # with no build behind it, so the import cost never lands on real users.
+    from importlib.metadata import PackageNotFoundError
+    from importlib.metadata import version as _installed_version
+
+    try:
+        __version__ = _installed_version("patchcraft")
+    except PackageNotFoundError:
+        __version__ = "0+unknown"
+
+__all__ = [
+    "Cache",
+    "PairedTilingSpec",
+    "PatchMeta",
+    "PatchPair",
+    "Patchify",
+    "TilingSpec",
+    "WeightKind",
+    "accel_available",
+    "extract",
+    "num_patches",
+    "pair",
+    "paired_tilings",
+    "patch_metrics",
+    "per_patch_mse",
+    "per_patch_psnr",
+    "reconstruct",
+    "resize",
+    "scale_factor",
+    "stitch",
+    "tilings",
+]

patchcraft/_accel.py

@@ -0,0 +1,116 @@
+"""Bridge to the optional Rust accelerator (``patchcraft._accel_native``).
+
+The accelerator is a pyo3/Rust extension module compiled into this wheel on
+the platforms that have one. Where it is absent the wheel is pure Python and
+every path here reports unavailable. This module detects it at runtime and
+exposes a single primitive, :func:`fold_weighted`, for the overlap paths of
+``reconstruct`` and ``stitch``. Any failure at all, whether the extension was
+never built, the ABI mismatches, ``PATCHCRAFT_ACCEL=0`` is set in the
+environment or the tensor is ineligible, yields ``None``/``False`` and the
+caller falls back to the pure-torch path. Nothing here raises for an
+unavailable accelerator.
+"""
+from __future__ import annotations
+
+import importlib
+import os
+from types import ModuleType
+
+import torch
+
+__all__ = ["accel_available", "fold_weighted"]
+
+_ABI_VERSION_REQUIRED = 1
+
+_module: ModuleType | None = None
+_checked = False
+
+
+def _load() -> ModuleType | None:
+    """Import the native module once, cache the outcome, return it or None."""
+    global _checked, _module
+    if not _checked:
+        _checked = True
+        try:
+            mod = importlib.import_module("patchcraft._accel_native")
+        except ImportError:
+            pass
+        else:
+            if getattr(mod, "_ABI_VERSION", None) == _ABI_VERSION_REQUIRED:
+                _module = mod
+    return _module
+
+
+def _env_disabled() -> bool:
+    """Evaluated per call so tests/debugging can toggle without cache resets."""
+    return os.environ.get("PATCHCRAFT_ACCEL", "1") == "0"
+
+
+def accel_available() -> bool:
+    """Whether the overlap paths will use the native accelerator."""
+    return not _env_disabled() and _load() is not None
+
+
+def fold_weighted(
+    patches: torch.Tensor,
+    image_shape: tuple[int, int, int],
+    stride: tuple[int, int],
+    kernel: torch.Tensor | None,
+) -> torch.Tensor | None:
+    """Sum ``patches`` into a ``(C, H, W)`` image, optionally kernel-weighted.
+
+    ``out[c, y, x] = sum_p patches[p, c, y - row_p, x - col_p] * kernel[...]``
+    over the patches covering ``(y, x)``, which is the numerator of the overlap fold,
+    before the count/denominator division the caller performs. Summation per
+    pixel is in descending patch index (= ascending kernel offset), matching
+    ATen col2im's per-pixel order, the one order that is bit-exact against
+    ``F.fold``.
+
+    Returns ``None`` when the accelerator is unavailable or the input is
+    ineligible (non-CPU device, dtype outside float32/float64, mismatched
+    kernel); the caller then uses its pure-torch path. Geometry is NOT
+    validated here, because callers validate with ``check_fold_geometry`` first.
+    """
+    mod = None if _env_disabled() else _load()
+    if mod is None:
+        return None
+    if patches.device.type != "cpu":
+        return None
+    if patches.dtype not in (torch.float32, torch.float64):
+        return None
+    if patches.requires_grad:
+        # The native kernel writes a leaf tensor through raw pointers, so no
+        # autograd graph. Fall back to the differentiable torch path.
+        return None
+    if kernel is not None and (
+        kernel.dtype != patches.dtype or kernel.device != patches.device
+    ):
+        return None
+
+    c, h, w = image_shape
+    n, _c, ph, pw = patches.shape
+    sh, sw = stride
+
+    work = patches.contiguous()
+    kern = kernel.contiguous() if kernel is not None else None
+    out = torch.empty((c, h, w), dtype=work.dtype, device=work.device)
+    if work.numel() == 0 or out.numel() == 0:
+        return None
+
+    mod.fold_add(
+        work.data_ptr(),
+        out.data_ptr(),
+        n,
+        c,
+        ph,
+        pw,
+        h,
+        w,
+        sh,
+        sw,
+        kern.data_ptr() if kern is not None else None,
+        "f32" if work.dtype == torch.float32 else "f64",
+    )
+    # `work` and `kern` must stay alive until the native call returns; it is
+    # synchronous and both are still local references here, so this holds.
+    return out

patchcraft/_foldgeom.py

@@ -0,0 +1,87 @@
+"""Shared fold-geometry validation for reconstruct and stitch (THEORY §9.2/§9.9).
+
+The two functions enforced identical rules on the image/patch-grid
+relationship with ~60 lines of verbatim-duplicated validation; this module
+centralizes them. Error messages are byte-identical to the pre-refactor
+ones, with ``op`` filling the function-name slot.
+"""
+from __future__ import annotations
+
+import torch
+
+from patchcraft.extract import _as_pair
+
+__all__ = ["check_fold_geometry"]
+
+
+def check_fold_geometry(
+    patches: torch.Tensor,
+    image_shape: tuple[int, int, int],
+    stride: int | tuple[int, int],
+    dilation: int | tuple[int, int],
+    *,
+    op: str,
+) -> tuple[int, int, int, int]:
+    """Validate the fold geometry; return ``(h, w, num_h, num_w)``.
+
+    Caller owns the dtype/ndim checks (their messages differ between
+    ``reconstruct`` and ``stitch``); this owns everything from
+    ``image_shape`` shape-checking through grid/L consistency.
+    """
+    n_patches, c, ph, pw = patches.shape
+
+    if not (isinstance(image_shape, tuple) and len(image_shape) == 3):
+        raise ValueError(
+            f"image_shape must be a 3-tuple (C, H, W), got {image_shape!r}"
+        )
+    for axis_name, val in zip(("C", "H", "W"), image_shape, strict=True):
+        if not isinstance(val, int) or isinstance(val, bool) or val <= 0:
+            raise ValueError(
+                f"image_shape[{axis_name}] must be a positive int, got {val!r}"
+            )
+    target_c, h, w = image_shape
+    if target_c != c:
+        raise ValueError(
+            f"image_shape channels={target_c} does not match patches channel count {c}"
+        )
+
+    sh, sw = _as_pair(stride, "stride")
+    dh, dw = _as_pair(dilation, "dilation")
+
+    if dh != 1 or dw != 1:
+        raise ValueError(
+            f"{op} requires dilation==1, got dilation=({dh}, {dw}). "
+            "Patches extracted with dilation > 1 cannot round-trip; consume them as features."
+        )
+    if sh > ph or sw > pw:
+        raise ValueError(
+            f"{op} forbids stride > patch_size (partial coverage forbidden), "
+            f"got stride=({sh}, {sw}) and patch_size=({ph}, {pw})."
+        )
+
+    num_h = (h - ph) // sh + 1
+    num_w = (w - pw) // sw + 1
+    if num_h <= 0 or num_w <= 0:
+        raise ValueError(
+            f"image_shape={image_shape} too small for patch_size=({ph}, {pw}) "
+            f"and stride=({sh}, {sw})"
+        )
+    covered_h = (num_h - 1) * sh + ph
+    covered_w = (num_w - 1) * sw + pw
+    if covered_h != h or covered_w != w:
+        raise ValueError(
+            f"patch grid leaves pixels uncovered (partial coverage forbidden): "
+            f"image_shape={image_shape}, patch_size=({ph}, {pw}), "
+            f"stride=({sh}, {sw}) covers ({covered_h}, {covered_w}) of "
+            f"({h}, {w}). Choose a geometry with exact coverage "
+            f"(see patchcraft.tilings)."
+        )
+    expected_n_patches = num_h * num_w
+    if n_patches != expected_n_patches:
+        raise ValueError(
+            f"patches.shape[0]={n_patches} inconsistent with grid implied by "
+            f"image_shape={image_shape}, patch_size=({ph}, {pw}), "
+            f"stride=({sh}, {sw}): expected L={expected_n_patches} "
+            f"(num_h={num_h}, num_w={num_w})."
+        )
+    return (h, w, num_h, num_w)

patchcraft/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.5.1'
+__version_tuple__ = version_tuple = (0, 5, 1)
+
+__commit_id__ = commit_id = 'g375362d3b'

patchcraft/cache.py

@@ -0,0 +1,254 @@
+"""Content-addressed disk cache.
+
+Bytes in, bytes out. Optional ``zstandard`` compression (transparent fallback
+when not installed). Retry on transient ``PermissionError`` from OneDrive,
+antivirus, or the Windows Search indexer. Atomic write via ``*.tmp`` plus
+``os.replace``. Sidecar JSON carries the full key, version, content checksum.
+
+Contract: docs/THEORY.md §4 and §9.5.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import time
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+__all__ = ["Cache"]
+
+_WRITE_BACKOFF: tuple[float, ...] = (0.25, 0.5, 1.0, 2.0, 4.0)
+_READ_BACKOFF: tuple[float, ...] = (0.25,)
+
+
+def _retry[T](
+    op: Callable[[], T],
+    backoff: tuple[float, ...],
+) -> T:
+    """Retry ``op`` on ``PermissionError`` with the given backoff schedule.
+
+    First attempt is immediate; subsequent attempts sleep for
+    ``backoff[i-1]`` seconds. After exhausting the schedule the last
+    ``PermissionError`` is re-raised. All other exceptions propagate
+    immediately.
+    """
+    last: PermissionError | None = None
+    for attempt in range(len(backoff) + 1):
+        try:
+            return op()
+        except PermissionError as exc:
+            last = exc
+            if attempt < len(backoff):
+                time.sleep(backoff[attempt])
+    assert last is not None  # invariant from loop above
+    raise last
+
+
+def _try_zstandard() -> Any | None:
+    try:
+        import zstandard
+    except ImportError:
+        return None
+    return zstandard
+
+
+def _normalize_part(part: Any) -> Any:
+    """Coerce a key-part into something JSON-stable.
+
+    Lists and tuples both serialize as JSON arrays, so order matters. Dicts
+    are sorted by key. Bytes are hashed (avoids embedding binary blobs in
+    the key). Anything else falls back to ``repr``, which is explicit but uglier."""
+    if isinstance(part, (str, int, float, bool)) or part is None:
+        return part
+    if isinstance(part, (list, tuple)):
+        return [_normalize_part(p) for p in part]
+    if isinstance(part, dict):
+        return {str(k): _normalize_part(v) for k, v in sorted(part.items())}
+    if isinstance(part, bytes):
+        return {"__bytes_sha256__": hashlib.sha256(part).hexdigest()}
+    return {"__repr__": repr(part)}
+
+
+class Cache:
+    """Single-namespace content-addressed cache on disk.
+
+    ``root`` is created on construction if missing. ``namespace`` is used
+    as a subdirectory and as part of the key (so two namespaces never
+    collide even if a caller produces identical key parts). ``version``
+    is the invalidation lever: bump it, and old entries become
+    unreadable by construction without any delete.
+
+    Filenames address entries by the first 16 hex chars (64 bits) of the
+    full key. Two distinct keys sharing that prefix overwrite each other
+    on ``put``; ``get`` detects the mismatch via the sidecar and reports
+    a transparent miss, never wrong bytes. The birthday bound puts the
+    collision probability at ~50% only around 5e9 entries, so the prefix
+    stays at 16 chars; widen ``_paths`` if that ever stops being true.
+    """
+
+    def __init__(
+        self,
+        root: str | os.PathLike[str],
+        namespace: str,
+        version: int = 1,
+    ) -> None:
+        if not isinstance(namespace, str) or not namespace:
+            raise ValueError(
+                f"namespace must be a non-empty str, got {namespace!r}"
+            )
+        if not isinstance(version, int) or isinstance(version, bool) or version <= 0:
+            raise ValueError(f"version must be a positive int, got {version!r}")
+
+        self._namespace = namespace
+        self._version = version
+        self._root = Path(root) / namespace
+        self._root.mkdir(parents=True, exist_ok=True)
+        self._zstd = _try_zstandard()
+
+    @property
+    def root(self) -> Path:
+        return self._root
+
+    @property
+    def namespace(self) -> str:
+        return self._namespace
+
+    @property
+    def version(self) -> int:
+        return self._version
+
+    def key_for(self, *parts: Any) -> str:
+        """SHA-256 over a canonical JSON of ``parts``, namespace, version."""
+        canonical = {
+            "namespace": self._namespace,
+            "version": self._version,
+            "parts": [_normalize_part(p) for p in parts],
+        }
+        blob = json.dumps(canonical, sort_keys=True, separators=(",", ":")).encode()
+        return hashlib.sha256(blob).hexdigest()
+
+    def _paths(self, key: str) -> tuple[Path, Path]:
+        short = key[:16]
+        return self._root / f"{short}.bin", self._root / f"{short}.json"
+
+    def put(self, key: str, data: bytes) -> None:
+        """Store ``data`` under ``key``. Atomic; retries on transient races."""
+        if not isinstance(key, str):
+            raise TypeError(f"key must be str, got {type(key).__name__}")
+        if not isinstance(data, (bytes, bytearray, memoryview)):
+            raise TypeError(f"data must be bytes-like, got {type(data).__name__}")
+        data_bytes = bytes(data)
+
+        bin_path, sidecar_path = self._paths(key)
+
+        if self._zstd is not None:
+            cctx = self._zstd.ZstdCompressor(level=3)
+            payload = cctx.compress(data_bytes)
+            compressed = True
+        else:
+            payload = data_bytes
+            compressed = False
+
+        checksum = hashlib.sha256(data_bytes).hexdigest()
+        sidecar: dict[str, Any] = {
+            "key": key,
+            "namespace": self._namespace,
+            "version": self._version,
+            "checksum": checksum,
+            "compressed": compressed,
+            "size": len(data_bytes),
+        }
+
+        tmp_bin = bin_path.with_suffix(bin_path.suffix + ".tmp")
+        tmp_side = sidecar_path.with_suffix(sidecar_path.suffix + ".tmp")
+
+        def _write_payload() -> None:
+            with open(tmp_bin, "wb") as f:
+                f.write(payload)
+            os.replace(tmp_bin, bin_path)
+
+        def _write_sidecar() -> None:
+            with open(tmp_side, "w", encoding="utf-8") as f:
+                json.dump(sidecar, f)
+            os.replace(tmp_side, sidecar_path)
+
+        _retry(_write_payload, _WRITE_BACKOFF)
+        _retry(_write_sidecar, _WRITE_BACKOFF)
+
+    def get(self, key: str) -> bytes | None:
+        """Return cached bytes, or ``None`` if absent / version-mismatched.
+
+        Raises ``IOError`` on sidecar/payload mismatch (corrupt entry).
+        """
+        if not isinstance(key, str):
+            raise TypeError(f"key must be str, got {type(key).__name__}")
+
+        bin_path, sidecar_path = self._paths(key)
+        if not (bin_path.exists() and sidecar_path.exists()):
+            return None
+
+        def _read_sidecar() -> dict[str, Any]:
+            with open(sidecar_path, "rb") as f:
+                parsed = json.loads(f.read())
+            if not isinstance(parsed, dict):
+                raise OSError(
+                    f"sidecar at {sidecar_path} is not a JSON object"
+                )
+            return parsed
+
+        try:
+            sidecar = _retry(_read_sidecar, _READ_BACKOFF)
+        except FileNotFoundError:
+            return None
+
+        # Different key collided into the same 16-hex prefix? Treat as miss.
+        if sidecar.get("key") != key:
+            return None
+        # Stale version (cache invalidation lever). Transparent miss.
+        if sidecar.get("version") != self._version:
+            return None
+        if sidecar.get("namespace") != self._namespace:
+            return None
+
+        def _read_payload() -> bytes:
+            with open(bin_path, "rb") as f:
+                return f.read()
+
+        try:
+            payload = _retry(_read_payload, _READ_BACKOFF)
+        except FileNotFoundError:
+            return None
+
+        if sidecar.get("compressed"):
+            if self._zstd is None:
+                raise OSError(
+                    f"cache entry {key[:16]!r} is zstd-compressed but "
+                    "zstandard is not installed in this environment"
+                )
+            dctx = self._zstd.ZstdDecompressor()
+            try:
+                data: bytes = dctx.decompress(payload)
+            except self._zstd.ZstdError as exc:
+                # Compressed-payload corruption manifests here before checksum.
+                raise OSError(
+                    f"cache entry {key[:16]!r} payload corrupt (zstd decode "
+                    f"failed); remove it from {self._root} to invalidate"
+                ) from exc
+        else:
+            data = payload
+
+        if hashlib.sha256(data).hexdigest() != sidecar.get("checksum"):
+            raise OSError(
+                f"cache entry {key[:16]!r} checksum mismatch, corrupt; "
+                f"remove {bin_path.name} and {sidecar_path.name} from "
+                f"{self._root} to invalidate"
+            )
+        return data
+
+    def __repr__(self) -> str:
+        return (
+            f"Cache(root={str(self._root)!r}, namespace={self._namespace!r}, "
+            f"version={self._version})"
+        )

patchcraft/extract.py

@@ -0,0 +1,147 @@
+"""Patch extraction: strided-window fast path, F.unfold for dilation > 1.
+
+Contract: docs/THEORY.md §1 and §9.1, docs/ADR/0001-patch-extraction-api.md,
+docs/ADR/0002-patchify-transform.md.
+"""
+from __future__ import annotations
+
+import torch
+import torch.nn.functional as F  # noqa: N812 (torch convention)
+
+__all__ = ["Patchify", "extract"]
+
+
+# Dtypes that F.unfold (im2col) supports on CPU in torch 2.x. The dilation == 1
+# fast path is restricted to these to keep the accept/reject contract unchanged:
+# Tensor.unfold views accept any dtype, but integer dtypes must still raise
+# NotImplementedError from im2col, so they fall through to F.unfold as before.
+_FAST_PATH_DTYPES = frozenset(
+    {
+        torch.bool,
+        torch.float16,
+        torch.bfloat16,
+        torch.float32,
+        torch.float64,
+        torch.complex64,
+        torch.complex128,
+    }
+)
+
+
+def _as_pair(value: int | tuple[int, int], name: str) -> tuple[int, int]:
+    if isinstance(value, int) and not isinstance(value, bool):
+        if value <= 0:
+            raise ValueError(f"{name} must be positive, got {value}")
+        return (value, value)
+    if isinstance(value, tuple) and len(value) == 2:
+        h, w = value
+        h_ok = isinstance(h, int) and not isinstance(h, bool)
+        w_ok = isinstance(w, int) and not isinstance(w, bool)
+        if not (h_ok and w_ok):
+            raise ValueError(f"{name} must contain ints, got {value!r}")
+        if h <= 0 or w <= 0:
+            raise ValueError(f"{name} must be positive, got {value!r}")
+        return (h, w)
+    raise ValueError(f"{name} must be int or (int, int), got {value!r}")
+
+
+def extract(
+    image: torch.Tensor,
+    patch_size: int | tuple[int, int],
+    stride: int | tuple[int, int],
+    dilation: int | tuple[int, int] = 1,
+) -> torch.Tensor:
+    """Extract rectangular patches from a `(C, H, W)` image.
+
+    Returns `Tensor[L, C, ph, pw]` in row-major order. Patch `k` has its
+    top-left at `(k // num_w * sh, k % num_w * sw)`. Truncation is the only
+    boundary policy: if the geometry fits no patch, returns `Tensor[0, C, ph, pw]`.
+    Dtype and device of `image` are preserved.
+    """
+    if not isinstance(image, torch.Tensor):
+        raise TypeError(f"image must be torch.Tensor, got {type(image).__name__}")
+    if image.ndim != 3:
+        raise ValueError(f"image must have ndim==3 (C, H, W), got ndim={image.ndim}")
+
+    ph, pw = _as_pair(patch_size, "patch_size")
+    sh, sw = _as_pair(stride, "stride")
+    dh, dw = _as_pair(dilation, "dilation")
+
+    c, h, w = image.shape
+    eff_h = dh * (ph - 1) + 1
+    eff_w = dw * (pw - 1) + 1
+
+    if h < eff_h or w < eff_w:
+        return torch.empty(0, c, ph, pw, dtype=image.dtype, device=image.device)
+
+    if dh == 1 and dw == 1 and image.dtype in _FAST_PATH_DTYPES:
+        # Fast path: strided window view + one copy. Measured 13-21x faster
+        # than F.unfold (im2col) on CPU, bit-exact (same pixels, same order).
+        nh = (h - ph) // sh + 1
+        nw = (w - pw) // sw + 1
+        windows = image.unfold(1, ph, sh).unfold(2, pw, sw)  # (C, nh, nw, ph, pw)
+        out = windows.permute(1, 2, 0, 3, 4).reshape(nh * nw, c, ph, pw)
+        if out.untyped_storage().data_ptr() == image.untyped_storage().data_ptr():
+            # Degenerate geometry (e.g. ph == pw == 1): the permuted window is
+            # contiguous, reshape returned a view aliasing the image, and the
+            # contract promises independent memory.
+            out = out.clone()
+        return out
+
+    unfolded = F.unfold(
+        image.unsqueeze(0),
+        kernel_size=(ph, pw),
+        dilation=(dh, dw),
+        stride=(sh, sw),
+    )
+    return unfolded[0].view(c, ph, pw, -1).permute(3, 0, 1, 2).contiguous()
+
+
+class Patchify:
+    """Callable that extracts patches with a frozen geometry.
+
+    Drop-in for `torchvision.transforms.Compose([...])`:
+
+        transform = Compose([
+            ToTensor(),
+            GaussianBlur(kernel_size=3),
+            Patchify(patch_size=4, stride=2),
+        ])
+        patches = transform(pil_image)  # Tensor[L, C, 4, 4]
+
+    Equivalent to `lambda img: extract(img, patch_size, stride, dilation)`,
+    but composable, repr-friendly, and validates the geometry at construction
+    instead of at first call. Holds no state beyond the geometry: no cache,
+    no fixed image size, no device. See ADR 0002.
+
+    Output shape is `(L, C, ph, pw)`, the same as `extract`. Subsequent
+    transforms in the Compose chain receive the patch stack, not a single
+    patch; they must accept `(N, C, H, W)` or be wrapped.
+    """
+
+    __slots__ = ("_dh", "_dw", "_ph", "_pw", "_sh", "_sw")
+
+    def __init__(
+        self,
+        patch_size: int | tuple[int, int],
+        stride: int | tuple[int, int],
+        dilation: int | tuple[int, int] = 1,
+    ) -> None:
+        self._ph, self._pw = _as_pair(patch_size, "patch_size")
+        self._sh, self._sw = _as_pair(stride, "stride")
+        self._dh, self._dw = _as_pair(dilation, "dilation")
+
+    def __call__(self, image: torch.Tensor) -> torch.Tensor:
+        return extract(
+            image,
+            patch_size=(self._ph, self._pw),
+            stride=(self._sh, self._sw),
+            dilation=(self._dh, self._dw),
+        )
+
+    def __repr__(self) -> str:
+        return (
+            f"Patchify(patch_size=({self._ph}, {self._pw}), "
+            f"stride=({self._sh}, {self._sw}), "
+            f"dilation=({self._dh}, {self._dw}))"
+        )