lingbot_test/script/subset_dataset.py

"""
Extract a small subset from a full lingbot-va dataset for quick model testing.

Supports both single-dataset and multi-dataset (recursive) layouts.
Copies metadata, latent files, action parquets, and trims videos (via ffmpeg)
for a specified number of episodes.

Usage:
    python subset_dataset.py \
        --src /path/to/full_dataset \
        --dst /path/to/subset_dataset \
        --num-episodes 5 \
        --copy-videos
"""

from __future__ import annotations

import argparse
import json
import os
import shutil
import subprocess
from pathlib import Path

import pandas as pd


def find_dataset_roots(base: Path) -> list[Path]:
    """Recursively find all dataset roots (dirs containing meta/info.json)."""
    roots = []
    for dirpath, _, filenames in os.walk(base):
        if "info.json" in filenames and Path(dirpath).name == "meta":
            roots.append(Path(dirpath).parent)
    if not roots:
        raise FileNotFoundError(
            f"No dataset found under {base} (looking for meta/info.json)"
        )
    return sorted(roots)


def load_jsonl(path: Path) -> list[dict]:
    rows = []
    with open(path, "r", encoding="utf-8") as f:
        for line in f:
            line = line.strip()
            if line:
                rows.append(json.loads(line))
    return rows


def save_jsonl(rows: list[dict], path: Path):
    path.parent.mkdir(parents=True, exist_ok=True)
    with open(path, "w", encoding="utf-8") as f:
        for row in rows:
            f.write(json.dumps(row, ensure_ascii=False) + "\n")


def resolve_action_config_path(root: Path) -> Path | None:
    candidates = [
        root / "meta/lingbot_action_config.jsonl",
        root / "meta/action_config.jsonl",
        root / "meta/episodes.jsonl",
    ]
    for c in candidates:
        if c.exists():
            return c
    return None


def get_segments(config_path: Path) -> list[dict]:
    """Load action segments from config file, handling legacy format."""
    rows = load_jsonl(config_path)

    if config_path.name == "episodes.jsonl":
        segments = []
        for row in rows:
            if "action_config" in row:
                for ac in row["action_config"]:
                    seg = {"episode_index": int(row["episode_index"])}
                    seg.update(ac)
                    if "tasks" in row:
                        seg.setdefault("tasks", row["tasks"])
                    segments.append(seg)
            else:
                tasks = row.get("tasks", [])
                action_text = tasks[0] if tasks else "robot manipulation"
                segments.append({
                    "episode_index": int(row["episode_index"]),
                    "tasks": tasks,
                    "start_frame": 0,
                    "end_frame": int(row["length"]),
                    "action_text": action_text,
                })
        return segments

    # lingbot_action_config.jsonl / action_config.jsonl: flat format
    return rows


def copy_latents_for_episodes(
    src_root: Path, dst_root: Path, episode_indices: set[int], segments: list[dict],
):
    """Copy latent .pth files for selected episodes."""
    latent_src = src_root / "latents"
    if not latent_src.exists():
        print(f"  [skip] no latents/ dir in {src_root}")
        return 0

    copied = 0
    for seg in segments:
        ep = int(seg["episode_index"])
        if ep not in episode_indices:
            continue
        sf = int(seg["start_frame"])
        ef = int(seg["end_frame"])
        chunk_id = ep // 1000

        chunk_dir = latent_src / f"chunk-{chunk_id:03d}"
        if not chunk_dir.exists():
            continue

        for cam_dir in chunk_dir.iterdir():
            if not cam_dir.is_dir():
                continue
            fname = f"episode_{ep:06d}_{sf}_{ef}.pth"
            src_file = cam_dir / fname
            if src_file.exists():
                dst_file = dst_root / "latents" / f"chunk-{chunk_id:03d}" / cam_dir.name / fname
                dst_file.parent.mkdir(parents=True, exist_ok=True)
                shutil.copy2(src_file, dst_file)
                copied += 1
    return copied


def _load_episode_metadata(src_root: Path) -> dict[int, dict]:
    """Load episode metadata from jsonl or parquet and return {episode_index: row_dict}."""
    # v3.0: meta/episodes/ is a parquet directory
    ep_parquet_dir = src_root / "meta/episodes"
    if ep_parquet_dir.is_dir():
        df = pd.read_parquet(ep_parquet_dir)
        rows = df.to_dict("records")
        return {int(r["episode_index"]): r for r in rows}

    # single parquet file
    ep_parquet = src_root / "meta/episodes.parquet"
    if ep_parquet.exists():
        df = pd.read_parquet(ep_parquet)
        rows = df.to_dict("records")
        return {int(r["episode_index"]): r for r in rows}

    # legacy jsonl
    ep_jsonl = src_root / "meta/episodes.jsonl"
    if ep_jsonl.exists():
        rows = load_jsonl(ep_jsonl)
        return {int(r["episode_index"]): r for r in rows}

    return {}


def _discover_cam_keys(ep_meta: dict[int, dict]) -> set[str]:
    """Find all camera keys from episode metadata."""
    cams = set()
    for row in ep_meta.values():
        for k in row:
            if k.startswith("videos/") and k.endswith("/chunk_index"):
                cams.add(k.split("/")[1])
    return cams


def _ffmpeg_trim(src_mp4: Path, dst_mp4: Path, start: float, end: float | None):
    """Trim a video clip with ffmpeg (stream copy, no re-encoding)."""
    dst_mp4.parent.mkdir(parents=True, exist_ok=True)
    cmd = [
        "ffmpeg", "-y",
        "-i", str(src_mp4),
        "-ss", f"{start:.6f}",
    ]
    if end is not None:
        cmd += ["-to", f"{end:.6f}"]
    cmd += [
        "-c", "copy",
        "-avoid_negative_ts", "make_zero",
        str(dst_mp4),
    ]
    result = subprocess.run(cmd, capture_output=True, text=True)
    if result.returncode != 0:
        print(f"  [warn] ffmpeg failed for {src_mp4}: {result.stderr[-200:]}")
        return False
    return True


def _ffmpeg_concat(clip_paths: list[Path], dst_mp4: Path):
    """Concatenate multiple clips into one file using ffmpeg concat demuxer."""
    dst_mp4.parent.mkdir(parents=True, exist_ok=True)
    # Write concat list file
    list_file = dst_mp4.parent / ".concat_list.txt"
    with open(list_file, "w") as f:
        for p in clip_paths:
            f.write(f"file '{p}'\n")
    cmd = [
        "ffmpeg", "-y",
        "-f", "concat", "-safe", "0",
        "-i", str(list_file),
        "-c", "copy",
        str(dst_mp4),
    ]
    result = subprocess.run(cmd, capture_output=True, text=True)
    list_file.unlink(missing_ok=True)
    if result.returncode != 0:
        print(f"  [warn] ffmpeg concat failed: {result.stderr[-300:]}")
        return False
    return True


def trim_videos_for_episodes(
    src_root: Path,
    dst_root: Path,
    episode_indices: set[int],
    ep_meta: dict[int, dict],
) -> dict[int, dict]:
    """Trim and concatenate video clips for selected episodes.

    For each camera, groups episodes by source video file, trims each
    group as a contiguous range [min(from_ts), max(to_ts)], then
    concatenates all groups into a single output file-000.mp4.
    Updates episode metadata with new timestamps.

    Returns metadata updates: {episode_index: {field: new_value, ...}}
    """
    from collections import defaultdict

    vid_src = src_root / "videos"
    meta_updates: dict[int, dict] = {}

    if not vid_src.exists() or not ep_meta:
        return meta_updates

    cam_keys = _discover_cam_keys(ep_meta)
    if not cam_keys:
        return meta_updates

    for cam in sorted(cam_keys):
        # Group selected episodes by source video file
        groups: dict[tuple[int, int], list[int]] = defaultdict(list)
        for ep in sorted(episode_indices):
            row = ep_meta.get(ep)
            if row is None:
                continue
            chunk_idx = row.get(f"videos/{cam}/chunk_index")
            file_idx = row.get(f"videos/{cam}/file_index")
            if chunk_idx is None or file_idx is None:
                continue
            groups[(int(chunk_idx), int(file_idx))].append(ep)

        if not groups:
            continue

        # Trim each source file to [min_from, max_to], track cumulative offset
        temp_clips: list[Path] = []
        cumulative_offset = 0.0

        for (chunk_idx, file_idx), eps in sorted(groups.items()):
            src_mp4 = (
                vid_src / cam
                / f"chunk-{chunk_idx:03d}"
                / f"file-{file_idx:03d}.mp4"
            )
            if not src_mp4.exists():
                print(f"  [warn] source video not found: {src_mp4}")
                continue

            # Find time range for this group
            from_ts_list = []
            to_ts_list = []
            for ep in eps:
                row = ep_meta[ep]
                from_ts_list.append(float(row[f"videos/{cam}/from_timestamp"]))
                to_ts_raw = row.get(f"videos/{cam}/to_timestamp")
                if to_ts_raw is not None:
                    to_ts_list.append(float(to_ts_raw))

            min_from = min(from_ts_list)
            max_to = max(to_ts_list) if to_ts_list else None

            # Trim source file to this range
            temp_clip = dst_root / f".tmp_{cam.replace('.', '_')}_{chunk_idx}_{file_idx}.mp4"
            ok = _ffmpeg_trim(src_mp4, temp_clip, min_from, max_to)
            if not ok:
                continue
            temp_clips.append(temp_clip)

            # Update each episode's metadata
            for ep in eps:
                row = ep_meta[ep]
                orig_from = float(row[f"videos/{cam}/from_timestamp"])
                orig_to_raw = row.get(f"videos/{cam}/to_timestamp")

                updates = meta_updates.setdefault(ep, {})
                updates[f"videos/{cam}/chunk_index"] = 0
                updates[f"videos/{cam}/file_index"] = 0
                updates[f"videos/{cam}/from_timestamp"] = cumulative_offset + (orig_from - min_from)
                if orig_to_raw is not None:
                    updates[f"videos/{cam}/to_timestamp"] = cumulative_offset + (float(orig_to_raw) - min_from)

            # Advance cumulative offset by the duration of this clip
            if max_to is not None:
                cumulative_offset += max_to - min_from

        # Concatenate all clips into one output file
        dst_mp4 = dst_root / "videos" / cam / "chunk-000" / "file-000.mp4"
        if len(temp_clips) == 1:
            dst_mp4.parent.mkdir(parents=True, exist_ok=True)
            shutil.move(str(temp_clips[0]), str(dst_mp4))
        elif len(temp_clips) > 1:
            _ffmpeg_concat(temp_clips, dst_mp4)
            for tc in temp_clips:
                tc.unlink(missing_ok=True)

        print(f"  [{cam}] merged {len(temp_clips)} clip(s) into {dst_mp4.relative_to(dst_root)}")

    return meta_updates



def copy_data_parquets(
    src_root: Path, dst_root: Path, episode_indices: set[int],
):
    """Copy and filter data parquet files to only include selected episodes."""
    data_src = src_root / "data"
    if not data_src.exists():
        return 0

    copied = 0
    for pq_file in sorted(data_src.rglob("*.parquet")):
        try:
            df = pd.read_parquet(pq_file)
        except Exception as e:
            print(f"  [warn] cannot read {pq_file}: {e}")
            continue

        if "episode_index" in df.columns:
            df_sub = df[df["episode_index"].isin(episode_indices)]
        else:
            df_sub = df

        if len(df_sub) == 0:
            continue

        rel = pq_file.relative_to(src_root)
        dst_file = dst_root / rel
        dst_file.parent.mkdir(parents=True, exist_ok=True)
        df_sub.to_parquet(dst_file, index=False)
        copied += 1

    return copied


def _apply_meta_updates(rows: list[dict], updates: dict[int, dict]) -> list[dict]:
    """Apply video metadata updates to episode rows."""
    if not updates:
        return rows
    out = []
    for row in rows:
        ep = int(row["episode_index"])
        if ep in updates:
            row = dict(row)
            row.update(updates[ep])
        out.append(row)
    return out


def subset_single_dataset(
    src_root: Path,
    dst_root: Path,
    num_episodes: int,
    copy_videos: bool = False,
):
    """Create a subset of a single dataset."""
    print(f"\nProcessing: {src_root}")

    # 1. Load action config to find available episodes
    config_path = resolve_action_config_path(src_root)
    if config_path is None:
        print("  [skip] no action config found")
        return

    all_segments = get_segments(config_path)
    all_episodes = sorted({int(s["episode_index"]) for s in all_segments})
    selected = set(all_episodes[:num_episodes])
    selected_segments = [s for s in all_segments if int(s["episode_index"]) in selected]

    print(f"  Total episodes: {len(all_episodes)}, selecting: {len(selected)}")
    print(f"  Total segments: {len(all_segments)}, selecting: {len(selected_segments)}")

    dst_root.mkdir(parents=True, exist_ok=True)

    # 2. Copy meta/info.json
    info_src = src_root / "meta/info.json"
    if info_src.exists():
        (dst_root / "meta").mkdir(parents=True, exist_ok=True)
        shutil.copy2(info_src, dst_root / "meta/info.json")

    # 3. Trim videos (must happen before writing episodes.jsonl so we can
    #    apply metadata updates for the new video paths/timestamps)
    video_meta_updates: dict[int, dict] = {}
    if copy_videos:
        ep_meta = _load_episode_metadata(src_root)
        video_meta_updates = trim_videos_for_episodes(
            src_root, dst_root, selected, ep_meta,
        )

    # 4. Write filtered action config
    if config_path.name == "episodes.jsonl":
        orig_rows = load_jsonl(config_path)
        filtered_rows = [r for r in orig_rows if int(r["episode_index"]) in selected]
        filtered_rows = _apply_meta_updates(filtered_rows, video_meta_updates)
        save_jsonl(filtered_rows, dst_root / "meta/episodes.jsonl")
    else:
        save_jsonl(selected_segments, dst_root / config_path.relative_to(src_root))

    # 5. Copy & filter episode metadata (parquet dir, parquet file, or jsonl)
    ep_parquet_dir = src_root / "meta/episodes"
    ep_parquet_file = src_root / "meta/episodes.parquet"
    ep_jsonl_file = src_root / "meta/episodes.jsonl"

    if ep_parquet_dir.is_dir():
        df = pd.read_parquet(ep_parquet_dir)
        df_sub = df[df["episode_index"].isin(selected)].copy()
        for ep_idx in df_sub["episode_index"]:
            if int(ep_idx) in video_meta_updates:
                for k, v in video_meta_updates[int(ep_idx)].items():
                    df_sub.loc[df_sub["episode_index"] == ep_idx, k] = v
        dst_ep_file = dst_root / "meta/episodes/chunk-000/file-000.parquet"
        dst_ep_file.parent.mkdir(parents=True, exist_ok=True)
        df_sub.to_parquet(dst_ep_file, index=False)
        print(f"  Wrote {len(df_sub)} rows to meta/episodes/")
    elif ep_parquet_file.exists():
        df = pd.read_parquet(ep_parquet_file)
        df_sub = df[df["episode_index"].isin(selected)].copy()
        for ep_idx in df_sub["episode_index"]:
            if int(ep_idx) in video_meta_updates:
                for k, v in video_meta_updates[int(ep_idx)].items():
                    df_sub.loc[df_sub["episode_index"] == ep_idx, k] = v
        (dst_root / "meta").mkdir(parents=True, exist_ok=True)
        df_sub.to_parquet(dst_root / "meta/episodes.parquet", index=False)
    elif ep_jsonl_file.exists() and config_path.name != "episodes.jsonl":
        orig_rows = load_jsonl(ep_jsonl_file)
        filtered_rows = [r for r in orig_rows if int(r["episode_index"]) in selected]
        filtered_rows = _apply_meta_updates(filtered_rows, video_meta_updates)
        save_jsonl(filtered_rows, dst_root / "meta/episodes.jsonl")

    # 6. Copy empty_emb.pt
    emb_src = src_root / "empty_emb.pt"
    if emb_src.exists():
        shutil.copy2(emb_src, dst_root / "empty_emb.pt")

    # 7. Copy latent files
    n = copy_latents_for_episodes(src_root, dst_root, selected, selected_segments)
    print(f"  Copied {n} latent files")

    # 8. Copy & filter data parquets
    n = copy_data_parquets(src_root, dst_root, selected)
    print(f"  Copied {n} data parquet files")

    # 9. Copy other meta files (stats, tasks, etc.)
    meta_src = src_root / "meta"
    if meta_src.exists():
        for f in meta_src.iterdir():
            if f.name in ("info.json", "episodes.jsonl", "episodes.parquet",
                          "episodes", "lingbot_action_config.jsonl",
                          "action_config.jsonl"):
                continue  # already handled
            dst_f = dst_root / "meta" / f.name
            if f.is_file() and not dst_f.exists():
                dst_f.parent.mkdir(parents=True, exist_ok=True)
                shutil.copy2(f, dst_f)


def main():
    parser = argparse.ArgumentParser(
        description="Extract a small subset from a lingbot-va dataset for testing."
    )
    parser.add_argument("--src", type=str, required=True,
                        help="Source dataset root (single dataset or multi-dataset parent)")
    parser.add_argument("--dst", type=str, required=True,
                        help="Destination path for the subset")
    parser.add_argument("--num-episodes", type=int, default=5,
                        help="Number of episodes to include per sub-dataset (default: 5)")
    parser.add_argument("--copy-videos", action="store_true",
                        help="Also copy raw video files (not needed for latent-based training)")
    args = parser.parse_args()

    src = Path(args.src).resolve()
    dst = Path(args.dst).resolve()

    if dst.exists():
        print(f"Warning: destination {dst} already exists, files may be overwritten.")

    dataset_roots = find_dataset_roots(src)
    print(f"Found {len(dataset_roots)} dataset(s) under {src}")

    for ds_root in dataset_roots:
        rel = ds_root.relative_to(src)
        ds_dst = dst / rel if str(rel) != "." else dst
        subset_single_dataset(ds_root, ds_dst, args.num_episodes, args.copy_videos)

    print(f"\nDone! Subset saved to: {dst}")


if __name__ == "__main__":
    main()