Update scripts/vlac2_release_common.py

scripts/vlac2_release_common.py

@@ -0,0 +1,266 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Callable
+
+
+KNOWN_DATASET_NAMES = (
+    "ARX-data",
+    "dex_fold_v2_mix",
+    "droid_lerobot",
+    "libero",
+    "libero_zty50",
+    "VLABench_5",
+)
+KNOWN_VIDEO_SUFFIXES = {".mp4", ".avi", ".mov", ".mkv", ".webm"}
+PORTABLE_IMAGE_ROOT = Path("_extracted_frames")
+LEGACY_PORTABLE_IMAGE_ROOTS = (
+    Path("extracted_frames"),
+    Path("progress_data") / "VLAC_preprocessed_data" / "data",
+)
+GENERATED_MARKER_FILENAME = "_GENERATED"
+PUBLIC_BENCHMARK_JSON_NAME = "video_progress_benchmark_file.json"
+PUBLIC_RELEASE_ROOT_PLACEHOLDER = "__VLAC2_RELEASE_ROOT__"
+PUBLIC_FRAMES_ROOT_PLACEHOLDER = "__VLAC2_FRAMES_ROOT__"
+PUBLIC_BENCHMARK_DIRNAME = "benchmark_splits"
+FULL_RELEASE_BENCHMARK_DIRNAME = "benchmark_style_all"
+LEGACY_BENCHMARK_DIRNAME = "benchmark_json"
+
+
+def portable_image_roots() -> tuple[Path, ...]:
+    roots = [PORTABLE_IMAGE_ROOT, *LEGACY_PORTABLE_IMAGE_ROOTS]
+    deduped: list[Path] = []
+    seen: set[tuple[str, ...]] = set()
+    for root in roots:
+        key = root.parts
+        if key in seen:
+            continue
+        seen.add(key)
+        deduped.append(root)
+    return tuple(deduped)
+
+
+def load_json(path: Path) -> Any:
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def dump_json(path: Path, payload: Any) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+
+
+def ensure_generated_marker(output_root: Path) -> Path:
+    output_root.mkdir(parents=True, exist_ok=True)
+    marker_path = output_root / GENERATED_MARKER_FILENAME
+    marker_path.write_text(
+        "This directory is generated by the VLAC2 public frame-extraction workflow.\n",
+        encoding="utf-8",
+    )
+    return marker_path
+
+
+def ensure_release_tree(release_root: Path) -> dict[str, Path]:
+    release_root = release_root.resolve()
+    paths = {
+        "release_root": release_root,
+        "raw_root": release_root / "data",
+        "benchmark_root": release_root / PUBLIC_BENCHMARK_DIRNAME,
+        "portable_image_root": release_root / PORTABLE_IMAGE_ROOT,
+        "scripts_root": release_root / "scripts",
+    }
+    for key in ("release_root", "raw_root", "benchmark_root", "scripts_root"):
+        paths[key].mkdir(parents=True, exist_ok=True)
+    return paths
+
+
+def _normalized_parts(raw_path: str | Path) -> list[str]:
+    raw = str(raw_path or "").strip().replace("\\", "/")
+    if not raw:
+        raise ValueError("empty path")
+    return [part for part in Path(raw).parts if part not in ("", ".", "/")]
+
+
+def dataset_relative_path(raw_path: str | Path) -> Path:
+    parts = _normalized_parts(raw_path)
+
+    for idx, part in enumerate(parts):
+        if part in KNOWN_DATASET_NAMES:
+            return Path(*parts[idx:])
+
+    for portable_root in portable_image_roots():
+        marker_parts = list(portable_root.parts)
+        marker_len = len(marker_parts)
+        for idx in range(max(0, len(parts) - marker_len + 1)):
+            if parts[idx : idx + marker_len] == marker_parts:
+                tail = parts[idx + marker_len :]
+                if not tail:
+                    break
+                for tail_idx, part in enumerate(tail):
+                    if part in KNOWN_DATASET_NAMES:
+                        return Path(*tail[tail_idx:])
+                return Path(*tail)
+
+    return Path(*parts)
+
+
+def normalize_main_path(raw_main_path: str | Path) -> Path:
+    rel = dataset_relative_path(raw_main_path)
+    if rel.suffix.lower() in KNOWN_VIDEO_SUFFIXES:
+        return rel.with_suffix("")
+    return rel
+
+
+def main_path_from_frame_path(raw_frame_path: str | Path) -> Path:
+    rel = dataset_relative_path(raw_frame_path)
+    if rel.suffix:
+        return rel.parent
+    return rel
+
+
+def portable_frame_path_from_any(raw_frame_path: str | Path) -> Path:
+    return PORTABLE_IMAGE_ROOT / dataset_relative_path(raw_frame_path)
+
+
+def placeholder_frame_path_from_any(raw_frame_path: str | Path) -> str:
+    return f"{PUBLIC_FRAMES_ROOT_PLACEHOLDER}/{dataset_relative_path(raw_frame_path).as_posix()}"
+
+
+def absolute_frame_path_from_any(raw_frame_path: str | Path, frames_root: Path) -> Path:
+    raw = str(raw_frame_path or "").strip()
+    if not raw:
+        raise ValueError("empty frame path")
+    path = Path(raw)
+    if path.is_absolute():
+        return path
+
+    parts = _normalized_parts(raw)
+    if parts and parts[0] in (PUBLIC_FRAMES_ROOT_PLACEHOLDER, PUBLIC_RELEASE_ROOT_PLACEHOLDER):
+        parts = parts[1:]
+
+    for portable_root in portable_image_roots():
+        marker_parts = list(portable_root.parts)
+        if parts[: len(marker_parts)] == marker_parts:
+            return frames_root.resolve() / Path(*parts[len(marker_parts) :])
+    if parts and parts[0] in KNOWN_DATASET_NAMES:
+        return frames_root.resolve() / Path(*parts)
+    return frames_root.resolve() / Path(*parts)
+
+
+def rewrite_benchmark_image_paths(
+    rows: list[dict[str, Any]],
+    path_rewriter: Callable[[str], str],
+) -> list[dict[str, Any]]:
+    rewritten_rows: list[dict[str, Any]] = []
+    for row in rows:
+        rewritten = dict(row)
+
+        frame_index = dict(row.get("frame_index") or {})
+        if frame_index:
+            rewritten_frame_index: dict[str, dict[str, str]] = {}
+            for frame_idx, images in frame_index.items():
+                image_map = dict(images or {})
+                rewritten_frame_index[str(frame_idx)] = {
+                    str(view): path_rewriter(str(image_path))
+                    for view, image_path in image_map.items()
+                    if str(image_path or "").strip()
+                }
+            rewritten["frame_index"] = rewritten_frame_index
+
+        reference_context = row.get("reference_context")
+        if isinstance(reference_context, dict):
+            rewritten_ref = dict(reference_context)
+            anchors = list(reference_context.get("reference_anchors") or [])
+            rewritten_anchors: list[dict[str, Any]] = []
+            for anchor in anchors:
+                rewritten_anchor = dict(anchor)
+                images = dict(anchor.get("images") or {})
+                if images:
+                    rewritten_anchor["images"] = {
+                        str(view): path_rewriter(str(image_path))
+                        for view, image_path in images.items()
+                        if str(image_path or "").strip()
+                    }
+                rewritten_anchors.append(rewritten_anchor)
+            rewritten_ref["reference_anchors"] = rewritten_anchors
+            rewritten["reference_context"] = rewritten_ref
+
+        videos = row.get("videos")
+        if isinstance(videos, list):
+            rewritten_videos: list[Any] = []
+            for item in videos:
+                if isinstance(item, list):
+                    rewritten_videos.append(
+                        [path_rewriter(str(path)) for path in item if str(path or "").strip()]
+                    )
+                elif isinstance(item, str) and item.strip():
+                    rewritten_videos.append(path_rewriter(item))
+            rewritten["videos"] = rewritten_videos
+
+        images = row.get("images")
+        if isinstance(images, list):
+            rewritten["images"] = [
+                path_rewriter(str(path))
+                for path in images
+                if str(path or "").strip()
+            ]
+
+        rewritten_rows.append(rewritten)
+    return rewritten_rows
+
+
+def infer_main_path_from_row(row: dict[str, Any]) -> Path | None:
+    for meta_key in ("metadata", "_meta", "meta"):
+        meta = row.get(meta_key)
+        if isinstance(meta, dict):
+            raw_main_path = str(meta.get("main_path") or "").strip()
+            if raw_main_path:
+                return normalize_main_path(raw_main_path)
+
+    frame_index = row.get("frame_index")
+    if isinstance(frame_index, dict):
+        for images in frame_index.values():
+            if not isinstance(images, dict):
+                continue
+            for image_path in images.values():
+                if str(image_path or "").strip():
+                    return main_path_from_frame_path(str(image_path))
+
+    videos = row.get("videos")
+    if isinstance(videos, list) and videos:
+        first = videos[0]
+        if isinstance(first, list) and first:
+            return main_path_from_frame_path(str(first[0]))
+        if isinstance(first, str) and first.strip():
+            return main_path_from_frame_path(first)
+
+    return None
+
+
+def discover_benchmark_jsons(benchmark_root: Path) -> list[Path]:
+    benchmark_root = benchmark_root.resolve()
+    candidates: list[Path] = []
+    seen: set[Path] = set()
+    for pattern in ("**/video_progress_benchmark_file.json", "**/intermediate_benchmark_*.json"):
+        for path in sorted(benchmark_root.glob(pattern)):
+            resolved = path.resolve()
+            if resolved in seen:
+                continue
+            seen.add(resolved)
+            candidates.append(resolved)
+    return candidates
+
+
+def resolve_benchmark_root(release_root: Path) -> Path:
+    release_root = release_root.resolve()
+    preferred = release_root / PUBLIC_BENCHMARK_DIRNAME
+    full_release = release_root / FULL_RELEASE_BENCHMARK_DIRNAME
+    legacy = release_root / LEGACY_BENCHMARK_DIRNAME
+    if preferred.exists():
+        return preferred
+    if full_release.exists():
+        return full_release
+    if legacy.exists():
+        return legacy
+    return preferred