{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "272e8bde",
   "metadata": {},
   "source": [
    "# Adding New Robotics Datasets to VLA Foundry\n",
    "\n",
    "VLA Foundry preprocesses robotics datasets into WebDataset tar files for efficient training. Raw data can come from any source (simulation logs, real robot recordings, HDF5, Parquet, NPZ, MCAP, etc.), as long as you write a **converter** that knows how to read it and produce a standardized output. This tutorial walks through every step."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "997befe0",
   "metadata": {},
   "source": [
    "## Overview\n",
    "\n",
    "| Step | Objective | File(s) |\n",
    "|----------|-----------|----------|\n",
    "| 0 | Understand the output format | current tutorial |\n",
    "| 1 | Write a Converter class | `vla_foundry/data/preprocessing/robotics/converters/my_format.py` |\n",
    "| 2 | Register the converter | `vla_foundry/data/preprocessing/robotics/converters/__init__.py`, `vla_foundry/data/preprocessing/robotics/preprocess_params.py` |\n",
    "| 3 | Run preprocessing | CLI or Ray cluster |"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0dc92dc",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## Step 0: Understanding the Output Format\n",
    "\n",
    "The preprocessing pipeline converts raw episodes into **WebDataset tar shards** that the training data loaders consume directly. Understanding this output format is essential before writing a converter.\n",
    "\n",
    "### Directory structure\n",
    "\n",
    "After preprocessing, the output directory will contain:\n",
    "\n",
    "```\n",
    "output_directory/\n",
    "├── frames/\n",
    "│   ├── {unique_id}_{episode_id}_frame_{frame_idx}.tar   # One tar per sample (intermediate)\n",
    "│   └── ...\n",
    "├── shards/\n",
    "│   ├── shard_000000.tar          # Shuffled training shards\n",
    "│   ├── shard_000001.tar\n",
    "│   ├── ...\n",
    "│   ├── manifest.jsonl            # Shard names and sample counts\n",
    "│   ├── stats.json                # Dataset-level statistics (mean, std, min, max per lowdim key)\n",
    "│   ├── preprocessing_config.yaml # Copy of config used\n",
    "│   ├── processing_metadata.json  # Timing, sample counts, git info\n",
    "│   └── COMPLETED                 # Marker file (written only by the Ray-based data_generation_ray.py pipeline, not by the standalone preprocess_robotics_to_tar.py script)\n",
    "└── episodes/\n",
    "    ├── {episode_id}.tar          # All samples from one episode, in order\n",
    "    ├── manifest.jsonl\n",
    "    └── stats.json\n",
    "```\n",
    "\n",
    "The `shards/` directory is what the training pipeline reads. The `episodes/` directory provides episode-ordered access for evaluation and visualization."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e93c54c",
   "metadata": {},
   "source": [
    "### Contents of each shard\n",
    "\n",
    "Each tar shard contains multiple samples. Each sample is a set of files sharing a UUID prefix:\n",
    "\n",
    "```\n",
    "shard_000000.tar\n",
    "├── {uuid}.lowdim.npz                      # Low-dimensional data\n",
    "├── {uuid}.{camera_name}_t{offset}.jpg     # RGB images (one per camera per time offset)\n",
    "├── {uuid}.language_instructions.json       # Language task description\n",
    "├── {uuid}.metadata.json                    # Sample metadata\n",
    "├── {uuid}.point_cloud.npz                  # (Optional) Fused point cloud\n",
    "└── ...\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f36262d",
   "metadata": {},
   "source": [
    "### The `lowdim.npz` file\n",
    "\n",
    "This is a NumPy compressed archive containing all low-dimensional arrays for the sample. It **must** contain:\n",
    "\n",
    "- `past_mask`: boolean array of shape `[T]` where `T = past_lowdim_steps + future_lowdim_steps + 1`. Marks which timesteps are valid past observations (not padded).\n",
    "- `future_mask`: boolean array of shape `[T]`. Marks which timesteps are valid future targets (not padded).\n",
    "\n",
    "Beyond these required masks, it will contain all the lowdim arrays your converter produces. Common examples:\n",
    "\n",
    "- Action arrays (e.g., `arm_action`, `base_action`) with shape `[T, D]`\n",
    "- State/proprioception arrays (e.g., `joint_positions`, `eef_pose`) with shape `[T, D]`\n",
    "- Camera calibration arrays (e.g., `original_intrinsics.cam1`, `extrinsics.cam1`)\n",
    "\n",
    "All lowdim arrays share the same time dimension `T` along axis 0."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "213f76e5",
   "metadata": {},
   "source": [
    "### The windowing concept\n",
    "\n",
    "Each sample is built from an **anchor timestep** within an episode. The preprocessing window extends:\n",
    "\n",
    "- `past_lowdim_steps` timesteps **before** the anchor\n",
    "- `future_lowdim_steps` timesteps **after** the anchor (inclusive of the anchor)\n",
    "\n",
    "This produces a lowdim window of size `T = past_lowdim_steps + future_lowdim_steps + 1`.\n",
    "\n",
    "When the window extends beyond episode boundaries, edge values are **padded** (using the configured `padding_strategy`: `copy`, `zero`, or `reflect`), and the masks indicate which positions are real vs. padded.\n",
    "\n",
    "Images are extracted at specific offsets from the anchor timestep (configured via `image_indices`, default `[-1, 0]`), meaning \"one frame before\" and \"at the anchor\". Images are clamped to valid episode indices rather than padded."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14cc7d64",
   "metadata": {},
   "source": [
    "### The `language_instructions.json` file\n",
    "\n",
    "A JSON dictionary with keys drawn from the set `[\"original\", \"randomized\", \"verbose\", \"alternative\"]`, each mapping to a string describing the task.\n",
    "\n",
    "### The `metadata.json` file\n",
    "\n",
    "A JSON dictionary containing sample-level metadata such as:\n",
    "\n",
    "- `camera_names`: list of cameras present in this sample\n",
    "- `anchor_relative_idx`: index of the anchor timestep within the lowdim window (equals `past_lowdim_steps`)\n",
    "- Any additional metadata from your converter (episode ID, timestamps, etc.)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b1243e3",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## Step 1: Write a Converter Class\n",
    "\n",
    "### 1a. The Base Class\n",
    "\n",
    "All converters inherit from `BaseRoboticsConverter` defined in `vla_foundry/data/preprocessing/robotics/converters/base.py`. The base class:\n",
    "\n",
    "- Receives the config (`cfg: PreprocessParams`) in its constructor\n",
    "- Handles the full processing pipeline via `process_episode()` -- you do **not** need to override this method\n",
    "- Calls your extraction methods for each episode, then for each anchor timestep\n",
    "- Manages parallel upload of samples via `ThreadPoolExecutor`\n",
    "- Batches statistics updates to the Ray statistics actor"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f939b7f6",
   "metadata": {},
   "source": [
    "### 1b. Required Methods\n",
    "\n",
    "You **must** implement these methods. The exact signatures (from `base.py`) are shown below.\n",
    "\n",
    "#### 1. `discover_episodes`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Created 3 synthetic episodes in /tmp/vla_tutorial_4q6wheqr:\n",
      "  episode_000.npz  (482.4 KB)\n",
      "  episode_001.npz  (482.4 KB)\n",
      "  episode_002.npz  (482.4 KB)\n"
     ]
    }
   ],
   "source": [
    "# Create synthetic demo episodes so the cells below can run end-to-end.\n",
    "# In practice, your source data already lives on disk.\n",
    "import os\n",
    "import tempfile\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "T, H, W = 20, 64, 64  # 20 timesteps, 64×64 images\n",
    "CAMERA_NAMES = [\"front_camera\", \"wrist_camera\"]\n",
    "rng = np.random.default_rng(42)\n",
    "\n",
    "demo_dir = tempfile.mkdtemp(prefix=\"vla_tutorial_\")\n",
    "for i in range(3):\n",
    "    np.savez(\n",
    "        os.path.join(demo_dir, f\"episode_{i:03d}.npz\"),\n",
    "        front_camera=rng.integers(0, 255, (T, H, W, 3), dtype=np.uint8),\n",
    "        wrist_camera=rng.integers(0, 255, (T, H, W, 3), dtype=np.uint8),\n",
    "        actions=rng.standard_normal((T, 7)).astype(np.float32),\n",
    "        joint_positions=rng.standard_normal((T, 7)).astype(np.float32),\n",
    "        task_description=np.array(f\"Pick up object {i}\"),\n",
    "    )\n",
    "\n",
    "files = sorted(os.listdir(demo_dir))\n",
    "print(f\"Created {len(files)} synthetic episodes in {demo_dir}:\")\n",
    "for f in files:\n",
    "    size = os.path.getsize(os.path.join(demo_dir, f))\n",
    "    print(f\"  {f}  ({size / 1024:.1f} KB)\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "96fca02a",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-03-25T20:56:14.496419Z",
     "iopub.status.busy": "2026-03-25T20:56:14.496039Z",
     "iopub.status.idle": "2026-03-25T20:56:14.504226Z",
     "shell.execute_reply": "2026-03-25T20:56:14.502964Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Discovered 3 episodes:\n",
      "  episode_000.npz\n",
      "  episode_001.npz\n",
      "  episode_002.npz\n"
     ]
    }
   ],
   "source": [
    "# Signature:\n",
    "# def discover_episodes(self, source_paths: list[str], max_episodes_to_process: int = -1) -> list[str]:\n",
    "#\n",
    "# Given a list of source directory paths, return a flat list of episode paths.\n",
    "# Each path is later passed to load_episode_data().\n",
    "# If max_episodes_to_process > 0, truncate the list accordingly.\n",
    "\n",
    "\n",
    "def discover_episodes_example(source_paths, max_episodes_to_process=-1):\n",
    "    all_episodes = []\n",
    "    for source_dir in source_paths:\n",
    "        for fname in sorted(os.listdir(source_dir)):\n",
    "            if fname.endswith(\".npz\"):\n",
    "                all_episodes.append(os.path.join(source_dir, fname))\n",
    "    all_episodes.sort()\n",
    "    if max_episodes_to_process > 0:\n",
    "        all_episodes = all_episodes[:max_episodes_to_process]\n",
    "    return all_episodes\n",
    "\n",
    "\n",
    "episodes = discover_episodes_example([demo_dir])\n",
    "print(f\"Discovered {len(episodes)} episodes:\")\n",
    "for ep in episodes:\n",
    "    print(f\"  {os.path.basename(ep)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e02a42e5",
   "metadata": {},
   "source": [
    "#### 2. `load_episode_data`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "021afff6",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-03-25T20:56:14.553930Z",
     "iopub.status.busy": "2026-03-25T20:56:14.553395Z",
     "iopub.status.idle": "2026-03-25T20:56:14.679806Z",
     "shell.execute_reply": "2026-03-25T20:56:14.679272Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded: episode_000.npz\n",
      "\n",
      "Key                       Shape                  Dtype\n",
      "-------------------------------------------------------\n",
      "front_camera              (20, 64, 64, 3)        uint8\n",
      "wrist_camera              (20, 64, 64, 3)        uint8\n",
      "actions                   (20, 7)                float32\n",
      "joint_positions           (20, 7)                float32\n",
      "task_description          ()                     <U16\n"
     ]
    }
   ],
   "source": [
    "# Signature:\n",
    "# def load_episode_data(self, episode_path: str) -> Any:\n",
    "#\n",
    "# Load a single episode from disk and return it in whatever format is convenient.\n",
    "# The return value is passed unchanged to get_episode_length(), extract_camera_data(),\n",
    "# extract_lowdim_data(), etc.\n",
    "\n",
    "\n",
    "def load_episode_data_example(episode_path):\n",
    "    data = np.load(episode_path, allow_pickle=True)\n",
    "    return data\n",
    "\n",
    "\n",
    "episode_data = load_episode_data_example(episodes[0])\n",
    "\n",
    "print(f\"Loaded: {os.path.basename(episodes[0])}\")\n",
    "print(f\"\\n{'Key':<25} {'Shape':<22} {'Dtype'}\")\n",
    "print(\"-\" * 55)\n",
    "for key in episode_data.files:\n",
    "    arr = episode_data[key]\n",
    "    print(f\"{key:<25} {str(arr.shape):<22} {arr.dtype}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1fbf037c",
   "metadata": {},
   "source": [
    "#### 3. `get_episode_length`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "3c25a7f3",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-03-25T20:56:14.681574Z",
     "iopub.status.busy": "2026-03-25T20:56:14.681383Z",
     "iopub.status.idle": "2026-03-25T20:56:14.684126Z",
     "shell.execute_reply": "2026-03-25T20:56:14.683671Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode length: 20 timesteps\n"
     ]
    }
   ],
   "source": [
    "# Signature:\n",
    "# def get_episode_length(self, episode_data: Any) -> int:\n",
    "#\n",
    "# Return the number of timesteps in the episode.\n",
    "\n",
    "\n",
    "def get_episode_length_example(episode_data):\n",
    "    return len(episode_data[\"actions\"])\n",
    "\n",
    "\n",
    "length = get_episode_length_example(episode_data)\n",
    "print(f\"Episode length: {length} timesteps\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1dc8b5a1",
   "metadata": {},
   "source": [
    "#### 4. `extract_camera_data`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "4d2dfa89",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-03-25T20:56:14.685551Z",
     "iopub.status.busy": "2026-03-25T20:56:14.685416Z",
     "iopub.status.idle": "2026-03-25T20:56:14.688298Z",
     "shell.execute_reply": "2026-03-25T20:56:14.687823Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Camera data:\n",
      "  front_camera: (20, 64, 64, 3)  (uint8)\n",
      "  wrist_camera: (20, 64, 64, 3)  (uint8)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x300 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Signature:\n",
    "# def extract_camera_data(self, episode_data: Any):\n",
    "#\n",
    "# Return a dictionary mapping camera names to image data covering all timesteps.\n",
    "# Values can be:\n",
    "#   - A list/array of numpy images (H, W, 3) -- will be JPEG-encoded during upload\n",
    "#   - A list of raw bytes -- will be written as-is (must already be JPEG-encoded)\n",
    "# Return None to skip camera data.\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "def extract_camera_data_example(episode_data, camera_names):\n",
    "    camera_data = {}\n",
    "    for camera_name in camera_names:\n",
    "        camera_data[camera_name] = episode_data[camera_name]  # shape: (T, H, W, 3)\n",
    "    return camera_data\n",
    "\n",
    "\n",
    "camera_data = extract_camera_data_example(episode_data, CAMERA_NAMES)\n",
    "\n",
    "print(\"Camera data:\")\n",
    "for name, imgs in camera_data.items():\n",
    "    print(f\"  {name}: {imgs.shape}  ({imgs.dtype})\")\n",
    "\n",
    "fig, axes = plt.subplots(1, len(CAMERA_NAMES), figsize=(6, 3))\n",
    "for ax, (name, imgs) in zip(axes, camera_data.items(), strict=False):\n",
    "    ax.imshow(imgs[0])\n",
    "    ax.set_title(f\"{name}\\n(t=0)\")\n",
    "    ax.axis(\"off\")\n",
    "plt.suptitle(\"Sample frames from episode 0\", y=1.02)\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8242959",
   "metadata": {},
   "source": [
    "#### 5. `extract_lowdim_data`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f41a115f",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-03-25T20:56:14.689604Z",
     "iopub.status.busy": "2026-03-25T20:56:14.689458Z",
     "iopub.status.idle": "2026-03-25T20:56:14.692192Z",
     "shell.execute_reply": "2026-03-25T20:56:14.691722Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lowdim data:\n",
      "  Key                    Shape           Dtype           Min       Max\n",
      "  --------------------------------------------------------------------\n",
      "  actions                (20, 7)         float32      -2.829     2.638\n",
      "  joint_positions        (20, 7)         float32      -2.702     2.176\n",
      "\n",
      "First timestep — actions: [ 2.220193   -2.2364237   0.71444    -0.98934215 -0.05403329 -1.3091748\n",
      "  0.8534999 ]\n"
     ]
    }
   ],
   "source": [
    "# Signature:\n",
    "# def extract_lowdim_data(self, episode_data: Any):\n",
    "#\n",
    "# Return a dictionary mapping lowdim key names to numpy arrays of shape (T, D)\n",
    "# covering all timesteps. These arrays will be windowed and padded in extract_sample_data().\n",
    "\n",
    "\n",
    "def extract_lowdim_data_example(episode_data):\n",
    "    return {\n",
    "        \"actions\": episode_data[\"actions\"],  # (T, 7)\n",
    "        \"joint_positions\": episode_data[\"joint_positions\"],  # (T, 7)\n",
    "    }\n",
    "\n",
    "\n",
    "lowdim_data = extract_lowdim_data_example(episode_data)\n",
    "\n",
    "print(\"Lowdim data:\")\n",
    "print(f\"  {'Key':<22} {'Shape':<15} {'Dtype':<10} {'Min':>8}  {'Max':>8}\")\n",
    "print(\"  \" + \"-\" * 68)\n",
    "for key, arr in lowdim_data.items():\n",
    "    print(f\"  {key:<22} {str(arr.shape):<15} {str(arr.dtype):<10} {arr.min():>8.3f}  {arr.max():>8.3f}\")\n",
    "\n",
    "print(f\"\\nFirst timestep — actions: {lowdim_data['actions'][0]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f40ddc4",
   "metadata": {},
   "source": [
    "#### 6. `extract_sample_data`\n",
    "\n",
    "```python\n",
    "def extract_sample_data(\n",
    "    self,\n",
    "    anchor_timestep: int,\n",
    "    episode_path: str,\n",
    "    episode_length: int,\n",
    "    camera_data: dict[str, Any],\n",
    "    lowdim_data: dict[str, Any],\n",
    "    intrinsics_data: dict[str, Any],\n",
    "    extrinsics_data: dict[str, Any],\n",
    "    metadata_data: dict[str, Any],\n",
    "    statistics_ray_actor,\n",
    "    logger_actor,\n",
    "):\n",
    "```\n",
    "\n",
    "This is the core method. For a given anchor timestep, extract the windowed sample from the full-episode data. Returns a tuple of:\n",
    "\n",
    "```\n",
    "(sample_images, sample_lowdim, sample_metadata, language_instructions, [point_cloud], [point_maps], [stats_sample])\n",
    "```\n",
    "\n",
    "- `sample_images`: dict mapping `\"{camera_name}_t{offset}\"` to image data (numpy array or bytes)\n",
    "- `sample_lowdim`: dict mapping lowdim key names to windowed arrays of shape `[T, D]`, **must include** `past_mask` and `future_mask`\n",
    "- `sample_metadata`: dict with at least `camera_names` and `anchor_relative_idx`\n",
    "- `language_instructions`: dict with at least an `\"original\"` key\n",
    "- Optional 5th element: point cloud array or `None`\n",
    "- Optional 6th element: point maps dict or `None`\n",
    "- Optional 7th element: stats sample dict or `None` (for batched statistics updates)\n",
    "\n",
    "Returning `(None, None, None, None)` signals that this sample should be **filtered out** (e.g., too much padding, still sample)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd8a0241",
   "metadata": {},
   "source": [
    "### 1c. Optional Methods\n",
    "\n",
    "These methods have default implementations in the base class but can be overridden:\n",
    "\n",
    "#### `extract_intrinsics_extrinsics_data`\n",
    "\n",
    "```python\n",
    "def extract_intrinsics_extrinsics_data(self, episode_data: Any):\n",
    "    \"\"\"Return (intrinsics_data, extrinsics_data) or (None, None).\"\"\"\n",
    "    return None, None\n",
    "```\n",
    "\n",
    "Override if your dataset includes camera calibration data. Return dicts mapping camera names to arrays of shape `(T, 3, 3)` for intrinsics and `(T, 4, 4)` for extrinsics.\n",
    "\n",
    "#### `extract_metadata_data`\n",
    "\n",
    "```python\n",
    "def extract_metadata_data(self, episode_data: Any):\n",
    "    \"\"\"Return a dict of global metadata or per-timestep metadata arrays.\"\"\"\n",
    "    return None\n",
    "```\n",
    "\n",
    "Override to provide additional metadata (e.g., timestamps, episode index, depth scale).\n",
    "\n",
    "#### `get_episode_id`\n",
    "\n",
    "```python\n",
    "def get_episode_id(self, episode_path: str) -> str:\n",
    "    \"\"\"Get episode ID from episode path. Default: basename of the path.\"\"\"\n",
    "    return os.path.basename(episode_path.rstrip(\"/\"))\n",
    "```\n",
    "\n",
    "Override if you need a custom episode naming scheme (e.g., to avoid collisions when using multiple source directories)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76c90afc",
   "metadata": {},
   "source": [
    "### 1d. Complete Example Converter\n",
    "\n",
    "Below is a minimal but complete converter for a hypothetical format where each episode is a single NPZ file containing:\n",
    "- `images`: array of shape `(T, H, W, 3)` with uint8 RGB images\n",
    "- `actions`: array of shape `(T, D)` with float32 actions\n",
    "- `joint_positions`: array of shape `(T, J)` with float32 joint states\n",
    "- `task_description`: a string describing the task\n",
    "\n",
    "This example is closely modeled on the LeRobot converter (the simplest production converter) but further simplified."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "1eee41d3",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-03-25T20:56:14.693886Z",
     "iopub.status.busy": "2026-03-25T20:56:14.693754Z",
     "iopub.status.idle": "2026-03-25T20:56:16.928281Z",
     "shell.execute_reply": "2026-03-25T20:56:16.927132Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ubuntu/vla_foundry/.venv/lib/python3.12/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n",
      "2026-03-26 01:19:29,266\tINFO util.py:154 -- Missing packages: ['ipywidgets']. Run `pip install -U ipywidgets`, then restart the notebook server for rich notebook output.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SimpleNPZConverter — public methods:\n",
      "  create_relative_lowdim_data(lowdim_data, reference_data)\n",
      "  discover_episodes(source_paths, max_episodes_to_process)\n",
      "  extract_camera_data(episode_data)\n",
      "  extract_intrinsics_extrinsics_data(episode_data)\n",
      "  extract_lowdim_data(episode_data)\n",
      "  extract_metadata_data(episode_data)\n",
      "  extract_sample_data(anchor_timestep, episode_path, episode_length, camera_data, lowdim_data, intrinsics_data, extrinsics_data, metadata_data, statistics_ray_actor, logger_actor)\n",
      "  get_episode_id(episode_path)\n",
      "  get_episode_length(episode_data)\n",
      "  load_episode_data(episode_path)\n",
      "  process_episode(episode_path, statistics_ray_actor, logger_actor)\n"
     ]
    }
   ],
   "source": [
    "import inspect\n",
    "from typing import Any\n",
    "\n",
    "try:\n",
    "    from vla_foundry.data.preprocessing.robotics.converters.base import BaseRoboticsConverter\n",
    "    from vla_foundry.data.preprocessing.robotics.preprocess_masks import create_past_and_future_masks\n",
    "    from vla_foundry.data.preprocessing.utils import is_still_sample\n",
    "\n",
    "    _deps_available = True\n",
    "except ImportError:\n",
    "    # Preprocessing dependencies not installed yet — run cell 27 (`uv sync`) first.\n",
    "    # The class definition below is still valid reference code.\n",
    "    _deps_available = False\n",
    "    BaseRoboticsConverter = object\n",
    "\n",
    "\n",
    "class SimpleNPZConverter(BaseRoboticsConverter):\n",
    "    \"\"\"Converter for the SimpleNPZ format.\"\"\"\n",
    "\n",
    "    def __init__(self, cfg):\n",
    "        super().__init__(cfg)\n",
    "\n",
    "    # ------------------------------------------------------------------\n",
    "    # Episode discovery and loading\n",
    "    # ------------------------------------------------------------------\n",
    "\n",
    "    def discover_episodes(self, source_paths: list[str], max_episodes_to_process: int = -1) -> list[str]:\n",
    "        all_episodes = []\n",
    "        for source_dir in source_paths:\n",
    "            for fname in sorted(os.listdir(source_dir)):\n",
    "                if fname.endswith(\".npz\"):\n",
    "                    all_episodes.append(os.path.join(source_dir, fname))\n",
    "        all_episodes.sort()\n",
    "        if max_episodes_to_process > 0:\n",
    "            all_episodes = all_episodes[:max_episodes_to_process]\n",
    "        return all_episodes\n",
    "\n",
    "    def load_episode_data(self, episode_path: str) -> dict:\n",
    "        data = np.load(episode_path, allow_pickle=True)\n",
    "        return {key: data[key] for key in data.files}\n",
    "\n",
    "    def get_episode_length(self, episode_data: dict) -> int:\n",
    "        return len(episode_data[\"actions\"])\n",
    "\n",
    "    # ------------------------------------------------------------------\n",
    "    # Full-episode extraction (called once per episode)\n",
    "    # ------------------------------------------------------------------\n",
    "\n",
    "    def extract_camera_data(self, episode_data: dict) -> dict[str, np.ndarray]:\n",
    "        camera_data = {}\n",
    "        for camera_name in self.cfg.camera_names:\n",
    "            camera_data[camera_name] = episode_data[camera_name]  # (T, H, W, 3)\n",
    "        return camera_data\n",
    "\n",
    "    def extract_lowdim_data(self, episode_data: dict) -> dict[str, np.ndarray]:\n",
    "        return {\n",
    "            \"actions\": episode_data[\"actions\"],  # (T, D)\n",
    "            \"joint_positions\": episode_data[\"joint_positions\"],  # (T, J)\n",
    "        }\n",
    "\n",
    "    def extract_metadata_data(self, episode_data: dict) -> dict:\n",
    "        return {\n",
    "            \"task_description\": str(episode_data.get(\"task_description\", \"\")),\n",
    "        }\n",
    "\n",
    "    # ------------------------------------------------------------------\n",
    "    # Per-sample extraction (called once per anchor timestep)\n",
    "    # ------------------------------------------------------------------\n",
    "\n",
    "    def extract_sample_data(\n",
    "        self,\n",
    "        anchor_timestep: int,\n",
    "        episode_path: str,\n",
    "        episode_length: int,\n",
    "        camera_data: dict[str, np.ndarray],\n",
    "        lowdim_data: dict[str, np.ndarray],\n",
    "        intrinsics_data: dict[str, Any],\n",
    "        extrinsics_data: dict[str, Any],\n",
    "        metadata_data: dict[str, Any],\n",
    "        statistics_ray_actor,\n",
    "        logger_actor,\n",
    "    ):\n",
    "        # 1. Track total potential samples\n",
    "        logger_actor.increment_total_potential_samples.remote()\n",
    "\n",
    "        # 2. Calculate the lowdim window boundaries\n",
    "        lowdim_start = anchor_timestep - self.cfg.past_lowdim_steps\n",
    "        lowdim_end = anchor_timestep + self.cfg.future_lowdim_steps\n",
    "\n",
    "        # 3. Determine how much padding is needed\n",
    "        past_padding = max(0, -lowdim_start)\n",
    "        future_padding = max(0, lowdim_end - episode_length + 1)\n",
    "\n",
    "        # 4. Filter: skip if padding exceeds allowed limits\n",
    "        if past_padding > self.cfg.max_padding_left or future_padding > self.cfg.max_padding_right:\n",
    "            logger_actor.increment_padding_samples_filtered.remote()\n",
    "            return None, None, None, None\n",
    "\n",
    "        valid_start = max(0, lowdim_start)\n",
    "        valid_end = min(episode_length - 1, lowdim_end)\n",
    "\n",
    "        # 5. Filter: skip still/stationary samples\n",
    "        if self.cfg.filter_still_samples and is_still_sample(\n",
    "            lowdim_data, valid_start, valid_end, self.cfg.still_threshold\n",
    "        ):\n",
    "            logger_actor.increment_still_samples_filtered.remote()\n",
    "            return None, None, None, None\n",
    "\n",
    "        # 6. Extract images at the configured offsets\n",
    "        sample_images = {}\n",
    "        for img_offset in self.image_indices:  # e.g., [-1, 0]\n",
    "            img_timestep = int(np.clip(anchor_timestep + img_offset, 0, episode_length - 1))\n",
    "            for camera_name, camera_images in camera_data.items():\n",
    "                key = f\"{camera_name}_t{img_offset}\"\n",
    "                sample_images[key] = camera_images[img_timestep]\n",
    "\n",
    "        # 7. Window and pad lowdim data\n",
    "        sample_lowdim = {}\n",
    "        for key, data in lowdim_data.items():\n",
    "            valid_data = data[valid_start : valid_end + 1]\n",
    "            if past_padding > 0 or future_padding > 0:\n",
    "                valid_data = self.pad_fn(valid_data, past_padding, future_padding)\n",
    "            sample_lowdim[key] = valid_data\n",
    "\n",
    "        # 8. Create past/future masks\n",
    "        past_mask, future_mask = create_past_and_future_masks(\n",
    "            anchor_timestep, self.cfg.past_lowdim_steps, self.cfg.future_lowdim_steps, episode_length\n",
    "        )\n",
    "\n",
    "        # 9. Build stats_sample BEFORE adding masks to sample_lowdim\n",
    "        #    (masks should not be included in dataset statistics)\n",
    "        stats_sample = (\n",
    "            None\n",
    "            if statistics_ray_actor is None\n",
    "            else {\n",
    "                \"lowdim\": {k: v.copy() for k, v in sample_lowdim.items()},\n",
    "                \"past_mask\": past_mask,\n",
    "                \"future_mask\": future_mask,\n",
    "            }\n",
    "        )\n",
    "\n",
    "        # 10. Add masks to sample_lowdim (after building stats_sample)\n",
    "        sample_lowdim[\"past_mask\"] = past_mask\n",
    "        sample_lowdim[\"future_mask\"] = future_mask\n",
    "\n",
    "        # 11. Build sample metadata\n",
    "        sample_metadata = {\n",
    "            \"camera_names\": list(camera_data.keys()),\n",
    "            \"anchor_relative_idx\": int(self.cfg.past_lowdim_steps),\n",
    "        }\n",
    "        if metadata_data:\n",
    "            for key, value in metadata_data.items():\n",
    "                sample_metadata[key] = value\n",
    "\n",
    "        # 12. Language instructions\n",
    "        language_instructions = {\n",
    "            \"original\": metadata_data.get(\"task_description\", \"Perform the task.\")\n",
    "            if metadata_data\n",
    "            else \"Perform the task.\"\n",
    "        }\n",
    "\n",
    "        return sample_images, sample_lowdim, sample_metadata, language_instructions, None, None, stats_sample\n",
    "\n",
    "\n",
    "# Show the public interface of the converter\n",
    "public_methods = [\n",
    "    (name, m)\n",
    "    for name, m in inspect.getmembers(SimpleNPZConverter, predicate=inspect.isfunction)\n",
    "    if not name.startswith(\"_\")\n",
    "]\n",
    "print(\"SimpleNPZConverter — public methods:\")\n",
    "for name, m in public_methods:\n",
    "    sig = inspect.signature(m)\n",
    "    params = list(sig.parameters.keys())[1:]  # drop 'self'\n",
    "    print(f\"  {name}({', '.join(params)})\")\n",
    "\n",
    "if not _deps_available:\n",
    "    print(\"\\n⚠  vla_foundry preprocessing deps not installed — run the `uv sync` cell in Step 3 first.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25fc3d06",
   "metadata": {},
   "source": [
    "Key patterns to note:\n",
    "\n",
    "1. **Always call `logger_actor.increment_total_potential_samples.remote()`** at the top of `extract_sample_data()`.\n",
    "2. **Always call `logger_actor.increment_padding_samples_filtered.remote()`** or `logger_actor.increment_still_samples_filtered.remote()` when filtering, before returning `(None, None, None, None)`.\n",
    "3. **Build `stats_sample` before adding masks** to `sample_lowdim`. The statistics computation uses the masks to distinguish valid vs. padded data, so they must be separate.\n",
    "4. **Use `self.pad_fn()`** (set by `PaddingStrategy.get_pad_fn()` in the base class) for consistent padding behavior.\n",
    "5. **Use `self.image_indices`** (set from `cfg.image_indices` in the base class, defaults to `[-1, 0]`) for image time offsets.\n",
    "6. **Use `np.clip()`** for image timesteps -- images are clamped to valid bounds rather than padded.\n",
    "7. **The return tuple** has 4 required elements and up to 3 optional ones: `(images, lowdim, metadata, language, point_cloud?, point_maps?, stats_sample?)`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b22e80d0",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## Step 2: Register the Converter\n",
    "\n",
    "### 2a. Add to `converters/__init__.py`\n",
    "\n",
    "Open `vla_foundry/data/preprocessing/robotics/converters/__init__.py` and add an `elif` branch to the `get_converter()` function:\n",
    "\n",
    "```python\n",
    "def get_converter(cfg: PreprocessParams) -> BaseRoboticsConverter:\n",
    "    if cfg.type == \"spartan\":\n",
    "        from vla_foundry.data.preprocessing.robotics.converters.spartan import SpartanConverter\n",
    "\n",
    "        return SpartanConverter(cfg)\n",
    "    elif cfg.type == \"lerobot\":\n",
    "        from vla_foundry.data.preprocessing.robotics.converters.lerobot import LeRobotConverter\n",
    "\n",
    "        return LeRobotConverter(cfg)\n",
    "    # ... existing converters ...\n",
    "    elif cfg.type == \"simple_npz\":\n",
    "        from vla_foundry.data.preprocessing.robotics.converters.simple_npz import SimpleNPZConverter\n",
    "\n",
    "        return SimpleNPZConverter(cfg)\n",
    "    else:\n",
    "        raise ValueError(f\"Unsupported source type: {cfg.type}\")\n",
    "```\n",
    "\n",
    "Note: The import is inside the `elif` block (lazy import) to avoid loading unnecessary dependencies."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d983d96",
   "metadata": {},
   "source": [
    "### 2b. Add a PreprocessParams subclass\n",
    "\n",
    "Open `vla_foundry/data/preprocessing/robotics/preprocess_params.py` and add a params dataclass for your format. Use the `@register_preprocess_params` decorator to register it with draccus:\n",
    "\n",
    "```python\n",
    "@register_preprocess_params(\"simple_npz\")\n",
    "@dataclass(frozen=True)\n",
    "class SimpleNPZPreprocessParams(PreprocessParams):\n",
    "    \"\"\"Preprocessing params for the SimpleNPZ format.\"\"\"\n",
    "\n",
    "    # Add any format-specific fields here. For example:\n",
    "    # observation_keys: list[str] = field(default=None)\n",
    "    # action_keys: list[str] = field(default=None)\n",
    "    pass\n",
    "```\n",
    "\n",
    "The `@register_preprocess_params(\"simple_npz\")` decorator:\n",
    "1. Registers the class with draccus's `ChoiceRegistry` so `--type simple_npz` works.\n",
    "2. Sets the internal `_type` attribute so `cfg.type` returns `\"simple_npz\"`.\n",
    "\n",
    "If your format needs format-specific parameters (like the LeRobot converter needs `observation_keys` and `action_keys`, or the MMT converter needs `mmt_lowdim_flatten_indices_selection`), add them as dataclass fields with defaults."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "001955f0",
   "metadata": {},
   "source": [
    "### 2c. Add to `TYPE_MAPPER`\n",
    "\n",
    "At the bottom of `preprocess_params.py`, add your new class to the `TYPE_MAPPER` dictionary:\n",
    "\n",
    "```python\n",
    "TYPE_MAPPER = {\n",
    "    \"spartan\": SpartanPreprocessParams,\n",
    "    \"lerobot\": LeRobotPreprocessParams,\n",
    "    \"simple_npz\": SimpleNPZPreprocessParams,\n",
    "}\n",
    "```\n",
    "\n",
    "This is used by the standalone entry point (`preprocess_robotics_to_tar.py`) to resolve `--type` to the correct config class."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "955cd829",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## Step 3: Run Preprocessing\n",
    "\n",
    "That's it! Your dataset should now be supported! To verify the implementation, you can try to run the preprocessing. There's a detailed tutorial for this at a separate notebook. Please refer to that notebook for more details.\n",
    "\n",
    "The standalone entry point is `vla_foundry/data/preprocessing/preprocess_robotics_to_tar.py`. It starts a local Ray instance, discovers episodes, processes them, and creates shards."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7d39c063",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-03-25T20:56:16.932806Z",
     "iopub.status.busy": "2026-03-25T20:56:16.932510Z",
     "iopub.status.idle": "2026-03-25T20:56:17.258874Z",
     "shell.execute_reply": "2026-03-25T20:56:17.256948Z"
    }
   },
   "outputs": [],
   "source": [
    "# Install preprocessing dependencies\n",
    "!uv sync --group preprocessing"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd53a33b",
   "metadata": {},
   "source": [
    "```bash\n",
    "# Run preprocessing\n",
    "uv run python vla_foundry/data/preprocessing/preprocess_robotics_to_tar.py \\\n",
    "    --type simple_npz \\\n",
    "    --source_episodes \"['path/to/episode_dir/']\" \\\n",
    "    --output_dir /tmp/my_dataset_output/ \\\n",
    "    --camera_names \"['front_camera', 'wrist_camera']\" \\\n",
    "    --resize_images_size \"[342, 256]\" \\\n",
    "    --samples_per_shard 100 \\\n",
    "    --past_lowdim_steps 1 \\\n",
    "    --future_lowdim_steps 14 \\\n",
    "    --max_padding_left 1 \\\n",
    "    --max_padding_right 7 \\\n",
    "    --compute_statistics true \\\n",
    "    --db_logging false \\\n",
    "    --skip_git_tagging true\n",
    "```\n",
    "\n",
    "> **Warning**: If you have a stale Ray cluster running, the standalone script may connect to it instead of starting a new local instance. Run `ray stop` before running locally to avoid package version mismatches.\n",
    "\n",
    "Notes:\n",
    "- `--source_episodes` accepts a Python list literal as a string.\n",
    "- `--resize_images_size` is required when camera data is numpy arrays (not pre-encoded JPEG bytes). Format: `[width, height]`.\n",
    "- `--db_logging false` disables DynamoDB logging (useful for local testing without AWS/DynamoDB access).\n",
    "- `--skip_git_tagging true` disables automatic git tag creation and push (see note below). Recommended for local testing.\n",
    "- Ray starts automatically in local mode when no cluster is detected.\n",
    "\n",
    "> **Note: Auto-tagging behavior.** By default, the preprocessing script inspects the git working tree for uncommitted changes to preprocessing-related files. If it finds critical changes, it automatically creates an annotated git tag (e.g., `preprocess_robotics_data_20260324_153000`) and pushes it to origin. This is useful for reproducibility in production but can be surprising during local development. Set `--skip_git_tagging true` to disable all git operations, or `--auto_tag false` to disable only the automatic tag creation while still recording git info in metadata."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}