Add side-by-side rollout vs. ground-truth viewer

Gradio app that reads 33-frame critical-window rollouts from a separate HF
dataset repo (default OneWorld-AI/abc-critical-window-rollout).

GT and generated are composed into a single frame-locked video rather than
shown in two independent players, which drift apart and cannot be scrubbed
together. Adds an optional absolute-difference panel, a frame stepper, the
driving action chunk, and filtering/sorting by task, gripper edge, arm and
critical-frame PSNR.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

.gitignore

@@ -0,0 +1,3 @@
+.venv/
+__pycache__/
+.omc/

README.md

@@ -1,6 +1,6 @@
 ---
-title: Test
-emoji: 👀
+title: Rollout vs Ground Truth
+emoji: 🎬
 colorFrom: green
 colorTo: purple
 sdk: gradio
@@ -8,6 +8,61 @@ sdk_version: 6.22.0
 python_version: '3.12'
 app_file: app.py
 pinned: false
+short_description: Frame-locked viewer for rollouts vs. ground truth
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Rollout vs. ground truth
+
+Side-by-side viewer for forward-dynamics world-model rollouts. Reads windows straight from a
+Hugging Face **dataset** repo — the Space holds no data of its own.
+
+Default dataset: [`OneWorld-AI/abc-critical-window-rollout`](https://huggingface.co/datasets/OneWorld-AI/abc-critical-window-rollout)
+(300 held-out ABC bimanual-YAM windows, each a 33-frame slice centred on a gripper critical frame).
+
+## What it shows
+
+- **Playback** — GT and generated rendered into one video, so the two panels stay frame-locked
+  instead of drifting apart the way two independent players do. Optional `|GT − generated|`
+  difference panel. Playback fps is adjustable (the 33-frame window is only ~1 s at native 30 fps).
+- **Frame stepper** — a single frame from both videos side by side, defaulting to frame 16
+  (the critical frame).
+- **Driving actions** — the `[33, 14]` action chunk fed to the model, split into grippers /
+  left-arm joints / right-arm joints, with the critical frame marked.
+- **All windows** — sortable table of every window with its PSNR; click a row to load it.
+
+Filter by task, gripper edge (grasp / release) and arm; sort by critical-frame PSNR to jump
+straight to the hardest or easiest cases.
+
+## Expected dataset layout
+
+```
+windows_manifest.json                 # list of window dicts: episode_id, task, edge_type, arm,
+                                      #   start_frame, critical_frame, amplitude, n_frames, ...
+metrics_summary.json                  # list of {id, task, edge, arm, full_mse, full_psnr,
+                                      #   crit_mse, crit_psnr}
+windows/<episode_id>/gt.mp4           # 33 frames, 3 cameras vstacked (top / L wrist / R wrist)
+windows/<episode_id>/generated.mp4    # model rollout for the same slice, same geometry
+windows/<episode_id>/actions.json     # [33, 14] = [L arm 6, L grip, R arm 6, R grip]
+windows/<episode_id>/meta.json
+```
+
+Any dataset matching this layout works. Black letterbox bars are trimmed automatically, and the
+per-camera split is derived from the frame height, so other stacked-camera resolutions are fine.
+
+## Configuration
+
+| Variable | Purpose |
+|---|---|
+| `DATASET_REPO` | Dataset repo to read (default `OneWorld-AI/abc-critical-window-rollout`). |
+| `HF_TOKEN` | **Required if the dataset is private.** Add it under *Settings → Variables and secrets → Secrets*. |
+
+Only `windows_manifest.json` and `metrics_summary.json` are fetched at startup; videos and actions
+are downloaded per window on demand and cached, as are the composed comparison videos.
+
+## Running locally
+
+```bash
+pip install -r requirements.txt
+export HF_TOKEN=hf_...          # if the dataset is private
+python app.py
+```

app.py

@@ -0,0 +1,491 @@
+"""
+Side-by-side viewer for Cosmos forward-dynamics rollouts vs. ground truth.
+
+Data lives in a separate HF dataset repo laid out as:
+
+    windows_manifest.json          # 300 window definitions
+    metrics_summary.json           # per-window GT-vs-generated MSE / PSNR
+    windows/<episode_id>/gt.mp4         # 33 frames, 224x672 (3 cams vstacked)
+    windows/<episode_id>/generated.mp4  # same slice, model rollout
+    windows/<episode_id>/actions.json   # [33, 14] driving action chunk
+    windows/<episode_id>/meta.json
+
+Set DATASET_REPO to point at a different dataset. If the dataset is private,
+the Space needs an HF_TOKEN secret with read access to it.
+"""
+
+from __future__ import annotations
+
+import functools
+import json
+import os
+import tempfile
+from pathlib import Path
+
+import cv2
+import gradio as gr
+import imageio_ffmpeg
+import numpy as np
+from huggingface_hub import hf_hub_download
+from matplotlib.figure import Figure
+
+DATASET_REPO = os.environ.get("DATASET_REPO", "OneWorld-AI/abc-critical-window-rollout")
+HF_TOKEN = os.environ.get("HF_TOKEN") or os.environ.get("HUGGING_FACE_HUB_TOKEN") or None
+
+CACHE_DIR = Path(tempfile.gettempdir()) / "wmviz_render"
+CACHE_DIR.mkdir(parents=True, exist_ok=True)
+
+# Each video stacks three 224x224 camera feeds vertically.
+VIEWS = ["All cameras", "Top", "Left wrist", "Right wrist"]
+VIEW_ROW = {"Top": 0, "Left wrist": 1, "Right wrist": 2}
+
+FONT = cv2.FONT_HERSHEY_SIMPLEX
+HDR, FTR, SEP = 26, 26, 4
+SCALE = 2  # native frames are only 224 wide; upscale so overlays stay legible
+
+GT_COLOR = (130, 225, 140)
+GEN_COLOR = (120, 180, 255)
+DIFF_COLOR = (215, 215, 215)
+CRIT_COLOR = (255, 95, 95)
+
+SORTS = [
+    "Hardest first (critical PSNR ↑)",
+    "Easiest first (critical PSNR ↓)",
+    "Task A→Z",
+    "Manifest order",
+]
+
+
+# --------------------------------------------------------------------------- data
+
+
+def fetch(rel_path: str) -> str:
+    """Download one file from the dataset repo (hf_hub_download caches on disk)."""
+    return hf_hub_download(
+        repo_id=DATASET_REPO,
+        filename=rel_path,
+        repo_type="dataset",
+        token=HF_TOKEN,
+    )
+
+
+@functools.lru_cache(maxsize=1)
+def load_index() -> list[dict]:
+    """Manifest rows joined with their metrics, in manifest order."""
+    manifest = json.load(open(fetch("windows_manifest.json")))
+    try:
+        metrics = json.load(open(fetch("metrics_summary.json")))
+    except Exception:
+        metrics = []
+    by_id = {m["id"]: m for m in metrics}
+
+    rows = []
+    for i, w in enumerate(manifest):
+        ep = w["episode_id"]
+        m = by_id.get(ep, {})
+        rows.append(
+            {
+                "order": i,
+                "episode_id": ep,
+                "task": w.get("task", "?"),
+                "edge": w.get("edge_type", "?"),
+                "arm": w.get("arm", "?"),
+                "amplitude": w.get("amplitude"),
+                "start_frame": w.get("start_frame"),
+                "window": w.get("window"),
+                "critical_frame": w.get("critical_frame"),
+                "n_frames": w.get("n_frames"),
+                "full_psnr": m.get("full_psnr"),
+                "crit_psnr": m.get("crit_psnr"),
+                "full_mse": m.get("full_mse"),
+                "crit_mse": m.get("crit_mse"),
+            }
+        )
+    return rows
+
+
+def label_for(row: dict) -> str:
+    psnr = row["crit_psnr"]
+    head = f"{psnr:5.1f} dB" if psnr is not None else "  -- dB"
+    return f"{head} · {row['edge']} {row['arm']} · {row['task']} · {row['episode_id'][8:16]}"
+
+
+def filter_rows(query: str, edge: str, arm: str, sort: str) -> list[dict]:
+    rows = load_index()
+    q = (query or "").strip().lower()
+    if q:
+        rows = [r for r in rows if q in r["task"].lower() or q in r["episode_id"].lower()]
+    if edge != "any":
+        rows = [r for r in rows if r["edge"] == edge]
+    if arm != "any":
+        rows = [r for r in rows if r["arm"] == arm]
+
+    worst = float("inf")
+    if sort == SORTS[0]:
+        rows = sorted(rows, key=lambda r: r["crit_psnr"] if r["crit_psnr"] is not None else worst)
+    elif sort == SORTS[1]:
+        rows = sorted(rows, key=lambda r: -(r["crit_psnr"] if r["crit_psnr"] is not None else -worst))
+    elif sort == SORTS[2]:
+        rows = sorted(rows, key=lambda r: (r["task"], r["episode_id"]))
+    else:
+        rows = sorted(rows, key=lambda r: r["order"])
+    return rows
+
+
+@functools.lru_cache(maxsize=64)
+def row_by_id(episode_id: str) -> dict:
+    for r in load_index():
+        if r["episode_id"] == episode_id:
+            return r
+    raise KeyError(episode_id)
+
+
+# --------------------------------------------------------------------------- video
+
+
+def read_video(path: str) -> np.ndarray:
+    """Decode an mp4 into a uint8 [T, H, W, 3] RGB array."""
+    cap = cv2.VideoCapture(path)
+    frames = []
+    while True:
+        ok, frame = cap.read()
+        if not ok:
+            break
+        frames.append(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
+    cap.release()
+    if not frames:
+        raise RuntimeError(f"no frames decoded from {path}")
+    return np.stack(frames)
+
+
+@functools.lru_cache(maxsize=4)
+def load_pair(episode_id: str) -> tuple[np.ndarray, np.ndarray]:
+    gt = read_video(fetch(f"windows/{episode_id}/gt.mp4"))
+    gen = read_video(fetch(f"windows/{episode_id}/generated.mp4"))
+    t = min(len(gt), len(gen))
+    return gt[:t], gen[:t]
+
+
+def cam_slices(frames: np.ndarray, view: str) -> list[np.ndarray]:
+    """Split the vstacked video into the camera bands requested by `view`."""
+    h = frames.shape[1] // 3
+    rows = [VIEW_ROW[view]] if view in VIEW_ROW else [0, 1, 2]
+    return [frames[:, i * h : (i + 1) * h] for i in rows]
+
+
+def letterbox_rows(*bands: np.ndarray, thresh: int = 16) -> tuple[int, int]:
+    """Rows to keep after dropping the black bars shared by every given band."""
+    h = bands[0].shape[1]
+    lit = np.zeros(h, bool)
+    for b in bands:
+        lit |= b.reshape(b.shape[0], h, -1).max(axis=(0, 2)) > thresh
+    idx = np.flatnonzero(lit)
+    if idx.size < h * 0.1:  # nothing meaningful to trim
+        return 0, h
+    return int(idx[0]), int(idx[-1]) + 1
+
+
+def crop_view(gt: np.ndarray, gen: np.ndarray, view: str) -> tuple[np.ndarray, np.ndarray]:
+    """Select cameras and trim the letterbox, identically for both videos."""
+    gt_out, gen_out = [], []
+    for g, p in zip(cam_slices(gt, view), cam_slices(gen, view)):
+        lo, hi = letterbox_rows(g, p)
+        gt_out.append(g[:, lo:hi])
+        gen_out.append(p[:, lo:hi])
+    return np.concatenate(gt_out, axis=1), np.concatenate(gen_out, axis=1)
+
+
+def upscale(frames: np.ndarray, scale: int) -> np.ndarray:
+    if scale == 1:
+        return frames
+    return np.stack(
+        [cv2.resize(f, None, fx=scale, fy=scale, interpolation=cv2.INTER_NEAREST) for f in frames]
+    )
+
+
+def panel(frames: np.ndarray, title: str, color: tuple[int, int, int]) -> np.ndarray:
+    t, h, w, _ = frames.shape
+    out = np.zeros((t, HDR + h, w, 3), np.uint8)
+    out[:, HDR:] = frames
+    bar = np.full((HDR, w, 3), 22, np.uint8)
+    cv2.putText(bar, title, (8, HDR - 8), FONT, 0.52, color, 1, cv2.LINE_AA)
+    out[:, :HDR] = bar
+    return out
+
+
+def diff_frames(gt: np.ndarray, gen: np.ndarray, gain: float = 3.0) -> np.ndarray:
+    d = np.abs(gt.astype(np.int16) - gen.astype(np.int16)).mean(axis=-1)
+    d = np.clip(d * gain, 0, 255).astype(np.uint8)
+    return np.stack([cv2.applyColorMap(f, cv2.COLORMAP_INFERNO)[:, :, ::-1] for f in d])
+
+
+@functools.lru_cache(maxsize=2)
+def compose(episode_id: str, view: str, show_diff: bool, crit_idx: int) -> np.ndarray:
+    """Build the labelled side-by-side strip: [T, H, W, 3] RGB."""
+    gt, gen = load_pair(episode_id)
+    gt_c, gen_c = crop_view(gt, gen, view)
+    gt_v, gen_v = upscale(gt_c, SCALE), upscale(gen_c, SCALE)
+
+    panels = [panel(gt_v, "GROUND TRUTH", GT_COLOR), panel(gen_v, "GENERATED", GEN_COLOR)]
+    if show_diff:
+        panels.append(panel(diff_frames(gt_v, gen_v), "|DIFF| x3", DIFF_COLOR))
+
+    t, ph, _, _ = panels[0].shape
+    gap = np.zeros((t, ph, SEP, 3), np.uint8)
+    stitched = [panels[0]]
+    for p in panels[1:]:
+        stitched += [gap, p]
+    comp = np.concatenate(stitched, axis=2)
+
+    t, h, w, _ = comp.shape
+    out = np.zeros((t, h + FTR, w, 3), np.uint8)
+    out[:, :h] = comp
+    tl0, tl1, y = int(w * 0.45), w - 14, FTR // 2
+    for i in range(t):
+        bar = np.full((FTR, w, 3), 22, np.uint8)
+        is_crit = i == crit_idx
+        text = f"frame {i:02d}/{t - 1}" + ("   CRITICAL FRAME" if is_crit else "")
+        cv2.putText(bar, text, (8, FTR - 8), FONT, 0.5, CRIT_COLOR if is_crit else (200, 200, 200), 1, cv2.LINE_AA)
+        cv2.line(bar, (tl0, y), (tl1, y), (70, 70, 70), 2, cv2.LINE_AA)
+        if 0 <= crit_idx < t:
+            cx = int(tl0 + (tl1 - tl0) * crit_idx / max(t - 1, 1))
+            cv2.line(bar, (cx, y - 7), (cx, y + 7), CRIT_COLOR, 2, cv2.LINE_AA)
+        px = int(tl0 + (tl1 - tl0) * i / max(t - 1, 1))
+        cv2.circle(bar, (px, y), 4, (255, 255, 255), -1, cv2.LINE_AA)
+        out[i, h:] = bar
+        if is_crit:
+            cv2.rectangle(out[i], (0, 0), (w - 1, h + FTR - 1), CRIT_COLOR, 3)
+
+    # yuv420p needs even dimensions
+    ph, pw = out.shape[1] % 2, out.shape[2] % 2
+    if ph or pw:
+        out = np.pad(out, ((0, 0), (0, ph), (0, pw), (0, 0)))
+    return out
+
+
+def write_mp4(frames: np.ndarray, path: Path, fps: float) -> str:
+    t, h, w, _ = frames.shape
+    writer = imageio_ffmpeg.write_frames(
+        str(path),
+        size=(w, h),
+        fps=fps,
+        codec="libx264",
+        pix_fmt_in="rgb24",
+        pix_fmt_out="yuv420p",
+        macro_block_size=1,
+        output_params=["-crf", "16", "-preset", "veryfast", "-movflags", "+faststart"],
+    )
+    writer.send(None)
+    for f in frames:
+        writer.send(np.ascontiguousarray(f).tobytes())
+    writer.close()
+    return str(path)
+
+
+def render_video(episode_id: str, view: str, show_diff: bool, fps: float, crit_idx: int) -> str:
+    key = f"{episode_id}_{view.replace(' ', '')}_{int(show_diff)}_{fps:g}"
+    path = CACHE_DIR / f"{key}.mp4"
+    if not path.exists():
+        write_mp4(compose(episode_id, view, show_diff, crit_idx), path, fps)
+    return str(path)
+
+
+# --------------------------------------------------------------------------- actions plot
+
+
+def plot_actions(episode_id: str, crit_idx: int, cursor: int | None = None) -> Figure:
+    actions = np.asarray(json.load(open(fetch(f"windows/{episode_id}/actions.json"))), dtype=float)
+    t = np.arange(len(actions))
+
+    fig = Figure(figsize=(7.2, 5.4), dpi=110, layout="constrained")
+    axes = fig.subplots(3, 1, sharex=True)
+    specs = [
+        ("Grippers (1.0 = open, 0.0 = closed)", [(6, "L gripper"), (13, "R gripper")]),
+        ("Left arm joints", [(i, f"L{i}") for i in range(6)]),
+        ("Right arm joints", [(i, f"R{i - 7}") for i in range(7, 13)]),
+    ]
+    for ax, (title, channels) in zip(axes, specs):
+        for idx, name in channels:
+            ax.plot(t, actions[:, idx], lw=1.4, label=name)
+        ax.set_title(title, fontsize=9, loc="left")
+        ax.axvline(crit_idx, color="crimson", ls="--", lw=1.2, zorder=0)
+        if cursor is not None:
+            ax.axvline(cursor, color="0.35", ls=":", lw=1.0, zorder=0)
+        ax.grid(alpha=0.25, lw=0.5)
+        ax.tick_params(labelsize=8)
+        ax.legend(fontsize=7, ncol=6, loc="upper right", framealpha=0.7)
+    axes[-1].set_xlabel("frame in window (dashed red = critical frame)", fontsize=8)
+    return fig
+
+
+# --------------------------------------------------------------------------- ui glue
+
+
+def metrics_md(row: dict) -> str:
+    def fmt(v, unit=""):
+        return f"{v:.2f}{unit}" if isinstance(v, (int, float)) else "—"
+
+    win = row.get("window") or [row["start_frame"], (row["start_frame"] or 0) + 32]
+
+    return (
+        f"### {row['task'].replace('_', ' ')}\n"
+        f"`{row['episode_id']}`\n\n"
+        f"| | full window | critical frame |\n|---|---|---|\n"
+        f"| **PSNR** | {fmt(row['full_psnr'], ' dB')} | {fmt(row['crit_psnr'], ' dB')} |\n"
+        f"| **MSE** | {fmt(row['full_mse'])} | {fmt(row['crit_mse'])} |\n\n"
+        f"**{row['edge']}** · arm **{row['arm']}** · amplitude {fmt(row['amplitude'])} · "
+        f"window frames {win[0]}–{win[1]} of {row['n_frames']} · "
+        f"critical frame {row['critical_frame']}"
+    )
+
+
+def table_rows(rows: list[dict]) -> list[list]:
+    return [
+        [
+            r["episode_id"][8:16],
+            r["task"],
+            r["edge"],
+            r["arm"],
+            round(r["crit_psnr"], 2) if r["crit_psnr"] is not None else None,
+            round(r["full_psnr"], 2) if r["full_psnr"] is not None else None,
+        ]
+        for r in rows
+    ]
+
+
+def on_filter(query, edge, arm, sort, current):
+    rows = filter_rows(query, edge, arm, sort)
+    choices = [(label_for(r), r["episode_id"]) for r in rows]
+    ids = [r["episode_id"] for r in rows]
+    value = current if current in ids else (ids[0] if ids else None)
+    return (
+        gr.update(choices=choices, value=value, label=f"Window ({len(ids)} of 300)"),
+        table_rows(rows),
+        ids,
+    )
+
+
+def critical_index(row: dict) -> int:
+    """Offset of the critical frame inside the window (16 for 33-frame windows)."""
+    start, crit = row.get("start_frame"), row.get("critical_frame")
+    if start is None or crit is None:
+        return 16
+    return int(crit) - int(start)
+
+
+def on_select(episode_id, view, show_diff, fps, frame_idx):
+    if not episode_id:
+        return None, None, "*No window matches the current filters.*", None
+    row = row_by_id(episode_id)
+    crit = critical_index(row)
+    video = render_video(episode_id, view, show_diff, fps, crit)
+    frames = compose(episode_id, view, show_diff, crit)
+    i = int(min(frame_idx, len(frames) - 1))
+    return video, frames[i], metrics_md(row), plot_actions(episode_id, crit, i)
+
+
+def on_frame(episode_id, view, show_diff, frame_idx):
+    if not episode_id:
+        return None, None
+    crit = critical_index(row_by_id(episode_id))
+    frames = compose(episode_id, view, show_diff, crit)
+    i = int(min(frame_idx, len(frames) - 1))
+    return frames[i], plot_actions(episode_id, crit, i)
+
+
+def step(ids, current, delta):
+    if not ids:
+        return None
+    try:
+        i = ids.index(current)
+    except ValueError:
+        i = 0
+    return ids[(i + delta) % len(ids)]
+
+
+# --------------------------------------------------------------------------- app
+
+CSS = """
+.window-video video { max-height: 78vh; object-fit: contain; background: #111; }
+.window-still img { max-height: 78vh; object-fit: contain; background: #111; }
+"""
+
+with gr.Blocks(title="Rollout vs. ground truth", fill_width=True) as demo:
+    gr.Markdown(
+        "# Forward-dynamics rollout vs. ground truth\n"
+        f"Ground-truth and generated 33-frame windows from **`{DATASET_REPO}`**, "
+        "each centred on a gripper critical frame (frame 16). "
+        "Cameras are top / left-wrist / right-wrist."
+    )
+    ids_state = gr.State([])
+
+    with gr.Row():
+        with gr.Column(scale=1, min_width=320):
+            query = gr.Textbox(label="Search task or episode", placeholder="e.g. napkin, pillowcase…")
+            with gr.Row():
+                edge = gr.Radio(["any", "grasp", "release"], value="any", label="Edge")
+                arm = gr.Radio(["any", "L", "R"], value="any", label="Arm")
+            sort = gr.Dropdown(SORTS, value=SORTS[0], label="Sort")
+            picker = gr.Dropdown([], label="Window", filterable=True)
+            with gr.Row():
+                prev_btn = gr.Button("← Prev")
+                next_btn = gr.Button("Next →")
+            gr.Markdown("---")
+            view = gr.Radio(VIEWS, value="Top", label="Camera")
+            show_diff = gr.Checkbox(False, label="Add |GT − generated| difference panel")
+            fps = gr.Slider(2, 30, value=8, step=1, label="Playback fps (source is 30 fps)")
+            info = gr.Markdown()
+
+        with gr.Column(scale=2):
+            with gr.Tabs():
+                with gr.Tab("Playback"):
+                    video = gr.Video(
+                        label="GT vs generated",
+                        autoplay=True,
+                        loop=True,
+                        buttons=["download", "fullscreen"],
+                        elem_classes="window-video",
+                    )
+                with gr.Tab("Frame stepper"):
+                    frame_idx = gr.Slider(0, 32, value=16, step=1, label="Frame in window (16 = critical)")
+                    still = gr.Image(label="Frame comparison", elem_classes="window-still")
+                with gr.Tab("Driving actions"):
+                    actions_plot = gr.Plot(label="Action chunk fed to the model [33 x 14]")
+                with gr.Tab("All windows"):
+                    table = gr.Dataframe(
+                        headers=["episode", "task", "edge", "arm", "crit PSNR", "full PSNR"],
+                        datatype=["str", "str", "str", "str", "number", "number"],
+                        interactive=False,
+                        wrap=True,
+                        max_height=650,
+                    )
+
+    filter_inputs = [query, edge, arm, sort]
+    filter_outputs = [picker, table, ids_state]
+    view_inputs = [picker, view, show_diff, fps, frame_idx]
+    view_outputs = [video, still, info, actions_plot]
+
+    for control in filter_inputs:
+        control.change(on_filter, filter_inputs + [picker], filter_outputs).then(
+            on_select, view_inputs, view_outputs
+        )
+
+    picker.change(on_select, view_inputs, view_outputs)
+    for control in (view, show_diff, fps):
+        control.change(on_select, view_inputs, view_outputs)
+    frame_idx.change(on_frame, [picker, view, show_diff, frame_idx], [still, actions_plot])
+
+    prev_btn.click(lambda i, c: step(i, c, -1), [ids_state, picker], picker)
+    next_btn.click(lambda i, c: step(i, c, +1), [ids_state, picker], picker)
+
+    def on_table_select(ids, evt: gr.SelectData):
+        return ids[evt.index[0]] if ids and evt.index[0] < len(ids) else gr.update()
+
+    table.select(on_table_select, ids_state, picker)
+
+    demo.load(on_filter, filter_inputs + [picker], filter_outputs).then(
+        on_select, view_inputs, view_outputs
+    )
+
+if __name__ == "__main__":
+    demo.queue(max_size=16).launch(css=CSS)

requirements.txt

@@ -0,0 +1,6 @@
+gradio==6.22.0
+huggingface_hub>=0.28
+numpy
+opencv-python-headless
+imageio-ffmpeg
+matplotlib