| |
| """Validate a built SmoothStyle repository.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import hashlib |
| import json |
| from concurrent.futures import ThreadPoolExecutor |
| from pathlib import Path |
| from typing import Any |
|
|
| from PIL import Image |
|
|
|
|
| IMAGE_FIELDS = ("content_file_name", "style_file_name", "target_file_name") |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--root", type=Path, default=Path(__file__).resolve().parents[1]) |
| parser.add_argument("--skip-images", action="store_true") |
| parser.add_argument("--skip-checksums", action="store_true") |
| parser.add_argument("--huggingface", action="store_true") |
| return parser.parse_args() |
|
|
|
|
| def load_json(path: Path) -> Any: |
| with path.open("r", encoding="utf-8") as handle: |
| return json.load(handle) |
|
|
|
|
| def load_jsonl(path: Path) -> list[dict[str, Any]]: |
| rows = [] |
| with path.open("r", encoding="utf-8") as handle: |
| for line_number, line in enumerate(handle, 1): |
| try: |
| value = json.loads(line) |
| except json.JSONDecodeError as error: |
| raise ValueError(f"Invalid JSON at {path}:{line_number}: {error}") from error |
| if not isinstance(value, dict): |
| raise ValueError(f"Expected object at {path}:{line_number}") |
| rows.append(value) |
| return rows |
|
|
|
|
| def safe_resolve(split_root: Path, relative_name: str) -> Path: |
| path = (split_root / relative_name).resolve() |
| try: |
| path.relative_to(split_root.resolve()) |
| except ValueError as error: |
| raise ValueError(f"Image path escapes split directory: {relative_name}") from error |
| return path |
|
|
|
|
| def validate_image(path: Path) -> None: |
| with Image.open(path) as image: |
| image.verify() |
|
|
|
|
| def sha256(path: Path) -> str: |
| digest = hashlib.sha256() |
| with path.open("rb") as handle: |
| for block in iter(lambda: handle.read(1024 * 1024), b""): |
| digest.update(block) |
| return digest.hexdigest() |
|
|
|
|
| def validate_checksums(root: Path) -> int: |
| checksum_path = root / "metadata" / "checksums.sha256" |
| entries: list[tuple[str, Path]] = [] |
| with checksum_path.open("r", encoding="utf-8") as handle: |
| for line_number, line in enumerate(handle, 1): |
| digest, separator, relative_name = line.rstrip("\n").partition(" ") |
| if not separator or len(digest) != 64: |
| raise ValueError(f"Invalid checksum line {line_number}") |
| path = (root / relative_name).resolve() |
| try: |
| path.relative_to(root.resolve()) |
| except ValueError as error: |
| raise ValueError(f"Checksum path escapes repository: {relative_name}") from error |
| if not path.is_file(): |
| raise FileNotFoundError(path) |
| entries.append((digest, path)) |
|
|
| def check(entry: tuple[str, Path]) -> None: |
| expected, path = entry |
| actual = sha256(path) |
| if actual != expected: |
| raise ValueError(f"Checksum mismatch: {path}") |
|
|
| with ThreadPoolExecutor(max_workers=8) as executor: |
| list(executor.map(check, entries)) |
| return len(entries) |
|
|
|
|
| def validate_huggingface(root: Path, expected: dict[str, int]) -> None: |
| try: |
| from datasets import load_dataset |
| except ImportError as error: |
| raise RuntimeError( |
| "The optional Hugging Face check requires the 'datasets' package" |
| ) from error |
|
|
| dataset = load_dataset("imagefolder", data_dir=str(root / "data")) |
| if set(dataset) != set(expected): |
| raise ValueError(f"Unexpected Hugging Face splits: {sorted(dataset)}") |
| for split, expected_rows in expected.items(): |
| if len(dataset[split]) != expected_rows: |
| raise ValueError( |
| f"Hugging Face row mismatch for {split}: " |
| f"{len(dataset[split])} != {expected_rows}" |
| ) |
| expected_features = { |
| "content", |
| "content_id", |
| "generator", |
| "id", |
| "pair_id", |
| "strength", |
| "strength_id", |
| "style", |
| "style_id", |
| "style_source", |
| "target", |
| } |
| actual_features = set(dataset[split].features) |
| if actual_features != expected_features: |
| raise ValueError( |
| f"Unexpected Hugging Face features for {split}: " |
| f"{sorted(actual_features)}" |
| ) |
| for image_feature in ("content", "style", "target"): |
| if dataset[split].features[image_feature].__class__.__name__ != "Image": |
| raise ValueError( |
| f"{split}.{image_feature} was not inferred as an Image feature" |
| ) |
|
|
|
|
| def main() -> None: |
| args = parse_args() |
| root = args.root.resolve() |
| stats = load_json(root / "metadata" / "dataset_stats.json") |
| split_manifest = load_json(root / "metadata" / "split_manifest.json") |
|
|
| all_images: set[Path] = set() |
| split_pairs: dict[str, set[str]] = {} |
| split_contents: dict[str, set[str]] = {} |
| split_styles: dict[str, set[str]] = {} |
| expected_hf_rows: dict[str, int] = {} |
|
|
| for split in ("train", "test"): |
| split_root = root / "data" / split |
| rows = load_jsonl(split_root / "metadata.jsonl") |
| expected_rows = stats["splits"][split]["examples"] |
| if len(rows) != expected_rows: |
| raise ValueError(f"{split} row count {len(rows)} != {expected_rows}") |
| expected_hf_rows[split] = expected_rows |
|
|
| ids: set[str] = set() |
| pair_strengths: set[tuple[str, int]] = set() |
| pairs: set[str] = set() |
| contents: set[str] = set() |
| styles: set[str] = set() |
| referenced: set[Path] = set() |
|
|
| for row in rows: |
| required = { |
| "id", |
| "pair_id", |
| "content_id", |
| "style_id", |
| "strength_id", |
| "strength", |
| *IMAGE_FIELDS, |
| } |
| missing = required - set(row) |
| if missing: |
| raise ValueError(f"Missing fields in {split}: {sorted(missing)}") |
| if row["id"] in ids: |
| raise ValueError(f"Duplicate sample ID: {row['id']}") |
| ids.add(row["id"]) |
|
|
| strength_id = row["strength_id"] |
| if strength_id not in range(1, 11): |
| raise ValueError(f"Invalid strength ID: {strength_id}") |
| if abs(row["strength"] - strength_id / 10.0) > 1e-12: |
| raise ValueError(f"Invalid scalar strength: {row}") |
| pair_strength = (row["pair_id"], strength_id) |
| if pair_strength in pair_strengths: |
| raise ValueError(f"Duplicate pair/strength: {pair_strength}") |
| pair_strengths.add(pair_strength) |
|
|
| expected_pair = f"{row['content_id']}_{row['style_id']}" |
| if row["pair_id"] != expected_pair: |
| raise ValueError(f"Pair ID mismatch: {row}") |
|
|
| pairs.add(row["pair_id"]) |
| contents.add(row["content_id"]) |
| styles.add(row["style_id"]) |
| for field in IMAGE_FIELDS: |
| path = safe_resolve(split_root, row[field]) |
| if not path.is_file(): |
| raise FileNotFoundError(path) |
| referenced.add(path) |
| all_images.add(path) |
|
|
| for pair in pairs: |
| strengths = { |
| strength for candidate, strength in pair_strengths if candidate == pair |
| } |
| if strengths != set(range(1, 11)): |
| raise ValueError(f"Incomplete target strengths for {split}/{pair}") |
|
|
| actual_images = {path.resolve() for path in split_root.rglob("*.jpg")} |
| if actual_images != referenced: |
| missing_from_index = sorted(actual_images - referenced) |
| missing_from_disk = sorted(referenced - actual_images) |
| raise ValueError( |
| f"Image/index mismatch for {split}: " |
| f"unindexed={missing_from_index[:5]}, absent={missing_from_disk[:5]}" |
| ) |
|
|
| split_pairs[split] = pairs |
| split_contents[split] = contents |
| split_styles[split] = styles |
|
|
| if split_pairs["train"] & split_pairs["test"]: |
| raise ValueError("Train/test pair overlap detected") |
| if split_contents["train"] & split_contents["test"]: |
| raise ValueError("Train/test content overlap detected") |
|
|
| manifest_train = set(split_manifest["train_pair_ids"]) |
| manifest_test = set(split_manifest["test_pair_ids"]) |
| if manifest_train != split_pairs["train"] or manifest_test != split_pairs["test"]: |
| raise ValueError("Split manifest does not match metadata rows") |
|
|
| expected_style_overlap = stats["totals"]["style_ids_shared_between_splits"] |
| actual_style_overlap = len(split_styles["train"] & split_styles["test"]) |
| if actual_style_overlap != expected_style_overlap: |
| raise ValueError( |
| f"Style overlap mismatch: {actual_style_overlap} != {expected_style_overlap}" |
| ) |
|
|
| provenance = load_jsonl(root / "metadata" / "sources.jsonl") |
| provenance_assets = {root / row["asset_id"] for row in provenance} |
| if {path.resolve() for path in provenance_assets} != all_images: |
| raise ValueError("Provenance index does not cover exactly the published images") |
|
|
| if not args.skip_images: |
| with ThreadPoolExecutor(max_workers=8) as executor: |
| list(executor.map(validate_image, sorted(all_images))) |
|
|
| checksum_count = 0 |
| if not args.skip_checksums: |
| checksum_count = validate_checksums(root) |
|
|
| if args.huggingface: |
| validate_huggingface(root, expected_hf_rows) |
|
|
| result = { |
| "status": "ok", |
| "examples": sum(expected_hf_rows.values()), |
| "images": len(all_images), |
| "style_ids_shared_between_splits": actual_style_overlap, |
| "checksums_verified": checksum_count, |
| "image_decoding_verified": not args.skip_images, |
| "huggingface_loader_verified": args.huggingface, |
| } |
| print(json.dumps(result, indent=2, sort_keys=True)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
