patchcraft 0.2.0__py3-none-any.whl

patchcraft/stitch.py

@@ -0,0 +1,215 @@
+"""Stitch patches back into an image with configurable weighting kernels.
+
+Where :func:`patchcraft.reconstruct` is a bit-exact inverse of ``extract``,
+``stitch`` is intended for *modified* patches — patches that have been
+denoised, super-resolved, or otherwise altered — where overlap seams are
+visible if patches are averaged uniformly. Weighting by a window kernel
+(Hann, Gaussian) emphasizes patch centers and reduces those seams.
+
+With ``weight="uniform"``, ``stitch`` is mathematically equivalent to
+``reconstruct`` (down to floating-point ordering).
+
+Contract: docs/THEORY.md §2.5 and §9.9.
+"""
+from __future__ import annotations
+
+import math
+from typing import Literal
+
+import torch
+import torch.nn.functional as F  # noqa: N812 (torch convention)
+
+from patchcraft.extract import _as_pair
+
+__all__ = ["stitch"]
+
+
+WeightKind = Literal["uniform", "hann", "gaussian"]
+_WEIGHT_KINDS: tuple[WeightKind, ...] = ("uniform", "hann", "gaussian")
+
+
+def _hann_1d(n: int, dtype: torch.dtype, device: torch.device) -> torch.Tensor:
+    """Symmetric Hann window in ``[0, 1]``. ``n == 1`` is degenerate → ``[1.0]``."""
+    if n == 1:
+        return torch.ones(1, dtype=dtype, device=device)
+    i = torch.arange(n, dtype=dtype, device=device)
+    return 0.5 * (1.0 - torch.cos(2.0 * math.pi * i / (n - 1)))
+
+
+def _gaussian_1d(n: int, dtype: torch.dtype, device: torch.device) -> torch.Tensor:
+    """Gaussian centered at ``(n-1)/2`` with ``sigma = max(1, n/4)``."""
+    if n == 1:
+        return torch.ones(1, dtype=dtype, device=device)
+    sigma = max(1.0, n / 4.0)
+    center = (n - 1) / 2.0
+    i = torch.arange(n, dtype=dtype, device=device)
+    return torch.exp(-((i - center) ** 2) / (2.0 * sigma * sigma))
+
+
+def _window_kernel(
+    kind: WeightKind,
+    ph: int,
+    pw: int,
+    dtype: torch.dtype,
+    device: torch.device,
+) -> torch.Tensor:
+    """Build a ``(ph, pw)`` window as the outer product of two 1-D windows."""
+    if kind == "uniform":
+        return torch.ones(ph, pw, dtype=dtype, device=device)
+    if kind == "hann":
+        wh = _hann_1d(ph, dtype, device)
+        ww = _hann_1d(pw, dtype, device)
+        return wh.unsqueeze(1) * ww.unsqueeze(0)
+    if kind == "gaussian":
+        wh = _gaussian_1d(ph, dtype, device)
+        ww = _gaussian_1d(pw, dtype, device)
+        return wh.unsqueeze(1) * ww.unsqueeze(0)
+    raise ValueError(
+        f"weight must be one of {_WEIGHT_KINDS!r}, got {kind!r}"
+    )
+
+
+def stitch(
+    patches: torch.Tensor,
+    image_shape: tuple[int, int, int],
+    stride: int | tuple[int, int],
+    *,
+    weight: WeightKind = "uniform",
+    dilation: int | tuple[int, int] = 1,
+) -> torch.Tensor:
+    """Reassemble a ``(C, H, W)`` image from ``(L, C, ph, pw)`` with blendable weights.
+
+    Use ``stitch`` when patches have been modified (model output, denoised,
+    super-resolved). Use :func:`patchcraft.reconstruct` when patches came
+    straight from ``extract`` and you want a bit-exact inverse with no
+    extra arithmetic.
+
+    ``weight`` controls how overlapping patches are blended:
+
+    - ``"uniform"`` — each covering patch contributes equally. Mathematically
+      equivalent to ``reconstruct`` (no seam attenuation).
+    - ``"hann"`` — Hann window: full weight at patch center, zero at patch
+      edges. Strong seam suppression. **Caveat:** image-corner pixels that
+      are covered only by patches whose edge-weight at that location is zero
+      will be zero in the output. Document this for callers.
+    - ``"gaussian"`` — Gaussian centered on the patch with
+      ``sigma = max(1.0, min(ph, pw) / 4)``. Smooth seam suppression without
+      the strict zero at the edge (no corner-zero artifact).
+
+    Internally: each patch is multiplied by the 2-D weight kernel, the
+    weighted patches are folded into the numerator, the weight kernel itself
+    is folded over the same geometry into the denominator, and
+    ``numerator / denominator.clamp(min=1e-6)`` gives the output. The clamp
+    absorbs float noise on covered pixels; geometry validation guarantees
+    no uncovered pixels.
+
+    Rejects (per §9.9): ``dilation != 1``; ``stride > patch_size`` in any
+    axis; ``patches.ndim != 4``; non-floating-point patches (kernel
+    multiplication breaks integer semantics for non-uniform weights —
+    callers convert to ``float`` first); ``image_shape`` inconsistent with
+    the patch grid; unknown ``weight``.
+
+    Dtype and device of ``patches`` are preserved.
+    """
+    if not isinstance(patches, torch.Tensor):
+        raise TypeError(
+            f"patches must be torch.Tensor, got {type(patches).__name__}"
+        )
+    if patches.ndim != 4:
+        raise ValueError(
+            f"patches must have ndim==4 (L, C, ph, pw), got ndim={patches.ndim}"
+        )
+    if not patches.is_floating_point():
+        raise ValueError(
+            f"stitch requires floating-point patches, got dtype={patches.dtype}. "
+            "Convert with patches.float() — weight kernels are float-valued and "
+            "integer semantics would silently quantize the result."
+        )
+
+    if weight not in _WEIGHT_KINDS:
+        raise ValueError(
+            f"weight must be one of {_WEIGHT_KINDS!r}, got {weight!r}"
+        )
+
+    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"stitch 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"stitch 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})"
+        )
+    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})."
+        )
+
+    kernel = _window_kernel(weight, ph, pw, patches.dtype, patches.device)
+
+    # Weighted patches: broadcast kernel (ph, pw) across (L, C, ph, pw).
+    weighted = patches * kernel
+
+    # Numerator fold: (L, C, ph, pw) -> (1, C*ph*pw, L) for F.fold.
+    num_flat = (
+        weighted.permute(1, 2, 3, 0)
+        .reshape(c * ph * pw, n_patches)
+        .unsqueeze(0)
+    )
+    folded_num = F.fold(
+        num_flat,
+        output_size=(h, w),
+        kernel_size=(ph, pw),
+        stride=(sh, sw),
+    )
+
+    # Denominator fold: replicate kernel across L patches; one "channel"
+    # broadcasts across image C in the division.
+    kernel_flat = (
+        kernel.flatten().unsqueeze(1).repeat(1, n_patches).unsqueeze(0)
+    )
+    folded_den = F.fold(
+        kernel_flat,
+        output_size=(h, w),
+        kernel_size=(ph, pw),
+        stride=(sh, sw),
+    )
+
+    # clamp(min=1e-6): for "uniform" this matches reconstruct's count-map
+    # clamp. For "hann", corner pixels covered only by edge-weight-zero
+    # positions have ~0 numerator AND ~0 denominator — output is dominated
+    # by the clamp (i.e., zero). Documented artifact (§9.9).
+    return (folded_num / folded_den.clamp(min=1e-6))[0]

patchcraft-0.2.0.dist-info/METADATA

@@ -0,0 +1,266 @@
+Metadata-Version: 2.4
+Name: patchcraft
+Version: 0.2.0
+Summary: Image patch extraction, reconstruction, pairing and seam-aware stitching for super-resolution and dataset pipelines.
+Project-URL: Homepage, https://github.com/LeoPR/PatchCraft
+Project-URL: Repository, https://github.com/LeoPR/PatchCraft
+Project-URL: Issues, https://github.com/LeoPR/PatchCraft/issues
+Project-URL: Changelog, https://github.com/LeoPR/PatchCraft/blob/main/CHANGELOG.md
+Project-URL: Documentation, https://github.com/LeoPR/PatchCraft/blob/main/docs/USAGE.md
+Author: Leonardo Marques de Souza
+License-Expression: MIT
+License-File: LICENSE
+Keywords: dataset,image,patches,super-resolution,torch
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: numpy>=1.26
+Requires-Dist: pillow>=10
+Requires-Dist: torch>=2.6
+Provides-Extra: cache
+Requires-Dist: zstandard>=0.22; extra == 'cache'
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.5; extra == 'dev'
+Requires-Dist: torchvision>=0.20; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# PatchCraft
+
+A small library for **encoding an image into patches and decoding it back**. Built to slot into other people's `torch` pipelines as one transform among many — like a `GaussianBlur` step in a `Compose([...])`.
+
+> **Status (2026-05-17):** v0.1.0 released; v0.2.0-track is on `main` (not yet tagged). Public API: `extract`, `Patchify`, `reconstruct`, `stitch`, `pair`, `resize`, `Cache`, plus geometry helpers (`num_patches`, `tilings`, `TilingSpec`, `scale_factor`, `paired_tilings`, `PairedTilingSpec`), pixel metrics (`patch_metrics`, `per_patch_mse`, `per_patch_psnr`), and `PatchPair`/`PatchMeta`.
+
+## The lib vs. this repo
+
+Think of the lib as a **car** and this repo as the **car plus its test track**.
+
+- **The car** — [`src/patchcraft/`](src/patchcraft/) — is what gets installed by `pip install patchcraft`. It is a single library with one job: take one image (`Tensor[C, H, W]`), encode it into patches, decode patches back into the image, optionally pair LR/HR, resize, cache. **One image at a time, every time.** No datasets, no training, no orchestration, no batching across images. Multi-image is the caller's `for` loop, or `torch.vmap`, or a `DataLoader`.
+- **The track** — [`tests/`](tests/), [`lab/`](lab/), [`tests/_datasets.py`](tests/_datasets.py), and the dev extras (`torchvision`, etc.) — is the pit crew, telemetry, driver and stopwatch that **prove the car works** on real images (MNIST today; more later). It downloads datasets, drives the lib through varied geometries, measures correctness. It never ships in the wheel.
+
+The car is also **acoplável** — designed to drop into someone else's pipeline:
+
+```python
+from patchcraft import Patchify
+from torchvision import transforms
+
+transform = transforms.Compose([
+    transforms.ToTensor(),
+    transforms.GaussianBlur(kernel_size=3),
+    Patchify(patch_size=4, stride=2),   # ← PatchCraft as one step
+])
+```
+
+`Patchify` is a callable; chain it inside a `Compose`, let `DataLoader` parallelize over workers. PatchCraft gives you the primitive; the surrounding pipeline stays your code.
+
+## Visual cheat sheet
+
+The five core operations, one diagram each. Letters mark which patch each cell came from / goes to.
+
+### `extract` — image → patch stack
+
+`patch_size=4`, `stride=4` (no overlap) on an 8×8 image:
+
+```
+   image (1, 8, 8)                  patches (4, 1, 4, 4)
+   +-----------------+              +-----+  +-----+
+   | . . . . | . . . . |             |  A  |  |  B  |
+   | . A . . | . B . . |  extract    +-----+  +-----+
+   | . . . . | . . . . |  -------->   patch0   patch1
+   | . . . . | . . . . |
+   |---------+---------|             +-----+  +-----+
+   | . . . . | . . . . |             |  C  |  |  D  |
+   | . C . . | . D . . |             +-----+  +-----+
+   | . . . . | . . . . |              patch2   patch3
+   | . . . . | . . . . |             (row-major order)
+   +-----------------+
+```
+
+### `reconstruct` — patch stack → image (bit-exact when `stride == patch_size`)
+
+Each output pixel = sum of patch contributions / `count` map (= how many patches covered it). When `stride == patch_size`, `count` is all-ones and the divide is a no-op.
+
+```
+   stride == patch  -->  count map all 1   -->  trivial copy
+   stride <  patch  -->  count map > 1     -->  weighted average
+
+   patch=4, stride=2, image cols 0..7:
+     col:    0  1  2  3  4  5  6  7
+     patch0: x  x  x  x
+     patch1:       x  x  x  x
+     patch2:             x  x  x  x
+     count:  1  1  2  2  2  2  1  1   <- divide sum by this
+```
+
+### `pair` — LR <-> HR, same image region, different resolution
+
+`scale_factor=2`: every k-th LR patch corresponds to the k-th HR patch; HR coords are LR coords times the integer scale.
+
+```
+   LR (1, 4, 4)               HR (1, 8, 8)
+   +---------+                +-------------+
+   | . . . . |                | . . . . . . . . |
+   | .[A]. . |   k = 1  -->   | . .[A A]. . . . |
+   | . . . . |                | . .[A A]. . . . |
+   | . . . . |                | . . . . . . . . |
+   +---------+                | . . . . . . . . |
+                              | . . . . . . . . |
+                              | . . . . . . . . |
+                              | . . . . . . . . |
+                              +-------------+
+
+   LR patch at (row=1, col=1)  <-->  HR patch at (row=2, col=2)
+```
+
+### `stitch` — same fold geometry as `reconstruct`, but each patch weighted by a window kernel
+
+Use when patches were modified by a model and uniform averaging shows boundary seams. Window kernels for `patch_size=4`:
+
+```
+   weight="uniform"     weight="hann"        weight="gaussian"
+   (== reconstruct)     centers > edges      centers >> edges (never 0)
+
+   + + + +              . . . .              . o o .
+   + + + +              . X X .              o X X o
+   + + + +              . X X .              o X X o
+   + + + +              . . . .              . o o .
+
+   no seam attenuation  strong attenuation,  smooth attenuation,
+                        image corners -> 0   corners preserved
+```
+
+### Everything stays one-image-at-a-time
+
+```
+   for image in images:
+       patches = extract(image, ...)       # PatchCraft primitive
+       result  = model(patches)            # caller's work
+       out     = stitch(result, ...)       # PatchCraft primitive
+```
+
+Multi-image parallelism is the caller's pipeline (`torch.vmap`, `DataLoader` workers, etc.) — see [`SCOPE.md`](docs/SCOPE.md) §2.
+
+## Scope (what the car does)
+
+- **Extract** patches from a single image with configurable size, stride and dilation (`extract`, `Patchify`).
+- **Reconstruct** an image from its patches — exact and weighted-overlap (`reconstruct`).
+- **Stitch** *modified* patches (model output, denoised, super-resolved) back into one image with a window kernel that attenuates boundary seams (`stitch`, with `weight="uniform"|"hann"|"gaussian"`).
+- **Plan** the geometry ahead of time: `num_patches((H, W), ...)` for the count, `tilings((H, W), allow_overlap=...)` for every full-coverage `(patch_size, stride)` combo (no image, no allocation — just arithmetic). For LR↔HR setups: `scale_factor(...)` and `paired_tilings(...)`.
+- **Pair** LR and HR patches with metadata sufficient to reconstruct either (`pair`, `PatchPair`, `PatchMeta`).
+- **Measure** pixel-level error between two patch stacks: `patch_metrics`, `per_patch_mse`, `per_patch_psnr`.
+- **Resize** with pluggable backends — PIL or torch (`resize`).
+- **Cache** results on disk with content-addressed keys, OneDrive-race retry, optional zstd (`Cache`).
+
+## Scope (what the car does NOT do)
+
+- **Not a dataset manager.** PatchCraft does not load, download, batch, shuffle, or stream datasets. That's the track's job — `tests/_datasets.py` has `mnist_subset(...)` for dev fixtures, and `torchvision` is in the `[dev]` extra (never a runtime dep of the car).
+- **Not a multi-image API.** Every primitive takes one image. Use `vmap` or a Python loop if you need to apply it to many.
+- No SVMs, no kernels, no quantum circuits — those belong to other projects.
+- No neural network training — PatchCraft is infrastructure, not a model.
+
+## Install
+
+### From PyPI
+
+```
+pip install patchcraft            # core only
+pip install patchcraft[cache]     # adds zstandard for compressed Cache entries
+```
+
+### From source (development)
+
+```
+git clone https://github.com/LeoPR/PatchCraft.git
+cd patchcraft
+pip install -e ".[dev,cache]"
+```
+
+For GPU support, install a matching torch wheel before PatchCraft
+(e.g. `pip install torch --index-url https://download.pytorch.org/whl/cu124`).
+
+## Run tests
+
+```
+pytest
+pytest -m "not gpu"        # skip GPU-requiring tests
+```
+
+## Layout
+
+```
+PatchCraft/
+├── pyproject.toml                  package metadata, build backend (hatchling)
+├── README.md                       this file
+├── LICENSE                         MIT
+├── .python-version                 3.13
+├── .gitignore                      ignores archive/, venvs, caches, outputs
+├── src/patchcraft/                   library core — one-image-at-a-time primitives
+│   ├── __init__.py                 re-exports the full public API
+│   ├── extract.py                  patches via F.unfold; Patchify wrapper (ADR 0002)
+│   ├── reconstruct.py              inverse via F.fold + count map
+│   ├── geometry.py                 pre-flight: num_patches, tilings, TilingSpec
+│   ├── pair.py                     LR↔HR pairing; PatchPair, PatchMeta
+│   ├── resize.py                   resize with PIL or torch backends
+│   └── cache.py                    content-addressed disk cache
+├── tests/                          pytest suite (contract tests for src/)
+│   ├── test_extract.py             extract + Patchify
+│   ├── test_reconstruct.py
+│   ├── test_geometry.py            num_patches + tilings
+│   ├── test_pair.py
+│   ├── test_resize.py
+│   ├── test_cache.py
+│   ├── test_datasets_helper.py     label_subset
+│   ├── test_import.py
+│   └── _datasets.py                dev-only fixtures (MNIST, etc) — NOT public API
+├── lab/                            ephemeral experiments; see lab/README.md
+│   ├── README.md                   bench rules (tracked)
+│   └── .gitignore                  ignores everything else (tracked)
+├── docs/
+│   ├── USAGE.md                    live REPL walkthrough of every public API
+│   ├── SCOPE.md                    responsibilities matrix + parallelization analysis
+│   ├── AUXILIARY.md                tests/_datasets, lab/, Z:\ conventions (NOT part of the wheel)
+│   ├── THEORY.md                   distilled design + §9 condition contract; §0 binding scope
+│   ├── ROADMAP.md                  milestone plan
+│   └── ADR/
+│       ├── 0001-patch-extraction-api.md   pure function `extract`
+│       └── 0002-patchify-transform.md     callable wrapper for Compose pipelines
+└── archive/                        reference-only; gitignored (pruned 2026-05-17 — only HISTORY.md kept)
+```
+
+## Validation lab
+
+The library is "one image in, one tensor out" by design — but you only know it works once you run it end-to-end on real images. That happens in two places, neither of which is part of the shipped package:
+
+- [`tests/`](tests/) — formal pytest suite that defines the contract from [`docs/THEORY.md`](docs/THEORY.md) §9.
+- [`lab/`](lab/) — ephemeral scripts and notebooks for fast hypothesis-checking. See [`lab/README.md`](lab/README.md) for the bench rules; outputs go to `Z:\outputs\patchcraft\` (off-tree).
+
+Datasets used by tests/lab are downloaded lazily into `Z:\caches\datasets\<name>\` on first use; they do not ship with the package and are never bundled into the wheel.
+
+## Where to read next
+
+| If you want… | Open |
+|---|---|
+| A hands-on tour with real REPL outputs for every public API | [`docs/USAGE.md`](docs/USAGE.md) |
+| The line between "PatchCraft's job" and "your pipeline's job", plus the parallelization story | [`docs/SCOPE.md`](docs/SCOPE.md) |
+| The auxiliary test fixtures and lab conventions (not shipped) | [`docs/AUXILIARY.md`](docs/AUXILIARY.md) |
+| Design decisions, math, the per-API contract | [`docs/THEORY.md`](docs/THEORY.md) |
+| Architecture Decision Records | [`docs/ADR/`](docs/ADR/) |
+| Milestone plan | [`docs/ROADMAP.md`](docs/ROADMAP.md) |
+| Per-release changes | [`CHANGELOG.md`](CHANGELOG.md) |
+
+## Author
+
+Leonardo Marques de Souza

patchcraft-0.2.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+patchcraft/__init__.py,sha256=mvvN6gwkDi6ZFhqjoImxxajfHzk7nnsmZmDADZKrQMU,957
+patchcraft/cache.py,sha256=Rs5_HS7nIVEYPvaDnvbgFcHTEx4xnB2Iqx2QCaeVLr4,8596
+patchcraft/extract.py,sha256=yFSd-ytukeVnieuu45OTpvULDFNEminhA97goMR04xs,4123
+patchcraft/geometry.py,sha256=AZZPV0JMKhpy5DVP-6XMJC-JhNipVZYhPvi8yYHd-7c,10501
+patchcraft/metrics.py,sha256=tJ8hPV4Emaw6jBzWTep3_ad7M-DbbRXdPRvlOuh3xZs,5164
+patchcraft/pair.py,sha256=fXzC03RVtlRh62lRdreknI7tAVz9eMPpLfYpj9VHaZ8,5779
+patchcraft/reconstruct.py,sha256=NGYGPbnQJ8o4aYiOV3m_dNc4X4WHekfidRPa1lelspc,4497
+patchcraft/resize.py,sha256=FB43uJcMTW5FPhthBVcluRTH749X6Cu6PDpzqyyws_U,7009
+patchcraft/stitch.py,sha256=CR-TD1LiaORmKoMarQ_pN20zvlC__CirB1z7778SvmE,8461
+patchcraft/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+patchcraft-0.2.0.dist-info/METADATA,sha256=JjLZOEneH7B5cDYAo7qHUbeC5G78wuHpG73jf0nNwT0,13375
+patchcraft-0.2.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+patchcraft-0.2.0.dist-info/licenses/LICENSE,sha256=mFbXuSyc-xMcSV55A6NVsfgvW7ldtJb6Eky-Rv5UHN8,1082
+patchcraft-0.2.0.dist-info/RECORD,,

patchcraft-0.2.0.dist-info/WHEEL

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

patchcraft-0.2.0.dist-info/licenses/LICENSE

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