| from __future__ import annotations |
|
|
| import argparse |
| import csv |
| import json |
| import re |
| import shutil |
| import subprocess |
| from collections import Counter |
| from pathlib import Path |
| from typing import Any |
|
|
|
|
| DEFAULT_CSVS = [ |
| "global.csv", |
| "global+local.csv", |
| "global_freeform3.csv", |
| "global_style.csv", |
| "local.csv", |
| "local_replace.csv", |
| "sim2real.csv", |
| ] |
|
|
| DEFAULT_EXCLUDE_KEYWORDS = [ |
| "anime", |
| "cartoon", |
| "comic", |
| "manga", |
| "ghibli", |
| "pixar", |
| "disney", |
| "illustration", |
| "japanese cartoon", |
| "cel-shaded", |
| "cel shaded", |
| "silhouette", |
| ] |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| parser = argparse.ArgumentParser( |
| description="Prepare Ditto low/high/prompt pairs and optionally materialize a training-ready pair-dir." |
| ) |
| parser.add_argument("--dataset-root", type=Path, default=Path("datas/Ditto-1M")) |
| parser.add_argument("--output", type=Path, required=True, help="Output JSONL manifest path.") |
| parser.add_argument("--summary-output", type=Path, default=None) |
| parser.add_argument("--csv-names", nargs="*", default=DEFAULT_CSVS) |
| parser.add_argument("--task-prefixes", nargs="*", default=[]) |
| parser.add_argument("--exclude-keywords", nargs="*", default=DEFAULT_EXCLUDE_KEYWORDS) |
| parser.add_argument("--include-existing-only", action="store_true") |
| parser.add_argument("--dedupe-by", choices=["high", "low_high_prompt", "none"], default="high") |
| parser.add_argument("--limit", type=int, default=0) |
| parser.add_argument("--offset", type=int, default=0) |
| parser.add_argument("--sample-id-prefix", default="ditto_pair") |
| parser.add_argument("--materialize-pair-dir", type=Path, default=None) |
| parser.add_argument("--materialize-low", action="store_true") |
| parser.add_argument("--materialize-high", action="store_true") |
| parser.add_argument("--materialize-reference", action="store_true") |
| parser.add_argument("--overwrite-existing", action="store_true") |
| parser.add_argument("--strict-materialize", action="store_true") |
| parser.add_argument("--materialize-limit", type=int, default=0) |
| parser.add_argument("--skip-copy-if-present", action="store_true") |
| parser.add_argument("--compact-pair-json", action="store_true", help="Write pair.json in compact low/high/prompt format.") |
| return parser.parse_args() |
|
|
|
|
| def _csv_task_family(csv_name: str, high_rel: str) -> str: |
| if csv_name == "sim2real.csv": |
| return "sim2real" |
| if high_rel.startswith("global_freeform1/"): |
| return "global_freeform1" |
| if high_rel.startswith("global_freeform2/"): |
| return "global_freeform2" |
| if high_rel.startswith("global_freeform3/"): |
| return "global_freeform3" |
| if high_rel.startswith("global_style1/") or high_rel.startswith("global_style2/"): |
| return "global_style" |
| if high_rel.startswith("local/"): |
| return "local" |
| return csv_name.replace(".csv", "") |
|
|
|
|
| def _dedupe_key(kind: str, row: dict[str, str]) -> str: |
| if kind == "none": |
| return "" |
| if kind == "high": |
| return str(row.get("video", "") or "") |
| return "||".join( |
| [ |
| str(row.get("vace_video", "") or ""), |
| str(row.get("video", "") or ""), |
| str(row.get("prompt", "") or ""), |
| ] |
| ) |
|
|
|
|
| def _matches_prefixes(high_rel: str, prefixes: list[str]) -> bool: |
| if not prefixes: |
| return True |
| return any(high_rel.startswith(prefix) for prefix in prefixes) |
|
|
|
|
| def _contains_excluded_keyword(prompt: str, keywords: list[str]) -> bool: |
| prompt_lower = prompt.lower() |
| return any(keyword.lower() in prompt_lower for keyword in keywords) |
|
|
|
|
| def _record_from_row( |
| dataset_root: Path, |
| csv_name: str, |
| row_index: int, |
| row: dict[str, str], |
| ) -> dict[str, Any]: |
| high_rel = str(row.get("video", "") or "").strip().lstrip("./") |
| low_rel = str(row.get("vace_video", "") or "").strip().lstrip("./") |
| prompt = str(row.get("prompt", "") or "").strip() |
| reference_rel = str(row.get("vace_reference_image", "") or "").strip().lstrip("./") |
| low_path = dataset_root / "videos" / low_rel |
| high_path = dataset_root / "videos" / high_rel |
| reference_path = dataset_root / "videos" / reference_rel if reference_rel else None |
| task_family = _csv_task_family(csv_name, high_rel) |
| source_bucket = low_rel.split("/", 1)[0] if "/" in low_rel else low_rel |
| target_bucket = high_rel.split("/", 1)[0] if "/" in high_rel else high_rel |
| return { |
| "source_csv": csv_name, |
| "row_index": row_index, |
| "task_family": task_family, |
| "source_bucket": source_bucket, |
| "target_bucket": target_bucket, |
| "prompt": prompt, |
| "low_video_relpath": low_rel, |
| "high_video_relpath": high_rel, |
| "reference_relpath": reference_rel, |
| "low_video_path": str(low_path), |
| "high_video_path": str(high_path), |
| "reference_path": str(reference_path) if reference_path is not None else "", |
| "low_exists": low_path.exists(), |
| "high_exists": high_path.exists(), |
| "reference_exists": reference_path.exists() if reference_path is not None else False, |
| } |
|
|
|
|
| def _contiguous_parts(directory: Path, prefix: str) -> list[Path]: |
| parts: list[tuple[int, Path]] = [] |
| for path in directory.glob(f"{prefix}.*"): |
| match = re.search(r"\.(\d+)$", path.name) |
| if match: |
| parts.append((int(match.group(1)), path)) |
| parts.sort(key=lambda item: item[0]) |
| contiguous: list[Path] = [] |
| expected = 1 |
| for index, path in parts: |
| if index != expected: |
| break |
| contiguous.append(path) |
| expected += 1 |
| return contiguous |
|
|
|
|
| def _archive_parts_for_bucket(dataset_root: Path, bucket: str) -> list[Path]: |
| bucket_dir = dataset_root / "videos" / bucket |
| prefix = f"{bucket}.tar.gz" |
| return _contiguous_parts(bucket_dir, prefix) |
|
|
|
|
| def _copy_if_present(src: Path, dst: Path, overwrite: bool) -> bool: |
| if not src.exists(): |
| return False |
| if dst.exists() and not overwrite: |
| return True |
| dst.parent.mkdir(parents=True, exist_ok=True) |
| shutil.copy2(src, dst) |
| return True |
|
|
|
|
| def _symlink_or_copy(src: Path, dst: Path, overwrite: bool) -> bool: |
| if not src.exists(): |
| return False |
| if dst.exists() or dst.is_symlink(): |
| if not overwrite: |
| return True |
| dst.unlink() |
| dst.parent.mkdir(parents=True, exist_ok=True) |
| try: |
| dst.symlink_to(src) |
| except OSError: |
| shutil.copy2(src, dst) |
| return True |
|
|
|
|
| def _extract_from_archive(parts: list[Path], relpath: str, dst: Path) -> bool: |
| if not parts: |
| return False |
| dst.parent.mkdir(parents=True, exist_ok=True) |
| joined = " ".join(str(path) for path in parts) |
| rel = relpath.lstrip("./") |
| cmd = f"cat {joined} | tar -xzf - -O ./{rel} > {shlex_quote(str(dst))}" |
| completed = subprocess.run(cmd, shell=True, executable="/bin/bash") |
| if completed.returncode != 0: |
| if dst.exists(): |
| dst.unlink() |
| return False |
| return True |
|
|
|
|
| def shlex_quote(text: str) -> str: |
| import shlex |
| return shlex.quote(text) |
|
|
|
|
| def _materialize_one( |
| dataset_root: Path, |
| relpath: str, |
| out_path: Path, |
| *, |
| bucket_override: str | None = None, |
| overwrite: bool, |
| skip_copy_if_present: bool, |
| ) -> tuple[bool, str]: |
| rel = relpath.strip().lstrip("./") |
| if not rel: |
| return False, "missing_relpath" |
| if out_path.exists() and not overwrite: |
| return True, "already_exists" |
|
|
| direct_src = dataset_root / "videos" / rel |
| if direct_src.exists(): |
| if skip_copy_if_present: |
| return (_symlink_or_copy(direct_src, out_path, overwrite), "linked_direct") |
| return (_copy_if_present(direct_src, out_path, overwrite), "copied_direct") |
|
|
| bucket = bucket_override or (rel.split("/", 1)[0] if "/" in rel else "") |
| if not bucket: |
| return False, "missing_bucket" |
| parts = _archive_parts_for_bucket(dataset_root, bucket) |
| ok = _extract_from_archive(parts, rel, out_path) |
| return ok, "extracted_archive" if ok else f"extract_failed:{bucket}" |
|
|
|
|
| def _materialize_pair_dir(args: argparse.Namespace, records: list[dict[str, Any]]) -> dict[str, Any]: |
| pair_dir = args.materialize_pair_dir |
| assert pair_dir is not None |
| pair_dir.mkdir(parents=True, exist_ok=True) |
| low_dir = pair_dir / "low" |
| high_dir = pair_dir / "high" |
| ref_dir = pair_dir / "reference" |
| low_dir.mkdir(parents=True, exist_ok=True) |
| high_dir.mkdir(parents=True, exist_ok=True) |
| if args.materialize_reference: |
| ref_dir.mkdir(parents=True, exist_ok=True) |
|
|
| selected = records[: args.materialize_limit] if args.materialize_limit > 0 else list(records) |
| manifest: list[dict[str, Any]] = [] |
| compact_pairs: list[dict[str, Any]] = [] |
| skipped = Counter() |
|
|
| for record in selected: |
| low_rel = str(record["low_video_relpath"]) |
| high_rel = str(record["high_video_relpath"]) |
| ref_rel = str(record.get("reference_relpath", "") or "") |
| low_name = Path(low_rel).name |
| high_path = Path(high_rel) |
| high_name = str(high_path) if len(high_path.parts) > 1 else high_path.name |
| ref_name = Path(ref_rel).name if ref_rel else "" |
|
|
| low_ok = True |
| high_ok = True |
| ref_ok = True |
|
|
| if args.materialize_low: |
| low_ok, low_reason = _materialize_one( |
| args.dataset_root, |
| low_rel, |
| low_dir / low_name, |
| bucket_override="source", |
| overwrite=args.overwrite_existing, |
| skip_copy_if_present=args.skip_copy_if_present, |
| ) |
| if not low_ok: |
| skipped[f"low::{low_reason}"] += 1 |
|
|
| if args.materialize_high: |
| high_ok, high_reason = _materialize_one( |
| args.dataset_root, |
| high_rel, |
| high_dir / high_name, |
| overwrite=args.overwrite_existing, |
| skip_copy_if_present=args.skip_copy_if_present, |
| ) |
| if not high_ok: |
| skipped[f"high::{high_reason}"] += 1 |
|
|
| if args.materialize_reference and ref_rel: |
| ref_ok, ref_reason = _materialize_one( |
| args.dataset_root, |
| ref_rel, |
| ref_dir / ref_name, |
| overwrite=args.overwrite_existing, |
| skip_copy_if_present=args.skip_copy_if_present, |
| ) |
| if not ref_ok: |
| skipped[f"ref::{ref_reason}"] += 1 |
|
|
| if args.strict_materialize and not (low_ok and high_ok and ref_ok): |
| continue |
|
|
| manifest.append( |
| { |
| "sample_id": record["sample_id"], |
| "row_index": record["row_index"], |
| "source_csv": record["source_csv"], |
| "task_family": record["task_family"], |
| "prompt": record["prompt"], |
| "low_rel": low_rel, |
| "high_rel": high_rel, |
| "ref_rel": ref_rel, |
| "low_video_path": record["low_video_path"], |
| "high_video_path": record["high_video_path"], |
| "reference_path": record["reference_path"], |
| "low_materialized": str((low_dir / low_name)) if args.materialize_low and low_ok else "", |
| "high_materialized": str((high_dir / high_name)) if args.materialize_high and high_ok else "", |
| "reference_materialized": str((ref_dir / ref_name)) if args.materialize_reference and ref_rel and ref_ok else "", |
| } |
| ) |
| compact_pairs.append( |
| { |
| "sample_id": record["sample_id"], |
| "prompt": record["prompt"], |
| "low": f"low/{low_name}" if args.materialize_low and low_ok else "", |
| "high": f"high/{high_name}" if args.materialize_high and high_ok else "", |
| "low_rel": low_rel, |
| "high_rel": high_rel, |
| } |
| ) |
|
|
| manifest_path = pair_dir / "manifest.json" |
| manifest_path.write_text(json.dumps(manifest, ensure_ascii=False, indent=2), encoding="utf-8") |
| pair_json_path = pair_dir / "pair.json" |
| pair_json_path.write_text(json.dumps(compact_pairs, ensure_ascii=False, indent=2), encoding="utf-8") |
| return { |
| "pair_dir": str(pair_dir), |
| "manifest_path": str(manifest_path), |
| "pair_json_path": str(pair_json_path), |
| "materialized_count": len(manifest), |
| "materialize_skipped": dict(skipped), |
| } |
|
|
|
|
| def main() -> None: |
| args = parse_args() |
| csv_dir = args.dataset_root / "csvs_for_DiffSynth" |
| records: list[dict[str, Any]] = [] |
| seen: set[str] = set() |
| skipped = Counter() |
|
|
| for csv_name in args.csv_names: |
| csv_path = csv_dir / csv_name |
| if not csv_path.exists(): |
| skipped["missing_csv"] += 1 |
| continue |
| with csv_path.open("r", encoding="utf-8", newline="") as f: |
| reader = csv.DictReader(f) |
| for row_index, row in enumerate(reader): |
| high_rel = str(row.get("video", "") or "").strip() |
| prompt = str(row.get("prompt", "") or "").strip() |
| if not high_rel: |
| skipped["missing_high_rel"] += 1 |
| continue |
| if not _matches_prefixes(high_rel, args.task_prefixes): |
| skipped["prefix_filtered"] += 1 |
| continue |
| if args.exclude_keywords and _contains_excluded_keyword(prompt, args.exclude_keywords): |
| skipped["keyword_filtered"] += 1 |
| continue |
| key = _dedupe_key(args.dedupe_by, row) |
| if key and key in seen: |
| skipped["deduped"] += 1 |
| continue |
| record = _record_from_row(args.dataset_root, csv_name, row_index, row) |
| if args.include_existing_only and not (record["low_exists"] and record["high_exists"]): |
| skipped["missing_files"] += 1 |
| continue |
| if key: |
| seen.add(key) |
| records.append(record) |
|
|
| if args.offset > 0: |
| records = records[args.offset :] |
| if args.limit > 0: |
| records = records[: args.limit] |
|
|
| for idx, record in enumerate(records, start=1): |
| record["sample_id"] = f"{args.sample_id_prefix}_{idx:06d}" |
|
|
| args.output.parent.mkdir(parents=True, exist_ok=True) |
| with args.output.open("w", encoding="utf-8") as f: |
| for record in records: |
| f.write(json.dumps(record, ensure_ascii=False) + "\n") |
|
|
| summary: dict[str, Any] = { |
| "count": len(records), |
| "dataset_root": str(args.dataset_root), |
| "output": str(args.output), |
| "csv_names": args.csv_names, |
| "task_prefixes": args.task_prefixes, |
| "include_existing_only": args.include_existing_only, |
| "dedupe_by": args.dedupe_by, |
| "task_family_counts": dict(Counter(str(record["task_family"]) for record in records)), |
| "target_bucket_counts": dict(Counter(str(record["target_bucket"]) for record in records)), |
| "skipped": dict(skipped), |
| } |
|
|
| if args.materialize_pair_dir is not None: |
| materialize_summary = _materialize_pair_dir(args, records) |
| summary["materialize"] = materialize_summary |
|
|
| summary_path = args.summary_output or args.output.with_suffix(".summary.json") |
| summary_path.write_text(json.dumps(summary, ensure_ascii=False, indent=2), encoding="utf-8") |
| print(json.dumps(summary, ensure_ascii=False, indent=2)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
