scripts/build_dataset.py

#!/usr/bin/env python3
"""Build the standalone SmoothStyle Hugging Face dataset without mutating its source."""

from __future__ import annotations

import argparse
import hashlib
import json
import os
import re
import shutil
import tempfile
from collections import defaultdict
from pathlib import Path
from typing import Any


FILE_RE = re.compile(
    r"^(?P<content>\d{4})_(?P<style>\d{4})_(?P<strength>0|[1-9]|10|11)\.jpg$"
)
EXPECTED_STRENGTHS = set(range(12))


def parse_args() -> argparse.Namespace:
    repo_root = Path(__file__).resolve().parents[1]
    default_source = repo_root.parent / "dataset"
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--source", type=Path, default=default_source)
    parser.add_argument("--output", type=Path, default=repo_root)
    return parser.parse_args()


def load_split_manifest(source: Path, split: str) -> dict[str, dict[str, str]]:
    manifest_path = source / f"{split}_files.json"
    with manifest_path.open("r", encoding="utf-8") as handle:
        names = json.load(handle)

    if not isinstance(names, list) or not all(isinstance(name, str) for name in names):
        raise ValueError(f"{manifest_path} must contain a JSON list of filenames")
    if len(names) != len(set(names)):
        raise ValueError(f"{manifest_path} contains duplicate filenames")

    grouped: dict[str, set[int]] = defaultdict(set)
    pair_ids: dict[str, dict[str, str]] = {}
    for name in names:
        match = FILE_RE.fullmatch(name)
        if match is None:
            raise ValueError(f"Invalid result filename in {manifest_path}: {name}")
        content_id = match.group("content")
        style_id = match.group("style")
        strength_id = int(match.group("strength"))
        pair_id = f"{content_id}_{style_id}"
        grouped[pair_id].add(strength_id)
        pair_ids[pair_id] = {"content_id": content_id, "style_id": style_id}

    incomplete = {
        pair_id: sorted(EXPECTED_STRENGTHS - strengths)
        for pair_id, strengths in grouped.items()
        if strengths != EXPECTED_STRENGTHS
    }
    if incomplete:
        first_items = list(incomplete.items())[:10]
        raise ValueError(f"Incomplete groups in {manifest_path}: {first_items}")

    return dict(sorted(pair_ids.items()))


def require_file(path: Path) -> Path:
    if not path.is_file():
        raise FileNotFoundError(path)
    return path


def copy_file(source: Path, destination: Path) -> None:
    require_file(source)
    destination.parent.mkdir(parents=True, exist_ok=True)
    shutil.copy2(source, destination)


def write_json(path: Path, value: Any) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    with path.open("w", encoding="utf-8") as handle:
        json.dump(value, handle, indent=2, ensure_ascii=False, sort_keys=True)
        handle.write("\n")


def write_jsonl(path: Path, rows: list[dict[str, Any]]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    with path.open("w", encoding="utf-8") as handle:
        for row in rows:
            handle.write(json.dumps(row, ensure_ascii=False, sort_keys=True))
            handle.write("\n")


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 provenance_for_style(style_id: str, asset_path: str) -> dict[str, Any]:
    if style_id.startswith("0"):
        return {
            "asset_id": asset_path,
            "asset_type": "style",
            "local_id": style_id,
            "source_dataset": "Style30K",
            "source_url": "https://github.com/alipay/style-tokenizer",
            "source_via": "unknown-per-image",
            "dataset_metadata_license": "CC-BY-4.0",
            "image_license": "original-source-license-or-unknown",
            "redistribution_status": "pending-rights-review",
        }
    if style_id.startswith("1"):
        return {
            "asset_id": asset_path,
            "asset_type": "style",
            "local_id": style_id,
            "source_dataset": "SmoothStyle",
            "source_via": "project-generated",
            "generation_model": None,
            "generation_model_license": None,
            "reference_image": None,
            "image_license": "project-license-pending-generation-audit",
            "redistribution_status": "pending-generation-record",
        }
    raise ValueError(f"Unsupported style ID prefix: {style_id}")


def provenance_for_content(content_id: str, asset_path: str) -> dict[str, Any]:
    return {
        "asset_id": asset_path,
        "asset_type": "content",
        "local_id": content_id,
        "source_dataset": "OmniStyle-150K",
        "source_url": "https://huggingface.co/datasets/StyleXX/OmniStyle-150k",
        "source_via": "randomly-selected-content-subset",
        "source_original_filename": None,
        "image_license": "Apache-2.0",
        "license_basis": "upstream-dataset-card",
        "generation_method_upstream": "FLUX",
        "redistribution_status": "upstream-license-declared",
    }


def build_split(
    source: Path,
    staging_root: Path,
    split: str,
    pairs: dict[str, dict[str, str]],
) -> tuple[dict[str, Any], list[dict[str, Any]]]:
    split_root = staging_root / "data" / split
    rows: list[dict[str, Any]] = []
    provenance: list[dict[str, Any]] = []
    content_ids = sorted({pair["content_id"] for pair in pairs.values()})
    style_ids = sorted({pair["style_id"] for pair in pairs.values()})

    for content_id in content_ids:
        relative = Path("data") / split / "content" / f"{content_id}.jpg"
        copy_file(source / "content" / f"{content_id}.jpg", staging_root / relative)
        provenance.append(
            provenance_for_content(content_id, relative.as_posix())
        )

    for style_id in style_ids:
        relative = Path("data") / split / "style" / f"{style_id}.jpg"
        copy_file(source / "style" / f"{style_id}.jpg", staging_root / relative)
        provenance.append(provenance_for_style(style_id, relative.as_posix()))

    for pair_id, pair in pairs.items():
        content_id = pair["content_id"]
        style_id = pair["style_id"]
        style_source = "Style30K" if style_id.startswith("0") else "project-generated"
        for strength_id in range(1, 11):
            filename = f"{pair_id}_{strength_id}.jpg"
            relative_target = (
                Path("data") / split / "target" / f"s{strength_id:02d}" / filename
            )
            copy_file(source / "result" / filename, staging_root / relative_target)
            row = {
                "id": f"{pair_id}_{strength_id:02d}",
                "pair_id": pair_id,
                "content_id": content_id,
                "style_id": style_id,
                "strength_id": strength_id,
                "strength": strength_id / 10.0,
                "content_file_name": f"content/{content_id}.jpg",
                "style_file_name": f"style/{style_id}.jpg",
                "target_file_name": f"target/s{strength_id:02d}/{filename}",
                "style_source": style_source,
                "generator": "STROTSS",
            }
            rows.append(row)
            provenance.append(
                {
                    "asset_id": relative_target.as_posix(),
                    "asset_type": "target",
                    "local_id": f"{pair_id}_{strength_id:02d}",
                    "content_id": content_id,
                    "style_id": style_id,
                    "strength_id": strength_id,
                    "generator": "STROTSS",
                    "generator_reference": "https://arxiv.org/abs/1904.12785",
                    "image_license": "inherits-source-rights-project-license-pending",
                    "redistribution_status": "pending-input-rights-review",
                }
            )

    rows.sort(key=lambda row: (row["pair_id"], row["strength_id"]))
    write_jsonl(split_root / "metadata.jsonl", rows)

    stats = {
        "pairs": len(pairs),
        "examples": len(rows),
        "content_images": len(content_ids),
        "style_images": len(style_ids),
        "style30k_images": sum(style_id.startswith("0") for style_id in style_ids),
        "project_generated_style_images": sum(
            style_id.startswith("1") for style_id in style_ids
        ),
        "target_images": len(rows),
    }
    return stats, provenance


def write_checksums(staging_root: Path) -> None:
    checksum_path = staging_root / "metadata" / "checksums.sha256"
    files = sorted(
        path
        for path in staging_root.rglob("*")
        if path.is_file() and path != checksum_path
    )
    with checksum_path.open("w", encoding="utf-8") as handle:
        for path in files:
            relative = path.relative_to(staging_root).as_posix()
            handle.write(f"{sha256(path)}  {relative}\n")


def main() -> None:
    args = parse_args()
    source = args.source.resolve()
    output = args.output.resolve()

    if source == output or source in output.parents:
        raise ValueError("Output must not be inside the source dataset directory")
    for required in (
        source / "content",
        source / "style",
        source / "result",
        source / "train_files.json",
        source / "test_files.json",
    ):
        if not required.exists():
            raise FileNotFoundError(required)

    generated_targets = [output / "data", output / "metadata"]
    existing = [path for path in generated_targets if path.exists()]
    if existing:
        raise FileExistsError(f"Refusing to overwrite generated paths: {existing}")

    train_pairs = load_split_manifest(source, "train")
    test_pairs = load_split_manifest(source, "test")
    overlap = set(train_pairs) & set(test_pairs)
    if overlap:
        raise ValueError(f"Train/test pair overlap: {sorted(overlap)[:10]}")

    output.mkdir(parents=True, exist_ok=True)
    with tempfile.TemporaryDirectory(prefix=".smoothstyle-build-", dir=output) as temp_dir:
        staging_root = Path(temp_dir)
        train_stats, train_provenance = build_split(
            source, staging_root, "train", train_pairs
        )
        test_stats, test_provenance = build_split(
            source, staging_root, "test", test_pairs
        )

        train_styles = {pair["style_id"] for pair in train_pairs.values()}
        test_styles = {pair["style_id"] for pair in test_pairs.values()}
        train_contents = {pair["content_id"] for pair in train_pairs.values()}
        test_contents = {pair["content_id"] for pair in test_pairs.values()}

        stats = {
            "dataset": "SmoothStyle",
            "schema_version": "1.0",
            "splits": {"train": train_stats, "test": test_stats},
            "totals": {
                "pairs": len(train_pairs) + len(test_pairs),
                "examples": train_stats["examples"] + test_stats["examples"],
                "physical_images": (
                    train_stats["content_images"]
                    + train_stats["style_images"]
                    + train_stats["target_images"]
                    + test_stats["content_images"]
                    + test_stats["style_images"]
                    + test_stats["target_images"]
                ),
                "unique_style_ids": len(train_styles | test_styles),
                "style_ids_shared_between_splits": len(train_styles & test_styles),
                "content_ids_shared_between_splits": len(train_contents & test_contents),
            },
            "source_scope": {
                "included": [
                    "dataset/content",
                    "dataset/style",
                    "dataset/result strengths 1-10",
                    "dataset/train_files.json",
                    "dataset/test_files.json",
                ],
                "explicitly_ignored": ["dataset/src"],
                "redundant_sources_not_copied": [
                    "dataset/train images",
                    "dataset/test images",
                    "dataset/result strengths 0 and 11",
                ],
                "content_provenance": {
                    "source_dataset": "OmniStyle-150K",
                    "source_url": "https://huggingface.co/datasets/StyleXX/OmniStyle-150k",
                    "selection": "random subset of content images",
                    "declared_upstream_license": "Apache-2.0",
                    "generation_method_upstream": "FLUX",
                },
            },
        }
        write_json(staging_root / "metadata" / "dataset_stats.json", stats)
        write_json(
            staging_root / "metadata" / "split_manifest.json",
            {
                "seed": 42,
                "strategy": "80/20 split over complete content-style pairs",
                "train_pair_ids": sorted(train_pairs),
                "test_pair_ids": sorted(test_pairs),
                "style_ids_shared_between_splits": sorted(train_styles & test_styles),
            },
        )
        provenance = sorted(
            train_provenance + test_provenance, key=lambda row: row["asset_id"]
        )
        write_jsonl(staging_root / "metadata" / "sources.jsonl", provenance)
        write_checksums(staging_root)

        os.replace(staging_root / "data", output / "data")
        os.replace(staging_root / "metadata", output / "metadata")

    print(json.dumps(stats, indent=2, ensure_ascii=False, sort_keys=True))


if __name__ == "__main__":
    main()