Update app.py

app.py

@@ -1,81 +1,293 @@
 """
-Hugging Face Space viewer for your TrajectoryBuffer HDF5 files.
+Standalone Hugging Face Space viewer for HDF5 trajectory datasets.
 
-Expected Space files:
-  app.py                  # this file
+This version does NOT require your local TrajectoryBuffer class.
+It reads the HDF5 file directly with h5py.
+
+Files needed in the Space:
+  app.py
   requirements.txt
-  tools/buffer_trajectory.py  # copied from your repo, plus any minimal dependencies it needs
-
-This first Space version visualizes:
-  - selected trajectory
-  - selected timestep
-  - image observations, e.g. image1/image2/agentview_image
-  - teacher action, robot action
-  - no_teacher/no_robot flags
-  - action chunk source mask
-  - simple action-chunk plot
-
-It intentionally removes:
-  - matplotlib keyboard controls
-  - manual region labeling
-  - robosuite/MuJoCo environment construction
-  - 3D camera projection overlay
-
-You can add the heavy robosuite projection overlay later, but the Space will be much easier
-to deploy if the first viewer does not need MuJoCo/robosuite/Hydra.
+
+requirements.txt:
+  gradio
+  huggingface_hub
+  h5py
+  numpy
+  pillow
+  matplotlib
+
+Optional:
+  opencv-python-headless
 """
 
 import os
-import sys
+import re
 from functools import lru_cache
 
-import cv2
+import gradio as gr
 import h5py
 import matplotlib
 matplotlib.use("Agg")
 import matplotlib.pyplot as plt
 import numpy as np
-import gradio as gr
 from huggingface_hub import hf_hub_download
+from PIL import Image
+
+try:
+    import cv2
+except Exception:
+    cv2 = None
 
 
 # -----------------------------------------------------------------------------
 # EDIT THESE FOR YOUR DATASET
 # -----------------------------------------------------------------------------
 REPO_ID = "Zhaoting123/Robosuite_Square_image_abs_with_state"
+REPO_TYPE = "dataset"
 HDF5_FILENAME = (
     "20260409_205051_Diffusion_CLIC_intervention_Circular_square_image_abs_"
     "Ta16_offlineFalse_Scale0.01/trajectory_buffer_0.hdf5"
 )
-REPO_TYPE = "dataset"
 
-# The keys you used locally were ["image1", "image2"].
-# For the robosuite upload, you may also have "agentview_image" or
-# "robot0_eye_in_hand_image" inside step["obs"].
-DEFAULT_IMAGE_KEYS = ["image1", "image2", "agentview_image", "robot0_eye_in_hand_image"]
 DEFAULT_CHUNK_LEN = 16
+PREFERRED_IMAGE_KEYS = [
+    "image1",
+    "image2",
+    "agentview_image",
+    "robot0_eye_in_hand_image",
+]
 
 
 # -----------------------------------------------------------------------------
-# Import your project loader
+# HDF5 helpers
 # -----------------------------------------------------------------------------
-HERE = os.path.dirname(os.path.abspath(__file__))
-sys.path.insert(0, HERE)
+@lru_cache(maxsize=1)
+def get_local_hdf5_path():
+    return hf_hub_download(
+        repo_id=REPO_ID,
+        filename=HDF5_FILENAME,
+        repo_type=REPO_TYPE,
+    )
 
-try:
-    from tools.buffer_trajectory import TrajectoryBuffer
-except Exception as exc:
-    TrajectoryBuffer = None
-    TRAJECTORY_BUFFER_IMPORT_ERROR = repr(exc)
-else:
-    TRAJECTORY_BUFFER_IMPORT_ERROR = None
+
+def _natural_sort_key(name):
+    m = re.search(r"([0-9]+)$", str(name))
+    return (0, int(m.group(1))) if m else (1, str(name))
+
+
+@lru_cache(maxsize=1)
+def get_trajectory_keys():
+    """Detect trajectory groups in common HDF5 layouts."""
+    path = get_local_hdf5_path()
+    with h5py.File(path, "r") as f:
+        # Your TrajectoryBuffer saves root-level groups:
+        #   /episode_0000
+        #   /episode_0001
+        #   ...
+        # Some other robotics datasets use /data/demo_0, so keep that fallback.
+        root_episode_keys = [
+            k for k in f.keys()
+            if isinstance(f[k], h5py.Group) and str(k).startswith("episode_")
+        ]
+        if root_episode_keys:
+            group = f
+            prefix = ""
+            group_keys = root_episode_keys
+        elif "data" in f and isinstance(f["data"], h5py.Group):
+            group = f["data"]
+            prefix = "data"
+            group_keys = [k for k in group.keys() if isinstance(group[k], h5py.Group)]
+        else:
+            group = f
+            prefix = ""
+            group_keys = [k for k in group.keys() if isinstance(group[k], h5py.Group)]
+
+    group_keys = sorted(group_keys, key=_natural_sort_key)
+    return tuple(f"{prefix}/{k}" if prefix else k for k in group_keys)
+
+
+@lru_cache(maxsize=1)
+def get_num_trajectories():
+    return max(len(get_trajectory_keys()), 1)
+
+
+def inspect_hdf5_tree(max_lines=160):
+    """Show the HDF5 tree for debugging inside the Space."""
+    path = get_local_hdf5_path()
+    lines = []
+    with h5py.File(path, "r") as f:
+        def visitor(name, obj):
+            if len(lines) >= max_lines:
+                return
+            if isinstance(obj, h5py.Dataset):
+                lines.append(f"DATASET {name} shape={obj.shape} dtype={obj.dtype}")
+            elif isinstance(obj, h5py.Group):
+                lines.append(f"GROUP   {name}")
+        f.visititems(visitor)
+
+    if len(lines) >= max_lines:
+        lines.append("...")
+    return "\n".join(lines) if lines else "No HDF5 contents found."
+
+
+def _read_dataset_value(ds):
+    value = ds[()]
+    if isinstance(value, bytes):
+        return value.decode("utf-8")
+    return value
+
+
+def _read_group_recursive(group):
+    """Read a group into nested dictionaries of numpy arrays."""
+    out = {}
+    for key, obj in group.items():
+        if isinstance(obj, h5py.Dataset):
+            out[key] = _read_dataset_value(obj)
+        elif isinstance(obj, h5py.Group):
+            out[key] = _read_group_recursive(obj)
+    return out
+
+
+def _find_first_existing_key(mapping, candidates):
+    for key in candidates:
+        if key in mapping:
+            return key
+    return None
+
+
+def _maybe_time_slice(value, t, T):
+    arr = np.asarray(value)
+    if arr.ndim >= 1 and arr.shape[0] == T:
+        return arr[t]
+    return arr
+
+
+def _infer_time_length(data):
+    """Infer T from datasets whose first dimension is time."""
+    candidate_lengths = []
+
+    def collect(obj):
+        if isinstance(obj, dict):
+            for v in obj.values():
+                collect(v)
+        else:
+            arr = np.asarray(obj)
+            if arr.ndim >= 1 and arr.shape[0] > 1:
+                candidate_lengths.append(int(arr.shape[0]))
+
+    collect(data)
+    if not candidate_lengths:
+        return 1
+
+    # The trajectory length should usually be the most common large first dim.
+    values, counts = np.unique(candidate_lengths, return_counts=True)
+    return int(values[np.argmax(counts)])
+
+
+@lru_cache(maxsize=32)
+def load_traj(traj_id):
+    """Load one trajectory as a list of step dictionaries.
+
+    Output step format:
+      {
+        "timestep": int,
+        "obs": dict,
+        "teacher_action": np.ndarray,
+        "robot_action": np.ndarray,
+        "no_teacher_action": bool,
+        "no_robot_action": bool,
+      }
+    """
+    path = get_local_hdf5_path()
+    traj_keys = get_trajectory_keys()
+    if not traj_keys:
+        return []
+
+    traj_id = int(np.clip(int(traj_id), 0, len(traj_keys) - 1))
+    traj_key = traj_keys[traj_id]
+
+    with h5py.File(path, "r") as f:
+        g = f[traj_key]
+        data = _read_group_recursive(g)
+        attrs = dict(g.attrs)
+
+    # Case A: trajectory group contains step groups: step_0, step_1, ...
+    step_group_keys = [
+        k for k, v in data.items()
+        if isinstance(v, dict) and (str(k).startswith("step") or str(k).isdigit())
+    ]
+    if step_group_keys:
+        traj = []
+        for step_key in sorted(step_group_keys, key=_natural_sort_key):
+            step = data[step_key]
+            obs = step.get("obs", {}) if isinstance(step.get("obs", {}), dict) else {}
+            teacher_action = step.get("teacher_action", step.get("teacher_actions", step.get("action", step.get("actions", np.zeros(1, dtype=np.float32)))))
+            robot_action = step.get("robot_action", step.get("robot_actions", step.get("action", step.get("actions", teacher_action))))
+            traj.append({
+                "timestep": int(step.get("timestep", len(traj))),
+                "obs": obs,
+                "teacher_action": np.asarray(teacher_action),
+                "robot_action": np.asarray(robot_action),
+                "no_teacher_action": bool(np.asarray(step.get("no_teacher_action", step.get("no_teacher_actions", False))).reshape(-1)[0]),
+                "no_robot_action": bool(np.asarray(step.get("no_robot_action", step.get("no_robot_actions", False))).reshape(-1)[0]),
+            })
+        return traj
+
+    # Case B: trajectory group contains array datasets with first dimension T.
+    # Your TrajectoryBuffer layout is:
+    #   /episode_0000/observation/<image_or_state_key>[T,...]
+    #   /episode_0000/robot_actions[T,D]
+    #   /episode_0000/teacher_actions[T,D]
+    #   /episode_0000/no_teacher_actions[T]
+    #   /episode_0000/no_robot_actions[T]
+    #
+    # Keep obs/action aliases for compatibility with other layouts.
+    T = _infer_time_length(data)
+    obs_all = {}
+    if isinstance(data.get("observation", {}), dict):
+        obs_all = data.get("observation", {})
+    elif isinstance(data.get("obs", {}), dict):
+        obs_all = data.get("obs", {})
+
+    action_key = _find_first_existing_key(data, ["actions", "action"])
+    teacher_key = _find_first_existing_key(data, ["teacher_actions", "teacher_action"])
+    robot_key = _find_first_existing_key(data, ["robot_actions", "robot_action"])
+    no_teacher_key = _find_first_existing_key(data, ["no_teacher_actions", "no_teacher_action"])
+    no_robot_key = _find_first_existing_key(data, ["no_robot_actions", "no_robot_action"])
+
+    traj = []
+    for t in range(T):
+        obs_t = {}
+        for key, value in obs_all.items():
+            obs_t[key] = _maybe_time_slice(value, t, T)
+
+        default_action = np.zeros(1, dtype=np.float32)
+        if action_key is not None:
+            default_action = _maybe_time_slice(data[action_key], t, T)
+
+        teacher_action = _maybe_time_slice(data[teacher_key], t, T) if teacher_key is not None else default_action
+        robot_action = _maybe_time_slice(data[robot_key], t, T) if robot_key is not None else default_action
+        no_teacher = _maybe_time_slice(data[no_teacher_key], t, T) if no_teacher_key is not None else False
+        no_robot = _maybe_time_slice(data[no_robot_key], t, T) if no_robot_key is not None else False
+
+        traj.append({
+            "timestep": t,
+            "obs": obs_t,
+            "teacher_action": np.asarray(teacher_action),
+            "robot_action": np.asarray(robot_action),
+            "no_teacher_action": bool(np.asarray(no_teacher).reshape(-1)[0]),
+            "no_robot_action": bool(np.asarray(no_robot).reshape(-1)[0]),
+        })
+
+    return traj
 
 
 # -----------------------------------------------------------------------------
-# Small utility functions extracted from your local script
+# Visualization helpers
 # -----------------------------------------------------------------------------
 def _extract_latest_obs_value(value):
     arr = np.asarray(value)
+    # Your local script handled stacked recent observations by taking the latest.
     if arr.ndim >= 1 and arr.shape[0] in (1, 2):
         return arr[-1]
     return arr
@@ -85,11 +297,19 @@ def _extract_display_image(value, reverse_channels=False, output_uint8=True):
     img = _extract_latest_obs_value(value)
     img = np.asarray(img)
 
+    # Your saved image shape can be [obs_T, C, H, W] per timestep.
+    # Take the latest stacked observation, then convert CHW -> HWC.
+    if img.ndim == 4 and img.shape[0] in (1, 2, 3, 4):
+        img = img[-1]
+
     if img.ndim == 2:
         img = np.repeat(img[..., None], 3, axis=-1)
-    elif img.ndim == 3 and img.shape[0] in (1, 3):
+    elif img.ndim == 3 and img.shape[0] in (1, 3, 4):
         img = np.transpose(img, (1, 2, 0))
 
+    if img.ndim == 3 and img.shape[-1] == 4:
+        img = img[..., :3]
+
     if img.ndim != 3:
         raise ValueError(f"Unsupported image shape: {img.shape}")
 
@@ -111,19 +331,20 @@ def _extract_display_image(value, reverse_channels=False, output_uint8=True):
     return img_rgb
 
 
-def _resize_image_for_display(img, display_scale=4, interpolation=None):
+def _resize_image_for_display(img, display_scale=4):
     if display_scale is None or float(display_scale) == 1.0:
         return img
-    display_scale = float(display_scale)
-    if display_scale <= 0:
-        raise ValueError(f"display_scale must be positive, got {display_scale}")
 
+    display_scale = float(display_scale)
     h, w = img.shape[:2]
     new_w = max(1, int(round(w * display_scale)))
     new_h = max(1, int(round(h * display_scale)))
-    if interpolation is None:
-        interpolation = cv2.INTER_NEAREST if display_scale >= 1 else cv2.INTER_AREA
-    return cv2.resize(img, (new_w, new_h), interpolation=interpolation)
+
+    if cv2 is not None:
+        return cv2.resize(img, (new_w, new_h), interpolation=cv2.INTER_NEAREST)
+
+    pil_img = Image.fromarray(img)
+    return np.asarray(pil_img.resize((new_w, new_h), resample=Image.Resampling.NEAREST))
 
 
 def _extract_mixed_action_chunk(traj, start_idx, chunk_length=16):
@@ -134,7 +355,7 @@ def _extract_mixed_action_chunk(traj, start_idx, chunk_length=16):
         step = traj[idx]
         use_teacher = not bool(step.get("no_teacher_action", False))
         action = step["teacher_action"] if use_teacher else step["robot_action"]
-        chunk.append(np.asarray(action, dtype=np.float32))
+        chunk.append(np.asarray(action, dtype=np.float32).reshape(-1))
         sources.append("T" if use_teacher else "R")
     if not chunk:
         return None, ""
@@ -146,17 +367,16 @@ def _extract_robot_action_chunk(traj, start_idx, chunk_length=16):
     end_idx = min(len(traj), int(start_idx) + int(chunk_length))
     for idx in range(int(start_idx), end_idx):
         step = traj[idx]
-        chunk.append(np.asarray(step["robot_action"], dtype=np.float32))
+        chunk.append(np.asarray(step["robot_action"], dtype=np.float32).reshape(-1))
     if not chunk:
         return None
     return np.stack(chunk, axis=0)
 
 
-def _safe_array_str(x, precision=3, max_items=20):
-    arr = np.asarray(x)
-    flat = arr.reshape(-1)
-    suffix = "" if flat.size <= max_items else f" ... +{flat.size - max_items} more"
-    shown = flat[:max_items]
+def _safe_array_str(x, precision=3, max_items=24):
+    arr = np.asarray(x).reshape(-1)
+    shown = arr[:max_items]
+    suffix = "" if arr.size <= max_items else f" ... +{arr.size - max_items} more"
     return np.array2string(shown, precision=precision, separator=", ") + suffix
 
 
@@ -170,9 +390,8 @@ def _make_action_chunk_plot(mixed_chunk, robot_chunk=None):
 
     fig, ax = plt.subplots(figsize=(7, 3.2), dpi=140)
     t = np.arange(mixed_chunk.shape[0])
-
-    # Plot up to 10 dims to avoid clutter.
     max_dims = min(mixed_chunk.shape[1], 10)
+
     for d in range(max_dims):
         ax.plot(t, mixed_chunk[:, d], label=f"mixed[{d}]")
 
@@ -180,8 +399,7 @@ def _make_action_chunk_plot(mixed_chunk, robot_chunk=None):
         robot_chunk = np.asarray(robot_chunk, dtype=np.float32)
         if robot_chunk.ndim == 1:
             robot_chunk = robot_chunk[:, None]
-        max_robot_dims = min(robot_chunk.shape[1], max_dims)
-        for d in range(max_robot_dims):
+        for d in range(min(robot_chunk.shape[1], max_dims)):
             ax.plot(t, robot_chunk[:, d], linestyle="--", alpha=0.55, label=f"robot[{d}]")
 
     ax.set_title("Action chunk")
@@ -190,7 +408,6 @@ def _make_action_chunk_plot(mixed_chunk, robot_chunk=None):
     ax.grid(True, alpha=0.3)
     ax.legend(loc="upper right", fontsize=7, ncol=2)
     fig.tight_layout()
-
     fig.canvas.draw()
     rgba = np.asarray(fig.canvas.buffer_rgba())
     img = rgba[..., :3].copy()
@@ -198,104 +415,62 @@ def _make_action_chunk_plot(mixed_chunk, robot_chunk=None):
     return img
 
 
-# -----------------------------------------------------------------------------
-# HDF5 download/load/cache
-# -----------------------------------------------------------------------------
-@lru_cache(maxsize=1)
-def get_local_hdf5_path():
-    return hf_hub_download(
-        repo_id=REPO_ID,
-        filename=HDF5_FILENAME,
-        repo_type=REPO_TYPE,
-    )
-
-
-@lru_cache(maxsize=1)
-def get_buffer():
-    if TrajectoryBuffer is None:
-        raise RuntimeError(
-            "Could not import tools.buffer_trajectory.TrajectoryBuffer. "
-            "Copy tools/buffer_trajectory.py into the Space. "
-            f"Original import error: {TRAJECTORY_BUFFER_IMPORT_ERROR}"
-        )
-    return TrajectoryBuffer()
-
-
-@lru_cache(maxsize=1)
-def get_num_trajectories():
-    path = get_local_hdf5_path()
-    return int(get_buffer().count_trajectories_in_hdf5(path))
-
-
-@lru_cache(maxsize=32)
-def load_traj(traj_id):
-    path = get_local_hdf5_path()
-    traj = get_buffer().load_from_file(path, traj_id=int(traj_id))
-    return traj
-
-
-def inspect_hdf5_tree(max_lines=120):
-    """Useful debug panel for Space deployment."""
-    path = get_local_hdf5_path()
-    lines = []
-    with h5py.File(path, "r") as f:
-        def visitor(name, obj):
-            if len(lines) >= max_lines:
-                return
-            if isinstance(obj, h5py.Dataset):
-                lines.append(f"DATASET {name} shape={obj.shape} dtype={obj.dtype}")
-            elif isinstance(obj, h5py.Group):
-                lines.append(f"GROUP   {name}")
-        f.visititems(visitor)
-    if len(lines) >= max_lines:
-        lines.append("...")
-    return "\n".join(lines) if lines else "Empty or unsupported HDF5 tree."
-
-
-# -----------------------------------------------------------------------------
-# Gradio rendering functions
-# -----------------------------------------------------------------------------
 def get_available_image_keys(traj_id):
-    traj = load_traj(int(traj_id))
+    n_traj = get_num_trajectories()
+    traj_id = int(np.clip(int(traj_id), 0, max(n_traj - 1, 0)))
+    traj = load_traj(traj_id)
     if not traj:
         return []
+
     obs = traj[0].get("obs", {})
-    keys = []
-    for k, v in obs.items():
+    image_keys = []
+    for key, value in obs.items():
         try:
-            arr = np.asarray(_extract_latest_obs_value(v))
-            if arr.ndim in (2, 3):
-                keys.append(k)
+            arr = np.asarray(_extract_latest_obs_value(value))
+            key_l = str(key).lower()
+            key_hint = any(s in key_l for s in ["rgb", "image", "img", "camera", "cam"])
+            looks_like_shape = (
+                arr.ndim == 2
+                or (arr.ndim == 3 and (arr.shape[-1] in (1, 3, 4) or arr.shape[0] in (1, 3, 4)))
+                or (arr.ndim == 4 and arr.shape[0] in (1, 2, 3, 4) and arr.shape[1] in (1, 3, 4))
+            )
+            if key_hint or looks_like_shape:
+                image_keys.append(key)
         except Exception:
             pass
-    # Prefer your known keys first, then any detected keys.
-    ordered = [k for k in DEFAULT_IMAGE_KEYS if k in keys]
-    ordered += [k for k in keys if k not in ordered]
+
+    ordered = [k for k in PREFERRED_IMAGE_KEYS if k in image_keys]
+    ordered += [k for k in image_keys if k not in ordered]
     return ordered
 
 
+# -----------------------------------------------------------------------------
+# Gradio callbacks
+# -----------------------------------------------------------------------------
 def update_after_traj_change(traj_id):
-    traj = load_traj(int(traj_id))
-    image_keys = get_available_image_keys(int(traj_id))
+    n_traj = get_num_trajectories()
+    traj_id = int(np.clip(int(traj_id), 0, max(n_traj - 1, 0)))
+    traj = load_traj(traj_id)
+    image_keys = get_available_image_keys(traj_id)
     max_step = max(len(traj) - 1, 0)
-    default_keys = image_keys[:2] if image_keys else []
+    slider_max = max(max_step, 1)  # Gradio requires min < max.
     return (
-        gr.update(maximum=max_step, value=0),
-        gr.update(choices=image_keys, value=default_keys),
+        gr.update(maximum=slider_max, value=0),
+        gr.update(choices=image_keys, value=image_keys[:2]),
     )
 
 
 def render_frame(traj_id, timestep, image_keys, chunk_len, display_scale, reverse_channels):
-    traj_id = int(traj_id)
-    timestep = int(timestep)
-    chunk_len = int(chunk_len)
-    display_scale = float(display_scale)
-
+    n_traj = get_num_trajectories()
+    traj_id = int(np.clip(int(traj_id), 0, max(n_traj - 1, 0)))
     traj = load_traj(traj_id)
+
     if not traj:
-        return [], None, "No trajectory loaded."
+        return [], None, "No trajectory could be loaded. Open the HDF5 debug panel to inspect the file layout."
 
-    timestep = int(np.clip(timestep, 0, len(traj) - 1))
+    timestep = int(np.clip(int(timestep), 0, len(traj) - 1))
+    chunk_len = int(chunk_len)
+    display_scale = float(display_scale)
     step = traj[timestep]
     obs = step.get("obs", {})
 
@@ -311,30 +486,23 @@ def render_frame(traj_id, timestep, image_keys, chunk_len, display_scale, revers
             errors.append(f"Missing image key: {key}")
             continue
         try:
-            img = _extract_display_image(
-                obs[key],
-                reverse_channels=bool(reverse_channels),
-                output_uint8=True,
-            )
+            img = _extract_display_image(obs[key], reverse_channels=bool(reverse_channels), output_uint8=True)
             img = _resize_image_for_display(img, display_scale=display_scale)
             gallery.append((img, key))
         except Exception as exc:
             errors.append(f"{key}: {exc}")
 
-    mixed_chunk, chunk_sources = _extract_mixed_action_chunk(
-        traj, timestep, chunk_length=chunk_len
-    )
-    robot_chunk = _extract_robot_action_chunk(
-        traj, timestep, chunk_length=chunk_len
-    )
+    mixed_chunk, chunk_sources = _extract_mixed_action_chunk(traj, timestep, chunk_length=chunk_len)
+    robot_chunk = _extract_robot_action_chunk(traj, timestep, chunk_length=chunk_len)
     action_plot = _make_action_chunk_plot(mixed_chunk, robot_chunk)
 
+    teacher_action = step.get("teacher_action", np.zeros(1, dtype=np.float32))
+    robot_action = step.get("robot_action", np.zeros(1, dtype=np.float32))
     no_teacher = bool(step.get("no_teacher_action", False))
     no_robot = bool(step.get("no_robot_action", False))
-    teacher_action = step.get("teacher_action", None)
-    robot_action = step.get("robot_action", None)
 
     info_lines = [
+        f"detected trajectories: {n_traj}",
         f"trajectory: {traj_id}",
         f"timestep: {timestep} / {len(traj) - 1}",
         f"no_teacher_action: {int(no_teacher)}",
@@ -342,8 +510,8 @@ def render_frame(traj_id, timestep, image_keys, chunk_len, display_scale, revers
         f"chunk_len: {chunk_len}",
         f"chunk source mask: {chunk_sources}  (T=teacher, R=robot fallback)",
         "",
-        f"teacher_action: {_safe_array_str(teacher_action) if teacher_action is not None else 'None'}",
-        f"robot_action:   {_safe_array_str(robot_action) if robot_action is not None else 'None'}",
+        f"teacher_action: {_safe_array_str(teacher_action)}",
+        f"robot_action:   {_safe_array_str(robot_action)}",
     ]
 
     if errors:
@@ -352,34 +520,36 @@ def render_frame(traj_id, timestep, image_keys, chunk_len, display_scale, revers
     return gallery, action_plot, "\n".join(info_lines)
 
 
+# -----------------------------------------------------------------------------
+# App
+# -----------------------------------------------------------------------------
 def build_app():
     try:
         n_traj = get_num_trajectories()
-        first_keys = get_available_image_keys(0) if n_traj > 0 else []
+        first_keys = get_available_image_keys(0)
         startup_error = None
     except Exception as exc:
         n_traj = 1
         first_keys = []
         startup_error = repr(exc)
 
-    with gr.Blocks(title="Robosuite HDF5 Trajectory Viewer") as demo:
+    with gr.Blocks(title="HDF5 Trajectory Viewer") as demo:
         gr.Markdown(
-            "# Robosuite HDF5 Trajectory Viewer\n"
-            "Browse trajectories directly from the Hugging Face dataset repository."
+            "# HDF5 Trajectory Viewer\n"
+            "Standalone viewer: no local `TrajectoryBuffer` dependency.\n\n"
+            f"Detected trajectories: **{n_traj}**"
         )
 
         if startup_error is not None:
             gr.Markdown(
                 "⚠️ **Startup warning**\n\n"
-                f"```text\n{startup_error}\n```\n"
-                "Most likely fix: copy `tools/buffer_trajectory.py` and its minimal dependencies "
-                "into this Space."
+                f"```text\n{startup_error}\n```"
             )
 
         with gr.Row():
             traj_slider = gr.Slider(
                 minimum=0,
-                maximum=max(n_traj - 1, 0),
+                maximum=max(n_traj - 1, 1),
                 value=0,
                 step=1,
                 label="Trajectory index",
@@ -414,7 +584,7 @@ def build_app():
             )
             reverse_channels = gr.Checkbox(
                 value=True,
-                label="Reverse image channels BGR↔RGB",
+                label="Reverse channels BGR↔RGB",
             )
 
         render_btn = gr.Button("Render frame", variant="primary")
@@ -426,11 +596,11 @@ def build_app():
             object_fit="contain",
         )
         action_plot = gr.Image(label="Action chunk plot", type="numpy")
-        info = gr.Textbox(label="Frame info", lines=12)
+        info = gr.Textbox(label="Frame info", lines=13)
 
         with gr.Accordion("Debug: HDF5 tree", open=False):
             inspect_btn = gr.Button("Inspect HDF5 structure")
-            hdf5_tree = gr.Textbox(lines=20, label="HDF5 tree")
+            hdf5_tree = gr.Textbox(lines=22, label="HDF5 tree")
             inspect_btn.click(fn=inspect_hdf5_tree, outputs=hdf5_tree)
 
         traj_slider.change(