dset-cli 0.1.0__tar.gz → 0.2.1__tar.gz

{dset_cli-0.1.0 → dset_cli-0.2.1}/PKG-INFO

@@ -1,9 +1,10 @@
 Metadata-Version: 2.4
 Name: dset-cli
-Version: 0.1.0
+Version: 0.2.1
 Summary: Version control for datasets — commit, diff, and roll back millions of files with semantic diffs.
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
+Requires-Dist: Pillow>=9.0
 
 # dset — version control for datasets
 
@@ -69,6 +70,7 @@ dset checkout v1
 | `dset log` | list versions with file counts and sizes |
 | `dset diff <a> <b>` | semantic diff: file counts by type, size, class distribution shift |
 | `dset checkout <ref>` | restore the working tree to a version (`--force` to discard changes) |
+| `dset check [path]` | quality scan: duplicates, corruption, leakage, imbalance, outliers (`--fix` to quarantine) |
 
 Refs can be a tag (`v3`), `HEAD`, or a commit-id prefix.
 
@@ -88,6 +90,28 @@ Refs can be a tag (`v3`), `HEAD`, or a commit-id prefix.
   corrupt history. On btrfs/XFS the copy is a free copy-on-write clone.
 - Uncommitted changes block `dset checkout` unless you pass `--force`.
 
+## dset check — the quality engine
+
+```
+dset check ./my-dataset            # scan and score
+dset check ./my-dataset --fix      # also quarantine exact dups + corrupted
+```
+
+Scans every image (parallel, ~2,000 images/sec) and reports:
+
+- corrupted / unreadable images
+- exact duplicates (content hash) and near-duplicates (perceptual dhash + LSH)
+- train/test leakage — exact and near-duplicate pairs across train/ and test/
+- class imbalance (parsed from CSV/TSV label files)
+- outliers: anomalous file size, odd resolutions, near-blank images
+- images missing from label files, and label rows pointing to missing files
+
+Prints a health score out of 100 and writes a browsable `dset_report.html`.
+`--fix` never deletes anything — it moves exact duplicates and corrupted
+files to `_dset_quarantine/` for you to review.
+
+Requires Pillow (installed automatically with the package).
+
 ## Current limits (MVP)
 
 - Class stats read CSV/TSV label files only (COCO/YOLO parsers are next).

{dset_cli-0.1.0 → dset_cli-0.2.1}/README.md

@@ -62,6 +62,7 @@ dset checkout v1
 | `dset log` | list versions with file counts and sizes |
 | `dset diff <a> <b>` | semantic diff: file counts by type, size, class distribution shift |
 | `dset checkout <ref>` | restore the working tree to a version (`--force` to discard changes) |
+| `dset check [path]` | quality scan: duplicates, corruption, leakage, imbalance, outliers (`--fix` to quarantine) |
 
 Refs can be a tag (`v3`), `HEAD`, or a commit-id prefix.
 
@@ -81,6 +82,28 @@ Refs can be a tag (`v3`), `HEAD`, or a commit-id prefix.
   corrupt history. On btrfs/XFS the copy is a free copy-on-write clone.
 - Uncommitted changes block `dset checkout` unless you pass `--force`.
 
+## dset check — the quality engine
+
+```
+dset check ./my-dataset            # scan and score
+dset check ./my-dataset --fix      # also quarantine exact dups + corrupted
+```
+
+Scans every image (parallel, ~2,000 images/sec) and reports:
+
+- corrupted / unreadable images
+- exact duplicates (content hash) and near-duplicates (perceptual dhash + LSH)
+- train/test leakage — exact and near-duplicate pairs across train/ and test/
+- class imbalance (parsed from CSV/TSV label files)
+- outliers: anomalous file size, odd resolutions, near-blank images
+- images missing from label files, and label rows pointing to missing files
+
+Prints a health score out of 100 and writes a browsable `dset_report.html`.
+`--fix` never deletes anything — it moves exact duplicates and corrupted
+files to `_dset_quarantine/` for you to review.
+
+Requires Pillow (installed automatically with the package).
+
 ## Current limits (MVP)
 
 - Class stats read CSV/TSV label files only (COCO/YOLO parsers are next).

dset_cli-0.2.1/dset/check.py

@@ -0,0 +1,388 @@
+"""dset check — the dataset quality engine.
+
+Scans a folder of images + label files and reports:
+  corrupted images, exact duplicates, near-duplicates, class imbalance,
+  train/test leakage, outliers (size / resolution / brightness),
+  and label <-> file mismatches.
+
+Writes a dset_report.html and prints a health score.
+`--fix` moves exact duplicates and corrupted files into _dset_quarantine/.
+
+Requires Pillow (pip install Pillow). Everything else is stdlib.
+"""
+
+import csv
+import hashlib
+import html
+import json
+import os
+import shutil
+import statistics
+import sys
+import time
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+
+IMAGE_EXT = {".jpg", ".jpeg", ".png", ".tif", ".tiff", ".bmp", ".gif", ".webp"}
+CLASS_COLUMNS = ("label", "class", "class_name", "category", "label_name", "target")
+FILE_COLUMNS = ("file", "filename", "path", "image", "id", "name")
+
+
+def _col(s, c, tty):
+    codes = {"g": "32", "r": "31", "y": "33", "d": "90", "b": "1"}
+    return f"\033[{codes[c]}m{s}\033[0m" if tty else str(s)
+
+
+# ---------------------------------------------------------------- per-image
+
+def _analyze_image(path):
+    """Hash + decode one image. Returns a record dict; ok=False if corrupt."""
+    from PIL import Image
+    rec = {"path": str(path), "bytes": 0, "sha": None, "ok": False,
+           "w": 0, "h": 0, "dhash": None, "bright": None}
+    try:
+        data = path.read_bytes()
+    except OSError:
+        return rec
+    rec["bytes"] = len(data)
+    rec["sha"] = hashlib.sha256(data).hexdigest()
+    try:
+        with Image.open(path) as im:
+            im.load()
+            rec["w"], rec["h"] = im.size
+            g = im.convert("L").resize((9, 8))
+            px = list(g.getdata())
+        bits = 0
+        for r in range(8):
+            for c in range(8):
+                bits = (bits << 1) | (px[r * 9 + c] > px[r * 9 + c + 1])
+        rec["dhash"] = bits
+        rec["bright"] = sum(px) / len(px)
+        rec["ok"] = True
+    except Exception:
+        pass
+    return rec
+
+
+def _hamming(a, b):
+    return bin(a ^ b).count("1")
+
+
+def _near_dup_groups(recs, max_dist=6):
+    """LSH banding on the 64-bit dhash: candidates share one 16-bit band."""
+    buckets = {}
+    for i, r in enumerate(recs):
+        hsh = r["dhash"]
+        for band in range(4):
+            key = (band, (hsh >> (band * 16)) & 0xFFFF)
+            buckets.setdefault(key, []).append(i)
+    parent = list(range(len(recs)))
+
+    def find(x):
+        while parent[x] != x:
+            parent[x] = parent[parent[x]]
+            x = parent[x]
+        return x
+
+    checked = set()
+    for idxs in buckets.values():
+        if len(idxs) < 2 or len(idxs) > 400:  # skip degenerate mega-buckets
+            continue
+        for i in range(len(idxs)):
+            for j in range(i + 1, len(idxs)):
+                a, b = idxs[i], idxs[j]
+                if (a, b) in checked:
+                    continue
+                checked.add((a, b))
+                if _hamming(recs[a]["dhash"], recs[b]["dhash"]) <= max_dist:
+                    parent[find(a)] = find(b)
+    groups = {}
+    for i in range(len(recs)):
+        groups.setdefault(find(i), []).append(i)
+    return [g for g in groups.values() if len(g) > 1]
+
+
+# ---------------------------------------------------------------- labels
+
+def _read_labels(root):
+    """Parse CSV/TSV label files. Returns (class_counts, file->class, sources)."""
+    counts, file_map, sources = {}, {}, []
+    for p in sorted(root.rglob("*")):
+        if p.suffix.lower() not in (".csv", ".tsv") or not p.is_file():
+            continue
+        if any(part.startswith((".", "_dset")) for part in p.parts):
+            continue
+        delim = "\t" if p.suffix.lower() == ".tsv" else ","
+        try:
+            with open(p, newline="", encoding="utf-8", errors="replace") as f:
+                reader = csv.reader(f, delimiter=delim)
+                header = next(reader, None)
+                if not header:
+                    continue
+                lower = [h.strip().lower() for h in header]
+                ci = next((lower.index(c) for c in CLASS_COLUMNS if c in lower), None)
+                fi = next((lower.index(c) for c in FILE_COLUMNS if c in lower), None)
+                if ci is None:
+                    continue
+                sources.append(p)
+                for row in reader:
+                    if ci < len(row) and row[ci].strip():
+                        v = row[ci].strip()
+                        counts[v] = counts.get(v, 0) + 1
+                        if fi is not None and fi < len(row):
+                            file_map[row[fi].strip()] = v
+        except OSError:
+            continue
+    return counts, file_map, sources
+
+
+# ---------------------------------------------------------------- report
+
+def _write_html(out, ctx):
+    rows = []
+    for sev, text, detail in ctx["findings"]:
+        color = {"ok": "#0a7d33", "warn": "#b0771e", "bad": "#c0392b"}[sev]
+        mark = {"ok": "✓", "warn": "⚠", "bad": "✕"}[sev]
+        d = f'<div class="detail">{html.escape(detail)}</div>' if detail else ""
+        rows.append(f'<div class="finding"><span style="color:{color}">{mark}</span>'
+                    f'<div>{html.escape(text)}{d}</div></div>')
+
+    def listing(title, items):
+        if not items:
+            return ""
+        lis = "".join(f"<li>{html.escape(i)}</li>" for i in items[:60])
+        more = (f'<p class="more">… and {len(items) - 60:,} more</p>'
+                if len(items) > 60 else "")
+        return (f'<details><summary>{html.escape(title)} ({len(items):,})</summary>'
+                f"<ul>{lis}</ul>{more}</details>")
+
+    score = ctx["score"]
+    color = "#0a7d33" if score >= 85 else "#b0771e" if score >= 60 else "#c0392b"
+    doc = f"""<!DOCTYPE html><html><head><meta charset="utf-8">
+<title>dset report — {html.escape(ctx['root'])}</title><style>
+body{{font-family:system-ui,sans-serif;max-width:760px;margin:40px auto;
+padding:0 24px;color:#111;line-height:1.6}}
+h1{{font-size:20px;font-weight:600}} .score{{font-size:52px;font-weight:600;
+color:{color};margin:8px 0 4px}} .meta{{color:#777;font-size:14px}}
+.finding{{display:flex;gap:12px;padding:10px 0;border-bottom:1px solid #eee;
+font-size:15px}} .detail{{color:#777;font-size:13px}}
+details{{margin:14px 0;font-size:14px}} summary{{cursor:pointer;font-weight:500}}
+ul{{color:#555;font-family:ui-monospace,monospace;font-size:12.5px}}
+.more{{color:#999;font-size:13px}}</style></head><body>
+<h1>dset check — {html.escape(ctx['root'])}</h1>
+<div class="score">{score} / 100</div>
+<div class="meta">{ctx['n_images']:,} images · {ctx['n_files']:,} files scanned ·
+{time.strftime('%Y-%m-%d %H:%M')}</div><br>
+{''.join(rows)}
+{listing('Corrupted files', ctx['corrupted'])}
+{listing('Exact duplicate files (kept one per group)', ctx['dup_files'])}
+{listing('Near-duplicate groups (first file of each)', ctx['near_files'])}
+{listing('Suspected train/test leakage pairs', ctx['leak_pairs'])}
+{listing('Outlier images', ctx['outlier_files'])}
+{listing('Images missing from label files', ctx['unlabeled'])}
+{listing('Label rows pointing to missing files', ctx['orphan_labels'])}
+</body></html>"""
+    Path(out).write_text(doc)
+
+
+# ---------------------------------------------------------------- command
+
+def run_check(root_arg, fix=False, report_path=None):
+    try:
+        import PIL  # noqa: F401
+    except ImportError:
+        print("dset check needs Pillow:  pip install Pillow", file=sys.stderr)
+        sys.exit(1)
+
+    tty = sys.stdout.isatty() and os.environ.get("NO_COLOR") is None
+    root = Path(root_arg).resolve()
+    if not root.exists():
+        print(f"error: path not found: {root}", file=sys.stderr)
+        sys.exit(1)
+
+    paths = [p for p in sorted(root.rglob("*"))
+             if p.is_file()
+             and not any(part.startswith((".", "_dset")) for part in p.parts)]
+    images = [p for p in paths if p.suffix.lower() in IMAGE_EXT]
+    print(f"Analyzing {len(images):,} images ({len(paths):,} files) in {root} ...")
+
+    t0 = time.time()
+    recs = []
+    with ThreadPoolExecutor(max_workers=min(32, (os.cpu_count() or 4) * 2)) as ex:
+        for i, rec in enumerate(ex.map(_analyze_image, images), 1):
+            recs.append(rec)
+            if i % 2000 == 0:
+                print(f"\r  {i:,}/{len(images):,} ...", end="", flush=True)
+    print("\r" + " " * 30 + "\r", end="")
+
+    ok = [r for r in recs if r["ok"]]
+    corrupted = [r["path"] for r in recs if not r["ok"]]
+
+    # exact duplicates (by content hash)
+    by_sha = {}
+    for r in ok:
+        by_sha.setdefault(r["sha"], []).append(r["path"])
+    dup_groups = [v for v in by_sha.values() if len(v) > 1]
+    dup_files = [p for g in dup_groups for p in g[1:]]  # all but first
+
+    # near duplicates (exclude exact dups so groups aren't double-counted)
+    firsts = {g[0] for g in dup_groups}
+    uniq = [r for r in ok if r["sha"] in {k for k, v in by_sha.items()}
+            and (len(by_sha[r["sha"]]) == 1 or r["path"] in firsts)]
+    near_groups_idx = _near_dup_groups(uniq)
+    near_files = [uniq[g[0]]["path"] for g in near_groups_idx]
+    n_near = sum(len(g) for g in near_groups_idx) - len(near_groups_idx)
+
+    # train/test leakage
+    def split_of(p):
+        parts = [x.lower() for x in Path(p).parts]
+        if any("train" in x for x in parts):
+            return "train"
+        if any(("test" in x or "val" in x) for x in parts):
+            return "test"
+        return None
+
+    leak_pairs = []
+    tr = {r["sha"]: r["path"] for r in ok if split_of(r["path"]) == "train"}
+    te = [r for r in ok if split_of(r["path"]) == "test"]
+    for r in te:
+        if r["sha"] in tr:
+            leak_pairs.append(f"{tr[r['sha']]}  ==  {r['path']}")
+    if te and tr:
+        tr_hashes = {}
+        for r in ok:
+            if split_of(r["path"]) == "train":
+                for band in range(4):
+                    key = (band, (r["dhash"] >> (band * 16)) & 0xFFFF)
+                    tr_hashes.setdefault(key, []).append(r)
+        seen = set()
+        for r in te:
+            for band in range(4):
+                key = (band, (r["dhash"] >> (band * 16)) & 0xFFFF)
+                for cand in tr_hashes.get(key, [])[:200]:
+                    pair = (cand["path"], r["path"])
+                    if pair in seen or cand["sha"] == r["sha"]:
+                        continue
+                    seen.add(pair)
+                    if _hamming(cand["dhash"], r["dhash"]) <= 6:
+                        leak_pairs.append(f"{cand['path']}  ≈  {r['path']}")
+
+    # outliers: file size, resolution, brightness
+    outlier_files = []
+    if len(ok) >= 20:
+        sizes = [r["bytes"] for r in ok]
+        mu, sd = statistics.mean(sizes), statistics.pstdev(sizes) or 1
+        res = {}
+        for r in ok:
+            res[(r["w"], r["h"])] = res.get((r["w"], r["h"]), 0) + 1
+        common_res = max(res, key=res.get)
+        for r in ok:
+            why = []
+            if abs(r["bytes"] - mu) > 4 * sd:
+                why.append("size")
+            if res.get((r["w"], r["h"]), 0) < max(3, len(ok) * 0.001) \
+                    and (r["w"], r["h"]) != common_res:
+                why.append(f"resolution {r['w']}x{r['h']}")
+            if r["bright"] is not None and (r["bright"] < 8 or r["bright"] > 247):
+                why.append("near-blank")
+            if why:
+                outlier_files.append(f"{r['path']}  ({', '.join(why)})")
+
+    # labels
+    counts, file_map, label_sources = _read_labels(root)
+    imbalance = None
+    if counts and len(counts) > 1:
+        total = sum(counts.values())
+        shares = sorted(((v / total, k) for k, v in counts.items()), reverse=True)
+        if shares[0][0] / max(shares[-1][0], 1e-9) > 3:
+            imbalance = shares
+    unlabeled, orphan_labels = [], []
+    if file_map:
+        img_names = {Path(r["path"]).name for r in ok}
+        img_stems = {Path(r["path"]).stem for r in ok}
+        keyset = set()
+        for k in file_map:
+            keyset.add(Path(k).name)
+            keyset.add(Path(k).stem)
+        unlabeled = sorted(n for n in img_names
+                           if n not in keyset and Path(n).stem not in keyset)
+        orphan_labels = sorted(k for k in file_map
+                               if Path(k).name not in img_names
+                               and Path(k).stem not in img_stems)
+
+    # ---------------- score + findings
+    n = max(len(ok), 1)
+    findings, score = [], 100
+
+    def add(cond, sev, penalty, text, detail=""):
+        nonlocal score
+        if cond:
+            findings.append((sev, text, detail))
+            score -= penalty
+        return bool(cond)
+
+    findings.append(("ok", f"{len(ok):,} of {len(images):,} images readable", ""))
+    add(corrupted, "bad", min(20, int(len(corrupted) / n * 400) + 2),
+        f"{len(corrupted):,} corrupted images ({len(corrupted) / n:.1%})")
+    add(dup_files, "warn", min(15, int(len(dup_files) / n * 200) + 2),
+        f"{len(dup_files):,} exact duplicates in {len(dup_groups):,} groups "
+        f"({len(dup_files) / n:.1%})")
+    add(n_near, "warn", min(10, int(n_near / n * 100) + 1),
+        f"{n_near:,} near-duplicate images in {len(near_groups_idx):,} groups")
+    add(imbalance, "warn", 10 if imbalance and imbalance[0][0] > 0.6 else 5,
+        "Class imbalance detected" if imbalance else "",
+        " / ".join(f"{k} {s:.0%}" for s, k in imbalance[:6]) if imbalance else "")
+    add(leak_pairs, "bad", 15,
+        f"Possible train/test leakage — {len(leak_pairs):,} suspicious pairs")
+    add(outlier_files, "warn", min(5, int(len(outlier_files) / n * 100) + 1),
+        f"{len(outlier_files):,} anomalous images (size / resolution / near-blank)")
+    add(unlabeled, "warn", min(8, int(len(unlabeled) / n * 100) + 1),
+        f"{len(unlabeled):,} images have no row in any label file")
+    add(orphan_labels, "warn", 3,
+        f"{len(orphan_labels):,} label rows point to files that don't exist")
+    if not counts:
+        findings.append(("warn", "No parseable label file found "
+                         "(need a CSV/TSV with a label/class column)", ""))
+    score = max(0, min(100, score))
+
+    # ---------------- terminal output
+    print()
+    grade = "g" if score >= 85 else "y" if score >= 60 else "r"
+    print("Dataset health  " + _col(f"{score} / 100", grade, tty))
+    print()
+    for sev, text, detail in findings:
+        mark = {"ok": _col("✓", "g", tty), "warn": _col("⚠", "y", tty),
+                "bad": _col("✕", "r", tty)}[sev]
+        print(f"  {mark} {text}")
+        if detail:
+            print(_col(f"      {detail}", "d", tty))
+
+    # ---------------- fix mode
+    if fix and (dup_files or corrupted):
+        q = root / "_dset_quarantine"
+        moved = 0
+        for p in dup_files + corrupted:
+            src = Path(p)
+            dst = q / src.relative_to(root)
+            dst.parent.mkdir(parents=True, exist_ok=True)
+            try:
+                shutil.move(str(src), str(dst))
+                moved += 1
+            except OSError:
+                pass
+        print(f"\n  Moved {moved:,} files (exact duplicates + corrupted) to "
+              f"{q.name}/ — review, then delete or restore them.")
+    elif fix:
+        print("\n  Nothing to quarantine.")
+
+    # ---------------- html report
+    report = report_path or (root / "dset_report.html")
+    _write_html(report, {
+        "root": str(root), "score": score, "n_images": len(images),
+        "n_files": len(paths), "findings": findings,
+        "corrupted": corrupted, "dup_files": dup_files,
+        "near_files": near_files, "leak_pairs": leak_pairs,
+        "outlier_files": outlier_files, "unlabeled": unlabeled,
+        "orphan_labels": orphan_labels,
+    })
+    print(f"\n  Report: {report}   ({time.time() - t0:.1f}s)")

{dset_cli-0.1.0 → dset_cli-0.2.1}/dset/cli.py

@@ -591,8 +591,21 @@ def main(argv=None):
     sp.add_argument("--force", action="store_true",
                     help="discard uncommitted changes")
 
+    sp = sub.add_parser("check", help="scan a folder for dataset quality "
+                        "problems (duplicates, corruption, leakage, ...)")
+    sp.add_argument("path", nargs="?", default=".",
+                    help="folder to scan (default: current directory)")
+    sp.add_argument("--fix", action="store_true",
+                    help="move exact duplicates and corrupted files "
+                         "to _dset_quarantine/")
+    sp.add_argument("--report", help="path for the HTML report")
+
     args = p.parse_args(argv)
     try:
+        if args.cmd == "check":
+            from .check import run_check
+            run_check(args.path, fix=args.fix, report_path=args.report)
+            return
         {"init": cmd_init, "add": cmd_add, "status": cmd_status,
          "commit": cmd_commit, "log": cmd_log, "diff": cmd_diff,
          "checkout": cmd_checkout}[args.cmd](args)

{dset_cli-0.1.0 → dset_cli-0.2.1}/dset_cli.egg-info/PKG-INFO

@@ -1,9 +1,10 @@
 Metadata-Version: 2.4
 Name: dset-cli
-Version: 0.1.0
+Version: 0.2.1
 Summary: Version control for datasets — commit, diff, and roll back millions of files with semantic diffs.
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
+Requires-Dist: Pillow>=9.0
 
 # dset — version control for datasets
 
@@ -69,6 +70,7 @@ dset checkout v1
 | `dset log` | list versions with file counts and sizes |
 | `dset diff <a> <b>` | semantic diff: file counts by type, size, class distribution shift |
 | `dset checkout <ref>` | restore the working tree to a version (`--force` to discard changes) |
+| `dset check [path]` | quality scan: duplicates, corruption, leakage, imbalance, outliers (`--fix` to quarantine) |
 
 Refs can be a tag (`v3`), `HEAD`, or a commit-id prefix.
 
@@ -88,6 +90,28 @@ Refs can be a tag (`v3`), `HEAD`, or a commit-id prefix.
   corrupt history. On btrfs/XFS the copy is a free copy-on-write clone.
 - Uncommitted changes block `dset checkout` unless you pass `--force`.
 
+## dset check — the quality engine
+
+```
+dset check ./my-dataset            # scan and score
+dset check ./my-dataset --fix      # also quarantine exact dups + corrupted
+```
+
+Scans every image (parallel, ~2,000 images/sec) and reports:
+
+- corrupted / unreadable images
+- exact duplicates (content hash) and near-duplicates (perceptual dhash + LSH)
+- train/test leakage — exact and near-duplicate pairs across train/ and test/
+- class imbalance (parsed from CSV/TSV label files)
+- outliers: anomalous file size, odd resolutions, near-blank images
+- images missing from label files, and label rows pointing to missing files
+
+Prints a health score out of 100 and writes a browsable `dset_report.html`.
+`--fix` never deletes anything — it moves exact duplicates and corrupted
+files to `_dset_quarantine/` for you to review.
+
+Requires Pillow (installed automatically with the package).
+
 ## Current limits (MVP)
 
 - Class stats read CSV/TSV label files only (COCO/YOLO parsers are next).

{dset_cli-0.1.0 → dset_cli-0.2.1}/dset_cli.egg-info/SOURCES.txt

@@ -1,9 +1,11 @@
 README.md
 pyproject.toml
 dset/__init__.py
+dset/check.py
 dset/cli.py
 dset_cli.egg-info/PKG-INFO
 dset_cli.egg-info/SOURCES.txt
 dset_cli.egg-info/dependency_links.txt
 dset_cli.egg-info/entry_points.txt
+dset_cli.egg-info/requires.txt
 dset_cli.egg-info/top_level.txt

dset_cli-0.2.1/dset_cli.egg-info/requires.txt

@@ -0,0 +1 @@
+Pillow>=9.0

{dset_cli-0.1.0 → dset_cli-0.2.1}/pyproject.toml

@@ -1,8 +1,9 @@
 [project]
 name = "dset-cli"
-version = "0.1.0"
+version = "0.2.1"
 description = "Version control for datasets — commit, diff, and roll back millions of files with semantic diffs."
 requires-python = ">=3.9"
+dependencies = ["Pillow>=9.0"]
 readme = "README.md"
 
 [project.scripts]