Add six source-processing recipes and document local reconstruction

README.md

@@ -42,9 +42,10 @@ configs:
 # MMTA-v1.0
 
 MMTA evaluates multimodal temporal analysis using images, videos, text and
-time-series observations. This repository contains a public test subset with
+time-series observations. This repository contains a distributable test subset with
 **1,322 original test records** and **1,400 alternative Terra channel views**.
-All five configurations use the `test` split.
+All five configurations use the `test` split. It also includes **processing
+recipes for six additional task domains** whose source data are not redistributed.
 
 | Configuration | Records | Task |
 |---|---:|---|
@@ -56,8 +57,10 @@ All five configurations use the `test` split.
 
 The Terra channel views reuse the same 200 original instances and images.
 They are alternative evaluation views and should not be counted as additional
-independent original examples. This release contains four source domains;
-the complete benchmark's other domains are not distributed here.
+independent original examples. The released records cover four source domains.
+The additional recipe directories contain code and instructions for local
+reconstruction; their source data and generated task records are not included
+and do not increase the record counts above.
 
 The 6,393 referenced assets occupy approximately **11.65 GiB**: 1,149 images,
 1,122 video clips, 2,722 history CSVs and 1,400 forecast target CSVs.
@@ -92,10 +95,63 @@ with (root / record["timeseries_path"]).open(encoding="utf-8", newline="") as ha
     history = list(csv.DictReader(handle))
 ```
 
-Resolve every record path relative to the **repository root**. The directory
-`sample/` contains the released test data. `answer` and `forecast_target_path`
+Resolve every released record path relative to the **repository root**. The directory
+`sample/` contains both released test data and the recipe-only directories
+listed below. `answer` and `forecast_target_path`
 are evaluation references; exclude them from model inputs.
 
+## Processing recipes for sources that are not redistributed
+
+The following directories provide download entry points, source-processing
+scripts and local generation instructions. Because of upstream sharing terms
+and access requirements, this repository distributes **processing code only**
+for these domains. It includes no source datasets, images, videos, patient
+records or generated benchmark records for them.
+
+| Recipe directory | Local task | Source access and instructions |
+|---|---|---|
+| `sample/image-timeseries/mimic_death/` | In-hospital mortality classification | [MIMIC mortality instructions](sample/image-timeseries/mimic_death/README.md); obtain the required MIMIC tables, notes and chest images through your own approved PhysioNet account. |
+| `sample/image-timeseries/mimic_disch/` | Discharge-within-48-hours classification | [MIMIC discharge instructions](sample/image-timeseries/mimic_disch/README.md); the same credentialed source access is required. |
+| `sample/image-timeseries/pixelrec/` | Cover-image-conditioned interaction forecasting | [PixelRec instructions](sample/image-timeseries/pixelrec/README.md); obtain interactions, item metadata and covers from the upstream project. |
+| `sample/image-timeseries/sp500/` | Financial forecasting with charts and dated news | [SP500 / FinMultiTime instructions](sample/image-timeseries/sp500/README.md); obtain the upstream prices, news and charts. |
+| `sample/video-timeseries/covla/` | Driving/braking classification | [CoVLA instructions](sample/video-timeseries/covla/README.md); complete upstream Hugging Face access requirements and obtain states, front-car signals and videos. |
+| `sample/video-timeseries/cuhk_x_har/` | Human activity classification | [CUHK-X HAR instructions](sample/video-timeseries/cuhk_x_har/README.md); complete the source data-use agreement and obtain the matching IMU and skeleton archives. |
+
+Use your own upstream account and follow each source's current terms. These
+scripts do not grant access to restricted datasets or permission to share them
+or their derivatives. Download and unpack sources locally, then run the
+corresponding `generate.py` to build task prompts and image/video/CSV records.
+Shared download and conversion dependencies are included in `processing/`;
+see the [setup instructions](processing/README.md).
+
+For the commands in the per-domain READMEs, run from the directory containing
+your downloaded `MMTA-v1.0` folder:
+
+```bash
+python -m pip install -r MMTA-v1.0/processing/requirements.txt
+
+# Inspect an upstream download plan without downloading data.
+python -B MMTA-v1.0/sample/image-timeseries/pixelrec/download.py \
+  --output local_sources/pixelrec --dry-run
+
+# Inspect the inputs accepted by the local task builder.
+python -B MMTA-v1.0/sample/image-timeseries/pixelrec/generate.py --help
+```
+
+Install `ffmpeg` and `ffprobe` for video processing, and `wget` for credentialed
+PhysioNet downloads. Actual downloads require `--accept-terms` after completing
+the upstream requirements; a dry run requires no source access. Keep
+`local_sources/` and generated `local_work/` directories outside `MMTA-v1.0/`.
+Locally generated record paths are relative to the generated domain directory,
+as described in each recipe README; released record paths remain relative to
+this repository root.
+
+These six recipes are not Hugging Face dataset configurations. `load_dataset`
+loads the five released configurations shown above; `snapshot_download`
+also retrieves the processing scripts. Locally reconstructed records are not
+guaranteed to reproduce the exact original benchmark selection, since available
+upstream versions and files may differ.
+
 ## Files and format
 
 ```text
@@ -106,10 +162,25 @@ sample/
     images/
     timeseries/
     forecast_targets/
+  image-timeseries/{mimic_death,mimic_disch,pixelrec,sp500}/
+    README.md
+    download.py
+    generate.py
+    <source processing scripts>.py
   video-timeseries/{agibot,future_factories,holo_assist}/
     <domain>.omnits.jsonl
     video_clips/
     timeseries/
+  video-timeseries/{covla,cuhk_x_har}/
+    README.md
+    download.py
+    generate.py
+    <source processing scripts>.py
+processing/
+  README.md
+  requirements.txt
+  download.py
+  common/
 ```
 
 JSONL is UTF-8 with one JSON object per line. IDs are unique across manifests. The release supports image/time-series prediction and video/sensor classification.
@@ -198,6 +269,12 @@ Factories supplies paired-camera cycle videos and PLC histories. HoloAssist
 supplies coarse-action segments with synchronized sensors and correctness labels.
 
 The full benchmark also uses MIMIC, PixelRec, CoVLA, CUHK-X and SP500/FinMultiTime.
-Their data are absent from this public subset because of source sharing terms.
+Their data are absent from this subset because of source sharing terms and
+access requirements. The recipe directories above provide processing code for
+users who obtain those sources themselves. Source agreements remain applicable
+to locally downloaded data and generated records. Script origins and existing
+code notices are documented in [processing/CODE_PROVENANCE.md](processing/CODE_PROVENANCE.md)
+and [processing/provenance.json](processing/provenance.json); no new license is
+assigned to third-party code.
 
 Questions about this release can be posted in this repository's Discussions.

processing/CODE_PROVENANCE.md

@@ -0,0 +1,28 @@
+# Code provenance
+
+The restored builders and shared converters come from the maintainer's archived
+MMTA processing scripts. [provenance.json](provenance.json) retains the source
+labels, original source hashes and packaged script hashes for the included code.
+Paths in that file are relative to the repository root. Archived scripts were
+copied without changing their contents.
+
+MIMIC patient joins, mortality/discharge labels, prompt construction and splitting
+are adapted from the original task scripts. The adaptations provide portable
+CLI paths, compressed-table inputs, matching image fields and prevention of
+repeated mortality stays. Mortality uses the first 48 hours after ICU admission;
+discharge uses a radiology-report anchor and a 48-hour vital-sign lookback.
+
+CUHK-X alignment, Excel-to-CSV conversion and skeleton-video rendering preserve
+trial matching, stream selection, per-second sampling and 20 fps rendering.
+Generated tables and videos use a new output tree. Original source column names
+are supported through Unicode aliases.
+
+SP500 news selection requires valid dates strictly before the first forecast
+day, sorts eligible articles and retains selection metadata. The common video
+converter excludes timestamp-free format examples from sensor observations.
+The included regression tests cover these behaviors.
+
+Existing source licenses and notices remain applicable. This restoration does
+not assign a new license to third-party code. Original MMTA contributions retain
+the repository's [CC BY 4.0 declaration](../LICENSE); upstream dataset agreements
+and access conditions apply independently to source data and local derivatives.

processing/README.md

@@ -0,0 +1,51 @@
+# Setup for local source processing
+
+This directory contains the shared download and image/video conversion helpers
+used by the six recipe-only directories under `sample/`. Their source data and
+generated records are not distributed by this repository.
+
+Use Python 3.10 or later. From the directory containing `MMTA-v1.0/`, install
+the dependencies:
+
+```bash
+python -m pip install -r MMTA-v1.0/processing/requirements.txt
+```
+
+Install `ffmpeg` and `ffprobe` for video processing. Credentialed PhysioNet
+downloads also require `wget` and an interactive terminal.
+
+| Domain | Download and generation instructions |
+|---|---|
+| MIMIC mortality | [mimic_death](../sample/image-timeseries/mimic_death/README.md) |
+| MIMIC discharge | [mimic_disch](../sample/image-timeseries/mimic_disch/README.md) |
+| PixelRec | [pixelrec](../sample/image-timeseries/pixelrec/README.md) |
+| SP500 / FinMultiTime | [sp500](../sample/image-timeseries/sp500/README.md) |
+| CoVLA | [covla](../sample/video-timeseries/covla/README.md) |
+| CUHK-X HAR | [cuhk_x_har](../sample/video-timeseries/cuhk_x_har/README.md) |
+
+Complete each upstream source's access requirements with your own account before
+downloading. `download.py --dry-run` prints a plan without contacting a source or
+writing data; actual downloads require `--accept-terms`. Use `--help` on each
+domain's `download.py` and `generate.py` to inspect all available options.
+Downloaded archives must be unpacked before building.
+
+Keep source data and outputs outside `MMTA-v1.0/`, for example in sibling
+`local_sources/` and `local_work/` directories. Generation writes a new domain
+directory containing task JSONL, sensor CSVs and intermediate prompts. Video
+recipes also write cropped videos; image recipes reference the local source
+images rather than copying them. Generated paths are relative to that local
+domain directory, and can refer to source images outside it.
+
+`common/local_generation.py` orchestrates the per-domain builders and the common
+converters. Optional `--input-jsonl` skips source prompt construction for all
+recipes except SP500, which rebuilds inputs using source-dated news strictly
+before the forecast cutoff. MIMIC discharge also uses the table, bucketing and
+splitting helpers in `sample/image-timeseries/mimic_death/`; retain both MIMIC
+directories when copying scripts.
+
+The recipes support local reconstruction, whose exact records may depend on the
+available upstream versions. They are not additional `load_dataset`
+configurations and do not change the five released test splits.
+
+See [CODE_PROVENANCE.md](CODE_PROVENANCE.md) and
+[provenance.json](provenance.json) for script origins and retained notices.

processing/common/convert_images.py

@@ -0,0 +1,674 @@
+#!/usr/bin/env python3
+"""Convert image+timeseries jsonl into a unified OmniTS-style jsonl.
+
+Output row keys:
+  id, image_path, timeseries_path, prompt, answer, image_meta, ts_shape, task
+
+Notes:
+  * This script writes per-sample CSV files from timeseries content.
+  * It does NOT copy or move image files.
+  * `image_meta` stores image shape as (W, H, C).
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import re
+from pathlib import Path
+from typing import Any
+
+import cv2
+import pandas as pd
+
+
+TS_BLOCK_RE = re.compile(r"<timeseries>(.*?)</timeseries>", re.DOTALL)
+HISTORY_BLOCK_RE = re.compile(r"<history>(.*?)</history>", re.DOTALL)
+DATA_LINE_RE = re.compile(r"^[^:]+:\s*(.+)$")
+TASK_CHOICES = {"classification", "prediction"}
+PROMPT_INLINE_TS_RE = re.compile(r"\(([^()]+)\)")
+
+
+def safe_filename_component(value: str) -> str:
+    safe_value = re.sub(r"[^A-Za-z0-9_.-]+", "_", value).strip("_")
+    return safe_value or "unknown"
+
+
+def source_cache_key(value: str) -> str:
+    return hashlib.sha1(value.encode("utf-8")).hexdigest()[:10]
+
+
+SOURCE_ROOT: Path | None = None
+PATH_MAPS: list[tuple[str, str]] = []
+
+
+def resolve_source_image_path(image_path: str, jsonl_path: Path) -> Path:
+    """Resolve portable input paths and explicitly configured legacy prefixes."""
+    for old, new in PATH_MAPS:
+        if image_path == old or image_path.startswith(old.rstrip("/") + "/"):
+            image_path = new.rstrip("/") + image_path[len(old.rstrip("/")):]
+            break
+    path = Path(image_path).expanduser()
+    return path.resolve() if path.is_absolute() else ((SOURCE_ROOT or jsonl_path.parent) / path).resolve()
+
+
+def _dedupe_keep_order(items: list[str]) -> list[str]:
+    seen = set()
+    out: list[str] = []
+    for item in items:
+        if item in seen:
+            continue
+        seen.add(item)
+        out.append(item)
+    return out
+
+
+def choose_image_paths_from_value(value: Any) -> list[str]:
+    if isinstance(value, str):
+        v = value.strip()
+        if not v:
+            raise ValueError("image_path string is empty")
+        return [v]
+
+    if isinstance(value, list):
+        paths = [item.strip() for item in value if isinstance(item, str) and item.strip()]
+        paths = _dedupe_keep_order(paths)
+        if not paths:
+            raise ValueError("image_path list has no usable string element")
+        return paths
+
+    if isinstance(value, dict):
+        paths: list[str] = []
+        preferred = ("satellite", "relief", "image", "img", "path")
+        for key in preferred:
+            v = value.get(key)
+            if isinstance(v, str) and v.strip():
+                paths.append(v.strip())
+        for _, v in value.items():
+            if isinstance(v, str) and v.strip():
+                paths.append(v.strip())
+        paths = _dedupe_keep_order(paths)
+        if not paths:
+            raise ValueError("image_path dict has no usable string value")
+        return paths
+
+    raise ValueError(f"unsupported image_path type: {type(value).__name__}")
+
+
+def stable_sample_id(
+    entry: dict,
+    dataset_name: str,
+    id_field: str,
+    image_field: str,
+    line_no: int,
+) -> str:
+    existing = entry.get(id_field)
+    if existing:
+        return safe_filename_component(str(existing))
+
+    identity = {
+        "dataset": dataset_name,
+        "line_no": line_no,
+        "task_id": entry.get("task_id"),
+        "image_path": entry.get(image_field),
+    }
+    digest = source_cache_key(json.dumps(identity, sort_keys=True, ensure_ascii=False))
+    return f"{safe_filename_component(dataset_name)}_{line_no}_{digest}"
+
+
+def parse_timeseries_data_line(line: str) -> dict[str, Any] | None:
+    stripped = line.strip()
+    if not stripped:
+        return None
+
+    # Tuple style: "(timestamp, value[, value2, ...])"
+    # Also tolerate missing trailing ")" in noisy prompt text.
+    if stripped.startswith("("):
+        inner = stripped[1:].strip()
+        if inner.endswith(")"):
+            inner = inner[:-1].strip()
+        if not inner:
+            return None
+        row: dict[str, Any] = {}
+
+        comma_pos = inner.find(",")
+        colon_pos = inner.find(":")
+        # Terra-style: "(timestamp: v1, v2, ...)"
+        if colon_pos != -1 and (comma_pos == -1 or colon_pos < comma_pos):
+            ts, rest = inner.split(":", 1)
+            timestamp = ts.strip()
+            values = [part.strip() for part in rest.split(",")]
+        else:
+            # Standard tuple style: "(timestamp, v1, v2, ...)"
+            parts = [part.strip() for part in inner.split(",")]
+            if len(parts) < 2:
+                return None
+            timestamp = parts[0]
+            values = parts[1:]
+
+        row["timestamp"] = timestamp
+        for idx, raw_value in enumerate(values):
+            if raw_value in ("null", "None", "nan", "NaN", ""):
+                value = float("nan")
+            else:
+                try:
+                    value = float(raw_value)
+                except ValueError:
+                    continue
+            key = "value" if len(values) == 1 else f"v{idx}"
+            row[key] = value
+        if len(row) <= 1:
+            return None
+        return row
+
+    timestamp = ""
+    if "=" in stripped:
+        # Robust split for lines like:
+        # 2133-09-08T02:29:00: heart_rate_bpm=63.0, ...
+        # Use the last ":" before the first "=" as separator.
+        eq_pos = stripped.find("=")
+        sep_pos = stripped.rfind(":", 0, eq_pos)
+        if sep_pos != -1:
+            timestamp = stripped[:sep_pos].strip()
+            kv_part = stripped[sep_pos + 1 :].strip()
+        else:
+            kv_part = stripped
+    elif ":" in stripped:
+        timestamp, kv_part = stripped.split(":", 1)
+        timestamp = timestamp.strip()
+        kv_part = kv_part.strip()
+    elif "," in stripped:
+        timestamp, kv_part = stripped.split(",", 1)
+        timestamp = timestamp.strip()
+        kv_part = kv_part.strip()
+    else:
+        return None
+
+    if "..." in kv_part:
+        return None
+
+    row: dict[str, Any] = {}
+    row["timestamp"] = timestamp
+    parts = [part.strip() for part in kv_part.split(",") if part.strip()]
+    for idx, part in enumerate(parts):
+        if "=" in part:
+            key, value = part.split("=", 1)
+            key = key.strip()
+            value = value.strip()
+        else:
+            key = f"v{idx}"
+            value = part.strip()
+        if not key:
+            continue
+
+        if value in ("null", "None", "nan", "NaN", ""):
+            row[key] = float("nan")
+            continue
+
+        try:
+            row[key] = float(value)
+        except ValueError:
+            # Skip non-numeric values (e.g., timestamp strings in mixed rows).
+            continue
+    if len(row) <= 1:
+        return None
+    return row
+
+
+def _timeseries_lines_from_field(entry: dict) -> list[str]:
+    raw = entry.get("timeseries")
+    if raw is not None:
+        if isinstance(raw, str):
+            return raw.splitlines()
+        if isinstance(raw, list):
+            lines: list[str] = []
+            for idx, item in enumerate(raw):
+                if isinstance(item, str):
+                    lines.append(item)
+                elif isinstance(item, dict):
+                    parts = [f"{k}={v}" for k, v in item.items()]
+                    lines.append(f"{idx}: " + ", ".join(parts))
+            return lines
+        if isinstance(raw, dict):
+            parts = [f"{k}={v}" for k, v in raw.items()]
+            return ["0: " + ", ".join(parts)]
+    # Terra: historical arrays and optional time index; targets are never inputs.
+    his_keys = sorted([k for k in entry.keys() if isinstance(k, str) and k.startswith("his_") and k != "his_time_index"])
+    if his_keys:
+        lines: list[str] = []
+        his_time = entry.get("his_time_index")
+
+        def build_group(keys: list[str], time_values: Any, prefix: str) -> list[str]:
+            if not keys:
+                return []
+            arrays = []
+            for key in keys:
+                val = entry.get(key)
+                arrays.append(val if isinstance(val, list) else [])
+            length = min([len(arr) for arr in arrays] or [0])
+            if length <= 0:
+                return []
+            out: list[str] = []
+            for i in range(length):
+                t = None
+                if isinstance(time_values, list) and i < len(time_values):
+                    t = time_values[i]
+                tlabel = str(t) if t is not None else f"{prefix}_{i}"
+                parts = []
+                for key, arr in zip(keys, arrays):
+                    ch = key.replace(prefix + "_", "", 1)
+                    parts.append(f"{ch}={arr[i]}")
+                out.append(f"{tlabel}: " + ", ".join(parts))
+            return out
+
+        lines.extend(build_group(his_keys, his_time, "his"))
+        if lines:
+            return lines
+
+    # SP500 / PixelRec style: time_series_data list of scalars or vectors.
+    tsd = entry.get("time_series_data")
+    if isinstance(tsd, list) and tsd:
+        lines: list[str] = []
+        for i, item in enumerate(tsd):
+            if isinstance(item, list):
+                parts = [f"v{j}={v}" for j, v in enumerate(item)]
+                lines.append(f"{i}: " + ", ".join(parts))
+            elif isinstance(item, dict):
+                parts = [f"{k}={v}" for k, v in item.items()]
+                lines.append(f"{i}: " + ", ".join(parts))
+            else:
+                lines.append(f"{i}: value={item}")
+        return lines
+
+    # MIMIC style: vitals_aligned dict of channel->list.
+    va = entry.get("vitals_aligned")
+    if isinstance(va, dict) and va:
+        channels = []
+        arrays = []
+        for key, value in va.items():
+            if isinstance(value, list):
+                channels.append(str(key))
+                arrays.append(value)
+        length = min([len(arr) for arr in arrays] or [0])
+        if length > 0:
+            lines = []
+            for i in range(length):
+                parts = [f"{ch}={arr[i]}" for ch, arr in zip(channels, arrays)]
+                lines.append(f"{i}: " + ", ".join(parts))
+            return lines
+
+    # PixelRec style: hist_* series fields.
+    hist_keys = sorted(
+        [
+            k
+            for k in entry.keys()
+            if isinstance(k, str)
+            and k.startswith("hist_")
+            and k != "hist_timestamp"
+            and isinstance(entry.get(k), list)
+            and entry.get(k)
+            and all(isinstance(x, (int, float)) or x is None for x in entry.get(k))
+        ]
+    )
+    if hist_keys:
+        arrays = [entry[k] for k in hist_keys]
+        length = min([len(arr) for arr in arrays] or [0])
+        if length > 0:
+            ts = entry.get("hist_timestamp")
+            lines = []
+            for i in range(length):
+                tlabel = str(ts[i]) if isinstance(ts, list) and i < len(ts) else str(i)
+                parts = [f"{k.replace('hist_', '', 1)}={arr[i]}" for k, arr in zip(hist_keys, arrays)]
+                lines.append(f"{tlabel}: " + ", ".join(parts))
+            return lines
+
+    return []
+
+
+def _timeseries_lines_from_prompt(prompt: str) -> list[str]:
+    # Parse lines like "(timestamp: v1, v2, ...)" into "timestamp: v0=..., ..."
+    lines: list[str] = []
+    for m in PROMPT_INLINE_TS_RE.finditer(prompt):
+        inner = m.group(1).strip()
+        if ":" not in inner:
+            continue
+        t, rest = inner.split(":", 1)
+        t = t.strip()
+        rest = rest.strip()
+        if not t or not rest:
+            continue
+
+        segments = [seg.strip() for seg in rest.split(",")]
+        kv_parts: list[str] = []
+        for idx, seg in enumerate(segments):
+            if not seg:
+                continue
+            if "=" in seg:
+                k, v = seg.split("=", 1)
+                kv_parts.append(f"{k.strip()}={v.strip()}")
+            else:
+                kv_parts.append(f"v{idx}={seg}")
+        if kv_parts:
+            lines.append(f"{t}: " + ", ".join(kv_parts))
+    return lines
+
+
+def _timeseries_lines_from_entry_fallback(entry: dict) -> list[str]:
+    # Generic fallback for dict[str, list] numeric fields with optional time index.
+    series_keys = []
+    arrays = []
+    for key, value in entry.items():
+        if isinstance(value, list) and value and all(
+            isinstance(x, (int, float)) or x is None for x in value
+        ):
+            series_keys.append(str(key))
+            arrays.append(value)
+    if not arrays:
+        return []
+
+    length = min(len(arr) for arr in arrays)
+    if length <= 0:
+        return []
+
+    # Prefer explicit time index fields when available.
+    time_candidates = ("his_time_index", "time_index", "timestamp", "hist_timestamp")
+    t_values = None
+    for tk in time_candidates:
+        val = entry.get(tk)
+        if isinstance(val, list) and len(val) >= length:
+            t_values = val
+            break
+
+    lines: list[str] = []
+    for i in range(length):
+        tlabel = str(t_values[i]) if isinstance(t_values, list) else str(i)
+        parts = [f"{k}={arr[i]}" for k, arr in zip(series_keys, arrays)]
+        lines.append(f"{tlabel}: " + ", ".join(parts))
+    return lines
+
+
+def extract_or_build_timeseries_block(prompt: str, entry: dict) -> tuple[str, str]:
+    match = TS_BLOCK_RE.search(prompt)
+    if match:
+        return prompt, match.group(1).strip()
+
+    history_match = HISTORY_BLOCK_RE.search(prompt)
+    if history_match:
+        body = history_match.group(1).strip()
+        normalized_prompt = HISTORY_BLOCK_RE.sub(
+            lambda m: f"<timeseries>{m.group(1)}</timeseries>",
+            prompt,
+        )
+        return normalized_prompt, body
+
+    lines = _timeseries_lines_from_field(entry)
+    if not lines:
+        lines = _timeseries_lines_from_prompt(prompt)
+    if not lines:
+        lines = _timeseries_lines_from_entry_fallback(entry)
+    body = "\n".join(line.rstrip() for line in lines if line.strip()).strip()
+    if not body:
+        raise ValueError("no <timeseries> block in prompt and no usable entry['timeseries']")
+
+    block = f"<timeseries>\n{body}\n</timeseries>"
+    if prompt.strip():
+        updated_prompt = prompt.rstrip() + "\n\n" + block
+    else:
+        updated_prompt = block
+    return updated_prompt, body
+
+
+def parse_timeseries_body_to_df(body: str) -> pd.DataFrame:
+    records: list[dict[str, float]] = []
+    for line in body.splitlines():
+        row = parse_timeseries_data_line(line)
+        if row:
+            records.append(row)
+    if not records:
+        raise ValueError("<timeseries> block had no data rows")
+    return pd.DataFrame.from_records(records)
+
+
+def probe_image_meta(image_path: Path, allow_missing: bool = False) -> dict[str, int]:
+    image = cv2.imread(str(image_path), cv2.IMREAD_UNCHANGED)
+    if image is None:
+        if allow_missing:
+            return {"width": -1, "height": -1, "channels": -1}
+        raise FileNotFoundError(f"failed to read image: {image_path}")
+
+    if len(image.shape) == 2:
+        height, width = image.shape
+        channels = 1
+    else:
+        height, width, channels = image.shape[:3]
+    return {
+        "width": int(width),
+        "height": int(height),
+        "channels": int(channels),
+    }
+
+
+def resolve_task_value(entry: dict, task_field: str, default_task: str) -> str:
+    raw = entry.get(task_field)
+    if isinstance(raw, str) and raw.lower() in TASK_CHOICES:
+        return raw.lower()
+    return default_task
+
+
+def normalize_answer_value(value: Any) -> str:
+    if isinstance(value, str):
+        return value
+    if isinstance(value, (int, float, bool)):
+        return str(value)
+    if isinstance(value, list):
+        return json.dumps(value, ensure_ascii=False)
+    if isinstance(value, dict):
+        return json.dumps(value, ensure_ascii=False)
+    return str(value)
+
+
+def format_forecast_answer_if_possible(entry: dict, answer_value: Any) -> str | None:
+    if isinstance(answer_value, str):
+        stripped = answer_value.strip()
+        if "<forecast>" in stripped and "</forecast>" in stripped:
+            return answer_value
+        return None
+
+    if not isinstance(answer_value, list) or not answer_value:
+        return None
+
+    meta_info = entry.get("meta_info")
+    if not isinstance(meta_info, dict):
+        return None
+    future_ts = meta_info.get("future_timestamps")
+    if not isinstance(future_ts, list) or not future_ts:
+        return None
+    if len(future_ts) != len(answer_value):
+        return None
+
+    lines = ["<forecast>"]
+    for ts, v in zip(future_ts, answer_value):
+        values = v if isinstance(v, list) else [v]
+        lines.append(f"({ts}: {', '.join(str(value) for value in values)})")
+    lines.append("</forecast>")
+    return "\n".join(lines)
+
+
+def convert_entry(
+    entry: dict,
+    jsonl_path: Path,
+    csv_dir: Path,
+    dataset_name: str,
+    line_no: int,
+    id_field: str,
+    image_field: str,
+    prompt_field: str,
+    answer_field: str,
+    task_field: str,
+    default_task: str,
+    allow_missing_image: bool,
+) -> dict:
+    prompt_value = entry.get(prompt_field)
+    if not isinstance(prompt_value, str):
+        raise ValueError(f"{prompt_field} must be a string")
+
+    image_value = entry.get(image_field)
+    image_path_values = choose_image_paths_from_value(image_value)
+
+    answer_value = entry.get(answer_field)
+    if answer_value is None:
+        answer_value = entry.get("answer")
+    if answer_value is None:
+        answer_value = entry.get("ground_truth")
+    if answer_value is None:
+        raise ValueError("missing answer value")
+
+    sample_id = stable_sample_id(
+        entry=entry,
+        dataset_name=dataset_name,
+        id_field=id_field,
+        image_field=image_field,
+        line_no=line_no,
+    )
+
+    src_image_paths = [resolve_source_image_path(p, jsonl_path) for p in image_path_values]
+    image_metas = [probe_image_meta(p, allow_missing=allow_missing_image) for p in src_image_paths]
+
+    updated_prompt, ts_body = extract_or_build_timeseries_block(prompt_value, entry)
+    ts_df = parse_timeseries_body_to_df(ts_body)
+
+    csv_name = f"{sample_id}.csv"
+    csv_path = (csv_dir / csv_name).resolve()
+    ts_df.to_csv(csv_path, index=False)
+
+    formatted_answer = format_forecast_answer_if_possible(entry, answer_value)
+    output = {
+        "id": sample_id,
+        "image_path": [str(p) for p in src_image_paths],
+        "timeseries_path": str(csv_path),
+        "prompt": updated_prompt,
+        "answer": formatted_answer if formatted_answer is not None else normalize_answer_value(answer_value),
+        "image_meta": image_metas,
+        "ts_shape": [int(ts_df.shape[0]), sum(str(column).lower() not in {"timestamp", "time", "datetime"} for column in ts_df.columns)],
+        "task": resolve_task_value(entry, task_field, default_task),
+    }
+    return output
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Convert image+timeseries jsonl to unified image OmniTS jsonl."
+    )
+    parser.add_argument("--in-jsonl", type=Path, required=True)
+    parser.add_argument("--out-jsonl", type=Path, required=True)
+    parser.add_argument("--csv-dir", type=Path, required=True)
+    parser.add_argument("--dataset-name", default="image_dataset")
+    parser.add_argument("--id-field", default="id")
+    parser.add_argument("--image-field", default="image_path")
+    parser.add_argument("--prompt-field", default="prompt")
+    parser.add_argument("--answer-field", default="ground_truth")
+    parser.add_argument("--task-field", default="task")
+    parser.add_argument(
+        "--default-task",
+        choices=sorted(TASK_CHOICES),
+        default="classification",
+        help="Fallback task value when task field is missing/invalid.",
+    )
+    parser.add_argument("--limit", type=int, default=None, help="Convert first N rows only.")
+    parser.add_argument(
+        "--start-line",
+        type=int,
+        default=1,
+        help="1-based inclusive source line number to start processing from.",
+    )
+    parser.add_argument(
+        "--end-line",
+        type=int,
+        default=None,
+        help="1-based inclusive source line number to stop processing at.",
+    )
+    parser.add_argument(
+        "--skip-errors",
+        action="store_true",
+        help="Skip rows that fail conversion and continue.",
+    )
+    parser.add_argument(
+        "--allow-missing-image",
+        action="store_true",
+        help="Allow missing/unreadable images and write image_meta as -1 placeholders.",
+    )
+    parser.add_argument("--source-root", type=Path, help="Base directory for relative input image paths.")
+    parser.add_argument("--path-map", action="append", default=[], metavar="OLD=NEW",
+                        help="Remap a legacy path prefix; repeat for multiple roots.")
+    args = parser.parse_args()
+    global SOURCE_ROOT, PATH_MAPS
+    SOURCE_ROOT = args.source_root.resolve() if args.source_root else None
+    PATH_MAPS = []
+    for item in args.path_map:
+        if "=" not in item:
+            parser.error("--path-map must have the form OLD=NEW")
+        PATH_MAPS.append(tuple(item.split("=", 1)))
+
+    in_jsonl = args.in_jsonl.resolve()
+    out_jsonl = args.out_jsonl.resolve()
+    csv_dir = args.csv_dir.resolve()
+
+    out_jsonl.parent.mkdir(parents=True, exist_ok=True)
+    csv_dir.mkdir(parents=True, exist_ok=True)
+
+    converted = 0
+    skipped: list[tuple[int, str]] = []
+
+    if args.start_line < 1:
+        raise ValueError("--start-line must be >= 1")
+    if args.end_line is not None and args.end_line < args.start_line:
+        raise ValueError("--end-line must be >= --start-line")
+
+    with in_jsonl.open("r", encoding="utf-8") as fin, out_jsonl.open("w", encoding="utf-8") as fout:
+        for line_no, line in enumerate(fin, start=1):
+            if line_no < args.start_line:
+                continue
+            if args.end_line is not None and line_no > args.end_line:
+                break
+            if args.limit is not None and converted >= args.limit:
+                break
+            if not line.strip():
+                continue
+
+            try:
+                entry = json.loads(line)
+                row = convert_entry(
+                    entry=entry,
+                    jsonl_path=in_jsonl,
+                    csv_dir=csv_dir,
+                    dataset_name=args.dataset_name,
+                    line_no=line_no,
+                    id_field=args.id_field,
+                    image_field=args.image_field,
+                    prompt_field=args.prompt_field,
+                    answer_field=args.answer_field,
+                    task_field=args.task_field,
+                    default_task=args.default_task,
+                    allow_missing_image=args.allow_missing_image,
+                )
+            except Exception as exc:  # noqa: BLE001
+                if args.skip_errors:
+                    skipped.append((line_no, str(exc)))
+                    continue
+                raise RuntimeError(f"line {line_no}: {exc}") from exc
+
+            fout.write(json.dumps(row, ensure_ascii=False) + "\n")
+            converted += 1
+
+    print(f"converted {converted} entries -> {out_jsonl}")
+    if skipped:
+        print(f"skipped {len(skipped)} entries")
+        for line_no, reason in skipped[:20]:
+            print(f"  line {line_no}: {reason}")
+        if len(skipped) > 20:
+            print(f"  ... {len(skipped) - 20} more")
+
+
+if __name__ == "__main__":
+    main()

processing/common/convert_videos.py

@@ -0,0 +1,623 @@
+#!/usr/bin/env python3
+"""Convert prompt JSONL into sensor CSVs, cropped videos and OmniTS metadata.
+
+Supported video domains include CoVLA, AgiBot, CUHK-X, Future Factories and
+HoloAssist. Intermediate outputs may use local paths; package_release.py
+copies referenced assets and writes relative paths for distribution.
+Video stream copying preserves the original pipeline's keyframe behavior.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import re
+import shutil
+import subprocess
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from pathlib import Path
+
+import pandas as pd
+
+from probe import probe_ts_shape, probe_video_meta
+
+TS_BLOCK_RE = re.compile(r"<timeseries>(.*?)</timeseries>", re.DOTALL)
+DATA_LINE_RE = re.compile(r"^[\d.]+:\s*(.+)$")
+TEMPORAL_FIELD_KEYS = ("frames", "segment", "start_frame", "end_frame", "start", "end")
+
+
+def safe_filename_component(value: str) -> str:
+    safe_value = re.sub(r"[^A-Za-z0-9_.-]+", "_", value).strip("_")
+    return safe_value or "unknown"
+
+
+def source_cache_key(value: str) -> str:
+    return hashlib.sha1(value.encode("utf-8")).hexdigest()[:10]
+
+
+def stable_video_id(entry: dict, dataset_name: str) -> str:
+    """Use existing video_id when present; otherwise create a stable trace id."""
+    existing = entry.get("video_id")
+    if existing:
+        return safe_filename_component(str(existing))
+
+    identity = {
+        "dataset": dataset_name,
+        "task_id": entry.get("task_id"),
+        "video_path": entry.get("video_path"),
+        "frames": entry.get("frames"),
+        "segment": entry.get("segment"),
+        "start_frame": entry.get("start_frame"),
+        "end_frame": entry.get("end_frame"),
+        "start": entry.get("start"),
+        "end": entry.get("end"),
+    }
+    digest = source_cache_key(json.dumps(identity, sort_keys=True, ensure_ascii=False))
+    task_id = safe_filename_component(str(entry.get("task_id", "no_task_id")))
+    dataset_part = safe_filename_component(dataset_name)
+    return f"{dataset_part}_{task_id}_{digest}"
+
+
+def has_temporal_bounds(entry: dict) -> bool:
+    """Return True when a row has the temporal fields used by video preprocessing."""
+    if entry.get("frames") is not None or entry.get("segment") is not None:
+        return True
+    if entry.get("start_frame") is not None and entry.get("end_frame") is not None:
+        return True
+    return entry.get("start") is not None and entry.get("end") is not None
+
+
+def has_frame_bounds(entry: dict) -> bool:
+    """Frame bounds take priority over time bounds, as in preprocess_video_segments."""
+    if isinstance(entry.get("frames"), dict):
+        return True
+    return entry.get("start_frame") is not None and entry.get("end_frame") is not None
+
+
+def extract_frame_bounds(entry: dict) -> tuple[int, int]:
+    """Extract [start_frame, end_frame] from ``frames`` or top-level fields."""
+    frames = entry.get("frames")
+    if isinstance(frames, dict):
+        start = int(frames.get("start_frame", entry.get("start_frame", 0)))
+        end = int(frames.get("end_frame", entry.get("end_frame", 0)))
+    else:
+        start = int(entry.get("start_frame", 0))
+        end = int(entry.get("end_frame", 0))
+    if end < start:
+        raise ValueError(f"invalid frame range: start={start}, end={end}")
+    return start, end
+
+
+def extract_time_bounds(entry: dict) -> tuple[float, float]:
+    """Extract [start, end] seconds from ``segment`` or top-level fields."""
+    segment = entry.get("segment")
+    if isinstance(segment, dict):
+        start = segment.get("start")
+        end = segment.get("end")
+        if start is not None and end is not None:
+            start = float(start)
+            end = float(end)
+            if end < start:
+                raise ValueError(f"invalid time range: start={start}, end={end}")
+            return start, end
+
+    start = entry.get("start")
+    end = entry.get("end")
+    if start is not None and end is not None:
+        start = float(start)
+        end = float(end)
+        if end < start:
+            raise ValueError(f"invalid time range: start={start}, end={end}")
+        return start, end
+
+    raise KeyError("no valid time bounds found")
+
+
+def _video_meta_dict(meta) -> dict | None:
+    """Shape the 5-tuple from probe_video_meta into the jsonl dict form."""
+    if meta is None:
+        return None
+    w, h, sfps, nf, dur = meta
+    return {
+        "width": int(w), "height": int(h),
+        "source_fps": float(sfps),
+        "nb_frames": int(nf),
+        "duration": float(dur),
+    }
+
+
+def parse_timeseries_data_line(line: str) -> dict[str, float] | None:
+    """Parse one prompt timeseries row into numeric channel values.
+
+    Supported prompt row shapes:
+      * ``12.345: x=1, y=2`` used by CoVLA/Holo/AgiBot/CUHK-X
+      * ``2023-...Z, x=1, y=2`` used by Future Factories
+    """
+    stripped = line.strip()
+    if not stripped:
+        return None
+
+    m = DATA_LINE_RE.match(stripped)
+    if m:
+        kv_part = m.group(1)
+    elif "," in stripped:
+        timestamp, kv_part = stripped.split(",", 1)
+        if not re.fullmatch(r"\d{4}-\d{2}-\d{2}(?:[T ].+)?", timestamp.strip()):
+            return None
+    else:
+        return None
+
+    if "..." in kv_part:
+        return None
+
+    row: dict[str, float] = {}
+    for pair in kv_part.split(","):
+        if "=" not in pair:
+            continue
+        k, v = pair.split("=", 1)
+        k, v = k.strip(), v.strip()
+        if not k:
+            continue
+        if v in ("null", "None", "nan", "NaN", ""):
+            row[k] = float("nan")
+        else:
+            row[k] = float(v)
+    return row or None
+
+
+def parse_timeseries_block(text: str) -> pd.DataFrame:
+    """Extract numeric rows from a <timeseries>...</timeseries> block into a DataFrame.
+
+    Each data line looks like: "25.5: vEgo=6.517, aEgo=0.197, ..., lead_a=null".
+    Returns a DataFrame with one column per variable; "null" or empty becomes NaN.
+    """
+    match = TS_BLOCK_RE.search(text)
+    if not match:
+        raise ValueError("no <timeseries> block found")
+    body = match.group(1)
+
+    records: list[dict[str, float]] = []
+    for line in body.splitlines():
+        row = parse_timeseries_data_line(line)
+        if row:
+            records.append(row)
+
+    if not records:
+        raise ValueError("<timeseries> block had no data rows")
+
+    return pd.DataFrame.from_records(records)
+
+
+def probe_video_fps(video_path: Path) -> float:
+    """Use ffprobe to read the source video's avg_frame_rate as a float."""
+    result = subprocess.run(
+        [
+            "ffprobe", "-v", "error", "-select_streams", "v:0",
+            "-show_entries", "stream=avg_frame_rate",
+            "-of", "default=nw=1:nk=1",
+            str(video_path),
+        ],
+        capture_output=True, text=True, check=True,
+    )
+    num, den = result.stdout.strip().split("/")
+    num_f, den_f = float(num), float(den)
+    if den_f == 0:
+        return 0.0
+    return num_f / den_f
+
+
+def probe_video_frame_count(video_path: Path) -> int:
+    """Use ffprobe to estimate total frames for whole-clip conversion."""
+    meta = probe_video_meta(str(video_path))
+    if meta is None:
+        return 0
+    _width, _height, source_fps, nb_frames, duration = meta
+    if nb_frames > 0:
+        return int(nb_frames)
+    if source_fps > 0 and duration > 0:
+        return max(1, int(duration * source_fps))
+    return 0
+
+
+def get_video_fps(src_video: Path, fps_cache: dict[Path, float]) -> float:
+    """Read and cache source fps for frame/time conversion."""
+    if src_video not in fps_cache:
+        fps_cache[src_video] = probe_video_fps(src_video)
+    fps = fps_cache[src_video]
+    if fps <= 0:
+        raise RuntimeError(f"could not probe fps for {src_video}")
+    return fps
+
+
+def time_to_frame_bounds(start_time: float, end_time: float, fps: float) -> tuple[int, int]:
+    """Convert seconds to inclusive frame bounds, matching preprocess_video_segments."""
+    if fps <= 0:
+        raise RuntimeError(f"cannot convert time bounds with invalid fps={fps}")
+    start_frame = max(0, int(start_time * fps))
+    end_frame = max(start_frame, int(end_time * fps))
+    return start_frame, end_frame
+
+
+def resolve_frame_bounds(
+    entry: dict,
+    src_video: Path,
+    fps_cache: dict[Path, float],
+) -> tuple[int, int]:
+    """Resolve supported temporal fields into inclusive frame bounds.
+
+    ``preprocess_video_segments.py`` accepts both frame fields and time fields.
+    This converter keeps the same precedence: explicit frame bounds are used
+    directly; otherwise ``segment`` / ``start`` / ``end`` are converted through
+    the source video's fps.
+    """
+    if has_frame_bounds(entry):
+        return extract_frame_bounds(entry)
+
+    if has_temporal_bounds(entry):
+        start_sec, end_sec = extract_time_bounds(entry)
+        fps = get_video_fps(src_video, fps_cache)
+        return time_to_frame_bounds(start_sec, end_sec, fps)
+
+    total_frames = probe_video_frame_count(src_video)
+    if total_frames <= 0:
+        raise KeyError(
+            "no temporal bounds found and failed to probe whole-video frame count; "
+            "expected frames, segment, start_frame/end_frame, or start/end"
+        )
+    return 0, total_frames - 1
+
+
+def frame_bounds_to_seconds(
+    start_frame: int,
+    end_frame: int,
+    src_video: Path,
+    fps_cache: dict[Path, float],
+) -> tuple[float, float]:
+    """Convert inclusive frame bounds to ffmpeg -ss / -t seconds."""
+    fps = get_video_fps(src_video, fps_cache)
+    start_sec = start_frame / fps
+    duration_sec = max(1e-3, (end_frame - start_frame + 1) / fps)
+    return start_sec, duration_sec
+
+
+def slice_video(src: Path, dst: Path, start_sec: float, duration_sec: float) -> None:
+    """Copy a segment with -c copy (stream copy, near-instant). Overwrites dst.
+
+    Caveat: `-ss` before `-i` with `-c copy` seeks to the nearest keyframe, so
+    clip start may be offset by up to the GOP length (typically ≤ 1s). For
+    video-QA training on multi-second segments this is acceptable.
+    """
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    if shutil.which("ffmpeg") is None:
+        raise RuntimeError("ffmpeg not found on PATH")
+    cmd = [
+        "ffmpeg", "-y", "-loglevel", "error",
+        "-ss", f"{start_sec:.3f}",
+        "-i", str(src),
+        "-t", f"{duration_sec:.3f}",
+        "-an",
+        "-c", "copy",
+        "-avoid_negative_ts", "make_zero",
+        str(dst),
+    ]
+    subprocess.run(cmd, check=True, capture_output=True)
+
+
+def convert_entry(
+    entry: dict,
+    csv_dir: Path,
+    clip_dir: Path,
+    fps_cache: dict[Path, float],
+    prompt_only: bool = False,
+    dataset_name: str = "dataset",
+    copy_full_video: bool = True,
+) -> dict:
+    """Convert one CoVLA row into the unified OmniTS row.
+
+    Returns: ``{video_id, video_path, timeseries_path, prompt, answer}`` where
+    ``prompt`` retains the inline ``<timeseries>...</timeseries>`` body.
+
+    ``prompt_only=True`` skips TS-CSV writing and video slicing. The derived
+    paths must already exist on disk. Use this to refresh prompts after the
+    source prompt text changes without re-running the expensive work.
+    """
+    csv_dir = Path(csv_dir).resolve()
+    clip_dir = Path(clip_dir).resolve()
+    if not prompt_only:
+        csv_dir.mkdir(parents=True, exist_ok=True)
+        clip_dir.mkdir(parents=True, exist_ok=True)
+
+    video_id = stable_video_id(entry, dataset_name)
+    src_video = Path(entry["video_path"]).expanduser().resolve()
+    start_frame, end_frame = resolve_frame_bounds(
+        entry=entry,
+        src_video=src_video,
+        fps_cache=fps_cache,
+    )
+
+    # 1. Time-series CSV. In prompt-only mode we read the shape from the
+    # existing file; in fresh mode we use the in-memory DataFrame's shape
+    # directly (no extra IO).
+    csv_name = f"{video_id}_{start_frame}_{end_frame}.csv"
+    csv_path = csv_dir / csv_name
+    if prompt_only:
+        if not csv_path.exists():
+            raise FileNotFoundError(f"prompt-only mode: missing csv {csv_path}")
+        ts_shape = probe_ts_shape(str(csv_path))
+    else:
+        df = parse_timeseries_block(entry["prompt"])
+        df.to_csv(csv_path, index=False)
+        ts_shape = (int(df.shape[0]), int(df.shape[1]))
+
+    # 2. Video clip (ffmpeg-sliced). Reuse if it already exists.
+    clip_name = f"{video_id}_{start_frame}_{end_frame}.mp4"
+    clip_path = clip_dir / clip_name
+    if prompt_only:
+        if not (clip_path.exists() and clip_path.stat().st_size > 0):
+            raise FileNotFoundError(f"prompt-only mode: missing clip {clip_path}")
+    elif not (clip_path.exists() and clip_path.stat().st_size > 0):
+        if copy_full_video and not has_temporal_bounds(entry):
+            clip_path.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(src_video, clip_path)
+        else:
+            start_sec, duration_sec = frame_bounds_to_seconds(
+                start_frame=start_frame,
+                end_frame=end_frame,
+                src_video=src_video,
+                fps_cache=fps_cache,
+            )
+            slice_video(src_video, clip_path, start_sec, duration_sec)
+
+    # 2b. Probe the sliced clip for the meta that `compute_exact_lengths`
+    # needs — same whether we just wrote it or are reusing an existing clip.
+    video_meta = _video_meta_dict(probe_video_meta(str(clip_path)))
+
+    # 3. Unified row — prompt retains inline TS body; baseline uses it as-is,
+    # omnits strips it in the collator via strip_ts_block(). video_meta /
+    # ts_shape are optional hints consumed by the length estimator.
+    row: dict = {
+        "video_id": video_id,
+        "video_path": str(clip_path),
+        "timeseries_path": str(csv_path),
+        "prompt": entry["prompt"],
+        "answer": entry["ground_truth"],
+    }
+    if video_meta is not None:
+        row["video_meta"] = video_meta
+    if ts_shape is not None:
+        row["ts_shape"] = [int(ts_shape[0]), int(ts_shape[1])]
+    return row
+
+
+def _worker_convert(args: tuple[dict, str, str, bool, str, bool]) -> tuple[int, dict]:
+    """Worker for ProcessPoolExecutor: convert a single entry.
+
+    Returns (line_no, row). fps_cache is per-worker (no sharing).
+    """
+    entry, csv_dir, clip_dir, prompt_only, dataset_name, copy_full_video = args
+    line_no = entry["_line_no"]
+    _entry = {k: v for k, v in entry.items() if k != "_line_no"}
+    row = convert_entry(
+        _entry, csv_dir=Path(csv_dir), clip_dir=Path(clip_dir),
+        fps_cache={}, prompt_only=prompt_only, dataset_name=dataset_name,
+        copy_full_video=copy_full_video,
+    )
+    return line_no, row
+
+
+def _annotate_only(jsonl_path: Path, num_workers: int, force: bool) -> None:
+    """Backfill video_meta / ts_shape into an existing unified OmniTS jsonl.
+
+    Use when clips + csvs already exist on disk and you only need the meta
+    fields added. Rewrites `jsonl_path` in place via .tmp + rename. Skips
+    rows that already have both fields unless --force is passed."""
+    with jsonl_path.open() as f:
+        rows = [json.loads(l) for l in f if l.strip()]
+    print(f"[ANNOTATE] loaded {len(rows)} rows from {jsonl_path}")
+
+    v_todo = [
+        i for i, r in enumerate(rows)
+        if force or not isinstance(r.get("video_meta"), dict)
+    ]
+    t_todo = [
+        i for i, r in enumerate(rows)
+        if r.get("timeseries_path") and
+           (force or not isinstance(r.get("ts_shape"), (list, tuple)))
+    ]
+    print(f"[ANNOTATE] to probe: {len(v_todo)} videos, {len(t_todo)} TS csvs "
+          f"(workers={num_workers})")
+
+    if v_todo:
+        done = 0
+        with ProcessPoolExecutor(max_workers=num_workers) as pool:
+            futs = {pool.submit(probe_video_meta, rows[i]["video_path"]): i for i in v_todo}
+            for fut in as_completed(futs):
+                i = futs[fut]
+                vm = _video_meta_dict(fut.result())
+                if vm is not None:
+                    rows[i]["video_meta"] = vm
+                done += 1
+                if done % 1000 == 0:
+                    print(f"[ANNOTATE]   video {done}/{len(v_todo)}", flush=True)
+
+    if t_todo:
+        done = 0
+        with ProcessPoolExecutor(max_workers=num_workers) as pool:
+            futs = {pool.submit(probe_ts_shape, rows[i]["timeseries_path"]): i for i in t_todo}
+            for fut in as_completed(futs):
+                i = futs[fut]
+                shape = fut.result()
+                if shape is not None:
+                    rows[i]["ts_shape"] = [int(shape[0]), int(shape[1])]
+                done += 1
+                if done % 2000 == 0:
+                    print(f"[ANNOTATE]   ts {done}/{len(t_todo)}", flush=True)
+
+    tmp = jsonl_path.with_suffix(jsonl_path.suffix + ".tmp")
+    with tmp.open("w") as f:
+        for r in rows:
+            f.write(json.dumps(r, ensure_ascii=False) + "\n")
+    tmp.replace(jsonl_path)
+
+    n_vm = sum(1 for r in rows if isinstance(r.get("video_meta"), dict))
+    n_ts = sum(1 for r in rows if isinstance(r.get("ts_shape"), (list, tuple)))
+    print(f"[ANNOTATE] wrote {jsonl_path}: {n_vm}/{len(rows)} video_meta, "
+          f"{n_ts}/{len(rows)} ts_shape")
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument(
+        "--annotate-only", action="store_true",
+        help="Skip slicing/parsing. Probe existing clips+csvs and write "
+             "video_meta / ts_shape back into --jsonl in place.",
+    )
+    ap.add_argument("--jsonl", type=Path,
+                   help="[annotate-only mode] path to unified omnits jsonl to update in place.")
+    ap.add_argument("--force", action="store_true",
+                   help="[annotate-only mode] re-probe rows that already have meta.")
+    ap.add_argument("--in-jsonl", type=Path)
+    ap.add_argument("--out-jsonl", type=Path)
+    ap.add_argument("--csv-dir", type=Path)
+    ap.add_argument("--clip-dir", type=Path)
+    ap.add_argument(
+        "--dataset-name",
+        default="dataset",
+        help="Prefix used when rows do not already contain video_id.",
+    )
+    ap.add_argument("--limit", type=int, default=None, help="First N rows only (smoke).")
+    ap.add_argument(
+        "--num-workers",
+        type=int,
+        default=1,
+        help="Parallel ffmpeg / probe workers. 1 = sequential.",
+    )
+    ap.add_argument(
+        "--prompt-only",
+        action="store_true",
+        help="Refresh prompts only: reuse existing TS CSVs and video clips, "
+             "skip ffmpeg slicing and TS parsing. Fails if derived files are missing.",
+    )
+    ap.add_argument(
+        "--slice-full-video",
+        action="store_true",
+        help="When a row has no temporal bounds, still rewrite the whole video with ffmpeg. "
+             "Default is to copy the already-segmented video into --clip-dir.",
+    )
+    ap.add_argument(
+        "--skip-errors",
+        action="store_true",
+        help="Skip rows that fail conversion and report their line numbers instead of stopping.",
+    )
+    ap.add_argument("--source-root", type=Path, help="Base directory for relative input video paths.")
+    ap.add_argument("--path-map", action="append", default=[], metavar="OLD=NEW",
+                    help="Remap a legacy path prefix; repeat for multiple roots.")
+    args = ap.parse_args()
+    path_maps = []
+    for item in args.path_map:
+        if "=" not in item:
+            ap.error("--path-map must have the form OLD=NEW")
+        path_maps.append(tuple(item.split("=", 1)))
+
+    if args.annotate_only:
+        if args.jsonl is None:
+            ap.error("--annotate-only requires --jsonl")
+        _annotate_only(args.jsonl, args.num_workers, args.force)
+        return
+
+    missing = [n for n in ("in_jsonl", "out_jsonl", "csv_dir", "clip_dir")
+               if getattr(args, n) is None]
+    if missing:
+        ap.error(f"missing required args for conversion: {missing}")
+
+    args.out_jsonl.parent.mkdir(parents=True, exist_ok=True)
+    entries: list[dict] = []
+    with args.in_jsonl.open() as fin:
+        for line_no, line in enumerate(fin, 1):
+            if args.limit is not None and line_no > args.limit:
+                break
+            entry = json.loads(line)
+            raw = entry["video_path"]
+            for old, new in path_maps:
+                if raw == old or raw.startswith(old.rstrip("/") + "/"):
+                    raw = new.rstrip("/") + raw[len(old.rstrip("/")):]
+                    break
+            source_video = Path(raw).expanduser()
+            if not source_video.is_absolute():
+                source_video = (args.source_root or args.in_jsonl.resolve().parent) / source_video
+            entry["video_path"] = str(source_video.resolve())
+            entry["_line_no"] = line_no
+            entries.append(entry)
+
+    fout = args.out_jsonl.open("w")
+    n = 0
+    skipped: list[tuple[int, str]] = []
+
+    if args.num_workers <= 1:
+        fps_cache: dict[Path, float] = {}
+        try:
+            for entry in entries:
+                line_no = entry.pop("_line_no")
+                try:
+                    row = convert_entry(
+                        entry, csv_dir=args.csv_dir, clip_dir=args.clip_dir,
+                        fps_cache=fps_cache, prompt_only=args.prompt_only,
+                        dataset_name=args.dataset_name,
+                        copy_full_video=not args.slice_full_video,
+                    )
+                except (ValueError, KeyError, RuntimeError,
+                        subprocess.CalledProcessError) as exc:
+                    if args.skip_errors:
+                        skipped.append((line_no, str(exc)))
+                        continue
+                    raise RuntimeError(f"line {line_no}: {exc}") from exc
+                fout.write(json.dumps(row, ensure_ascii=False) + "\n")
+                n += 1
+        finally:
+            fout.close()
+    else:
+        # Parallel: write rows as they complete (no order guarantee — shuffle-safe).
+        work = [
+            (
+                e,
+                str(args.csv_dir),
+                str(args.clip_dir),
+                args.prompt_only,
+                args.dataset_name,
+                not args.slice_full_video,
+            )
+            for e in entries
+        ]
+        try:
+            with ProcessPoolExecutor(max_workers=args.num_workers) as pool:
+                for future in as_completed(
+                    [pool.submit(_worker_convert, w) for w in work]
+                ):
+                    try:
+                        _line_no, row = future.result()
+                    except Exception as exc:
+                        if args.skip_errors:
+                            skipped.append((-1, str(exc)))
+                            continue
+                        raise
+                    fout.write(json.dumps(row, ensure_ascii=False) + "\n")
+                    fout.flush()
+                    n += 1
+                    if n % 200 == 0:
+                        print(f"  converted {n}/{len(entries)}", flush=True)
+        finally:
+            fout.close()
+
+    print(f"converted {n} entries → {args.out_jsonl}")
+    if skipped:
+        print(f"skipped {len(skipped)} entries")
+        for line_no, reason in skipped[:20]:
+            location = f"line {line_no}" if line_no > 0 else "worker"
+            print(f"  {location}: {reason}")
+        if len(skipped) > 20:
+            print(f"  ... {len(skipped) - 20} more")
+
+
+if __name__ == "__main__":
+    main()

processing/common/local_generation.py

@@ -0,0 +1,260 @@
+#!/usr/bin/env python3
+"""Run excluded-domain builders and conversion into a private output tree."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+
+PROCESSING = Path(__file__).resolve().parents[1]
+RELEASE = PROCESSING.parent
+DOMAINS = ("covla", "cuhk_x_har", "mimic_death", "mimic_disch", "pixelrec", "sp500")
+IMAGE_DOMAINS = {"mimic_death", "mimic_disch", "pixelrec", "sp500"}
+
+
+def run_stage(script: str, *arguments: object) -> None:
+    """Use the current interpreter and keep bytecode out of the release."""
+    group = script.split("/", 1)[0]
+    if group in DOMAINS:
+        modality = "image-timeseries" if group in IMAGE_DOMAINS else "video-timeseries"
+        path = RELEASE / "sample" / modality / script
+    else:
+        path = PROCESSING / script
+    subprocess.run(
+        [sys.executable, "-B", str(path), *map(str, arguments)],
+        check=True,
+    )
+
+
+def require_path(parser: argparse.ArgumentParser, path: Path | None, option: str) -> Path:
+    if path is None or not path.exists():
+        parser.error(f"{option} must identify an existing local input")
+    return path.resolve()
+
+
+def build_prompts(
+    args: argparse.Namespace, parser: argparse.ArgumentParser, output: Path,
+) -> Path:
+    if args.input_jsonl:
+        return require_path(parser, args.input_jsonl, "--input-jsonl")
+    prompts = output / "intermediate"
+    if args.domain in {"mimic_death", "mimic_disch"}:
+        hosp = require_path(parser, args.mimic_hosp_dir, "--mimic-hosp-dir")
+        notes = require_path(parser, args.mimic_note_dir, "--mimic-note-dir")
+        metadata = require_path(parser, args.cxr_metadata_csv, "--cxr-metadata-csv")
+        images = require_path(parser, args.cxr_jpg_root, "--cxr-jpg-root")
+        prompts.mkdir()
+        buckets = args.chartevents_root
+        if buckets is None:
+            events = require_path(parser, args.chartevents, "--chartevents")
+            buckets = prompts / "chartevents_bucketed"
+            run_stage("mimic_death/bucket_chartevents.py", "--input", events,
+                      "--output-root", buckets, "--chunksize", args.chunksize)
+        else:
+            buckets = require_path(parser, buckets, "--chartevents-root")
+        raw = prompts / "patients.jsonl"
+        common = ["--mimic-hosp-dir", hosp, "--mimic-note-dir", notes,
+                  "--cxr-metadata-csv", metadata, "--cxr-jpg-root", images,
+                  "--chartevents-root", buckets, "--out-jsonl", raw,
+                  "--qc-csv", prompts / "patient_qc.csv", "--seed", args.seed]
+        if args.domain == "mimic_death":
+            icu = require_path(parser, args.mimic_icu_dir, "--mimic-icu-dir")
+            run_stage("mimic_death/build_json_QA_death.py", *common,
+                      "--mimic-icu-dir", icu, "--n-death", args.n_positive,
+                      "--n-alive", args.n_negative, "--require-image-file-exists")
+            prompt_script = "mimic_death/json_prompt_death.py"
+        else:
+            run_stage("mimic_disch/build_json_QA.py", *common,
+                      "--max-pos", args.n_positive, "--max-neg", args.n_negative)
+            prompt_script = "mimic_disch/json_prompt.py"
+        all_prompts = prompts / "all.jsonl"
+        run_stage(prompt_script, "--in-jsonl", raw, "--out-jsonl", all_prompts)
+        run_stage("mimic_death/split_dataset.py", all_prompts,
+                  "--out-dir", prompts, "--seed", args.seed + (args.domain == "mimic_disch"))
+        (prompts / "all_train.jsonl").rename(prompts / "train.jsonl")
+        (prompts / "all_test.jsonl").rename(prompts / "test.jsonl")
+    elif args.domain == "covla":
+        source = require_path(parser, args.source_root, "--source-root")
+        for name in ("states", "front_car", "metadata.jsonl"):
+            require_path(parser, source / name, f"--source-root/{name}")
+        prompts.mkdir()
+        brakes = prompts / "brake_reasons"
+        run_stage("covla/extract_brake_reasons.py", "--root", source, "--output-dir", brakes)
+        enriched = prompts / "enriched.jsonl"
+        run_stage(
+            "covla/enrich_segments.py", "--root", source,
+            "--input", brakes / "all_brake_reasons.jsonl", "--output", enriched,
+            "--sample-output", prompts / "enriched_inspection.jsonl",
+        )
+        all_prompts = prompts / "all.jsonl"
+        run_stage(
+            "covla/build_prompts.py", "--root", source, "--input", enriched,
+            "--output", all_prompts, "--sample-output", prompts / "inspection.jsonl",
+        )
+        run_stage(
+            "covla/split_dataset.py", "--root", source, "--input", all_prompts,
+            "--train-output", prompts / "train.jsonl", "--test-output", prompts / "test.jsonl",
+            "--stats-output", prompts / "split_stats.json", "--seed", args.seed,
+        )
+    elif args.domain == "cuhk_x_har":
+        source = require_path(parser, args.source_root, "--source-root")
+        skeleton = require_path(parser, args.skeleton_root or source / "Skeleton", "--skeleton-root")
+        prompts.mkdir()
+        if args.aligned_jsonl:
+            aligned = require_path(parser, args.aligned_jsonl, "--aligned-jsonl")
+        else:
+            imu = require_path(parser, args.imu_root or source / "IMU", "--imu-root")
+            local_imu = prompts / "IMU"
+            local_skeleton = prompts / "Skeleton"
+            run_stage("cuhk_x_har/xlsx_to_csv.py", "--input-root", imu,
+                      "--output-root", local_imu)
+            run_stage("cuhk_x_har/images_to_video.py", skeleton,
+                      "--output-root", local_skeleton, "--fps", args.fps,
+                      "--split-mode", args.skeleton_crop)
+            aligned = prompts / "imu_skeleton_aligned.jsonl"
+            run_stage("cuhk_x_har/imu_skeleton_to_jsonl.py", "--imu-root", local_imu,
+                      "--skeleton-root", local_skeleton, "--output", aligned)
+        run_stage(
+            "cuhk_x_har/prepare.py", "--root", source, "--input", aligned,
+            "--skeleton-root", skeleton, "--train-output", prompts / "train.jsonl",
+            "--test-output", prompts / "test.jsonl",
+            "--train-sample-output", prompts / "train_inspection.jsonl",
+            "--test-sample-output", prompts / "test_inspection.jsonl", "--seed", args.seed,
+        )
+    elif args.domain == "pixelrec":
+        interactions = require_path(parser, args.interactions, "--interactions")
+        item_info = require_path(parser, args.item_info, "--item-info")
+        images = require_path(parser, args.image_root, "--image-root")
+        prompts.mkdir()
+        run_stage(
+            "pixelrec/prepare.py", "--interactions", interactions, "--item-info", item_info,
+            "--image-root", images, "--output", prompts / f"{args.split}.jsonl",
+            "--limit", args.limit or 0,
+        )
+    elif args.domain == "sp500":
+        prices = require_path(parser, args.time_series_dir, "--time-series-dir")
+        news = require_path(parser, args.news_dir, "--news-dir")
+        images = require_path(parser, args.image_root, "--image-root")
+        prompts.mkdir()
+        run_stage(
+            "sp500/prepare.py", "--time-series-dir", prices, "--news-dir", news,
+            "--image-dir", images, "--out-jsonl", prompts / f"{args.split}.jsonl",
+            "--max-files", args.limit or -1, "--fut-len", args.horizon,
+            "--news-timezone", args.news_timezone,
+        )
+    return prompts / f"{args.split}.jsonl"
+
+
+def main(domain: str) -> None:
+    if domain not in DOMAINS:
+        raise ValueError(f"Unsupported excluded domain: {domain}")
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.set_defaults(domain=domain, input_jsonl=None)
+    parser.add_argument("--output-dir", type=Path, required=True,
+                        help="New private workspace outside MMTA-v1.0; a domain child is created.")
+    if domain != "sp500":
+        parser.add_argument("--input-jsonl", type=Path,
+                            help="Optional existing task prompts to convert.")
+    parser.add_argument("--source-root", type=Path, help="Local source root or base for relative media.")
+    parser.add_argument("--path-map", action="append", default=[], metavar="OLD=NEW")
+    parser.add_argument("--split", choices=("train", "test"), default="test")
+    parser.add_argument("--limit", type=int, help="Maximum converted records; default processes all.")
+    if domain in {"covla", "cuhk_x_har", "mimic_death", "mimic_disch"}:
+        parser.add_argument("--seed", type=int, default=42)
+    if domain in {"covla", "cuhk_x_har"}:
+        parser.add_argument("--num-workers", type=int, default=1)
+    if domain == "cuhk_x_har":
+        parser.add_argument("--aligned-jsonl", type=Path, help="Optional existing aligned IMU/skeleton input.")
+        parser.add_argument("--imu-root", type=Path, help="Defaults to <source-root>/IMU.")
+        parser.add_argument("--skeleton-root", type=Path, help="Skeleton action directory tree.")
+        parser.add_argument("--fps", type=int, default=20)
+        parser.add_argument("--skeleton-crop", choices=("left-half", "auto", "none"), default="left-half")
+    if domain in {"mimic_death", "mimic_disch"}:
+        parser.add_argument("--mimic-hosp-dir", type=Path)
+        parser.add_argument("--mimic-icu-dir", type=Path)
+        parser.add_argument("--mimic-note-dir", type=Path)
+        parser.add_argument("--cxr-metadata-csv", type=Path)
+        parser.add_argument("--cxr-jpg-root", type=Path)
+        events = parser.add_mutually_exclusive_group()
+        events.add_argument("--chartevents", type=Path, help="Raw chartevents.csv or chartevents.csv.gz.")
+        events.add_argument("--chartevents-root", type=Path, help="Existing subject/admission buckets.")
+        parser.add_argument("--chunksize", type=int, default=1000000)
+        parser.add_argument("--n-positive", type=int, default=20 if domain == "mimic_death" else 50)
+        parser.add_argument("--n-negative", type=int, default=130 if domain == "mimic_death" else 100)
+    if domain == "pixelrec":
+        parser.add_argument("--interactions", type=Path)
+        parser.add_argument("--item-info", type=Path)
+        parser.add_argument("--image-root", type=Path)
+    if domain == "sp500":
+        parser.add_argument("--time-series-dir", type=Path)
+        parser.add_argument("--news-dir", type=Path)
+        parser.add_argument("--image-root", "--image-dir", type=Path)
+        parser.add_argument("--horizon", type=int, default=12)
+        parser.add_argument("--news-timezone", default="America/New_York")
+    args = parser.parse_args()
+    if args.limit is not None and args.limit < 1:
+        parser.error("--limit must be positive")
+    if getattr(args, "num_workers", 1) < 1:
+        parser.error("--num-workers must be positive")
+    if getattr(args, "fps", 1) < 1 or getattr(args, "chunksize", 1) < 1:
+        parser.error("--fps and --chunksize must be positive")
+    if domain in {"mimic_death", "mimic_disch"} and (args.n_positive < 0 or args.n_negative < 0):
+        parser.error("--n-positive and --n-negative must be nonnegative")
+    if any("=" not in item for item in args.path_map):
+        parser.error("--path-map must have the form OLD=NEW")
+    output = args.output_dir.expanduser().resolve() / domain
+    if output.is_relative_to(RELEASE):
+        parser.error("Restricted output must be outside MMTA-v1.0")
+    if output.exists():
+        parser.error(f"Output already exists: {output}; choose a new workspace")
+    output.mkdir(parents=True)
+    input_jsonl = build_prompts(args, parser, output)
+    output_jsonl = output / f"{domain}.omnits.jsonl"
+    arguments: list[object] = [
+        "--in-jsonl", input_jsonl, "--out-jsonl", output_jsonl,
+        "--csv-dir", output / "timeseries", "--dataset-name", f"{domain}_{args.split}",
+    ]
+    if args.source_root:
+        arguments.extend(("--source-root", args.source_root.resolve()))
+    for item in args.path_map:
+        arguments.extend(("--path-map", item))
+    if args.limit:
+        arguments.extend(("--limit", args.limit))
+    if domain in IMAGE_DOMAINS:
+        task = "prediction" if domain in {"pixelrec", "sp500"} else "classification"
+        arguments.extend(("--default-task", task))
+        run_stage("common/convert_images.py", *arguments)
+    else:
+        arguments.extend(("--clip-dir", output / "video_clips", "--num-workers", args.num_workers))
+        run_stage("common/convert_videos.py", *arguments)
+
+    # Keep converted assets and relative references local to this private tree.
+    temporary = output_jsonl.with_suffix(".tmp")
+    count = 0
+    with output_jsonl.open(encoding="utf-8") as source, temporary.open("w", encoding="utf-8") as target:
+        for line in source:
+            record = json.loads(line)
+            if "id" not in record:
+                record["id"] = f"{domain}_{args.split}_{Path(record['timeseries_path']).stem}"
+                record.pop("video_id", None)
+            record.setdefault("task", "classification")
+            record.update(domain=domain, split=args.split, variant="original")
+            for field in ("timeseries_path", "video_path", "image_path"):
+                if field not in record:
+                    continue
+                values = record[field] if isinstance(record[field], list) else [record[field]]
+                paths = [os.path.relpath(Path(value).resolve(), output).replace(os.sep, "/") for value in values]
+                record[field] = paths if isinstance(record[field], list) else paths[0]
+            target.write(json.dumps(record, ensure_ascii=False, allow_nan=False) + "\n")
+            count += 1
+    if not count:
+        raise RuntimeError("No local tasks were generated")
+    temporary.replace(output_jsonl)
+    print(json.dumps({"domain": domain, "split": args.split, "records": count,
+                      "output": str(output_jsonl), "path_base": str(output),
+                      "scope": "private_local_reconstruction"}, indent=2))

processing/common/probe.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python3
+"""Standalone CSV shape and ffprobe helpers for the video converter."""
+
+from __future__ import annotations
+
+import csv
+import json
+import subprocess
+from pathlib import Path
+
+
+def probe_ts_shape(path: str) -> tuple[int, int]:
+    with Path(path).open(encoding="utf-8", newline="") as handle:
+        reader = csv.reader(handle)
+        header = next(reader)
+        columns = sum(name.lower() not in {"timestamp", "time", "datetime"} for name in header)
+        return sum(1 for _ in reader), columns
+
+
+def probe_video_meta(path: str) -> tuple[int, int, float, int, float]:
+    result = subprocess.run(
+        ["ffprobe", "-v", "error", "-select_streams", "v:0", "-show_entries",
+         "stream=width,height,avg_frame_rate,nb_frames,duration:format=duration", "-of", "json", path],
+        capture_output=True, text=True, timeout=60, check=True,
+    )
+    data = json.loads(result.stdout)
+    stream = data["streams"][0]
+    numerator, denominator = stream["avg_frame_rate"].split("/")
+    fps = float(numerator) / float(denominator)
+    duration = float(stream.get("duration", data.get("format", {}).get("duration", 0)))
+    frame_count = stream.get("nb_frames", "N/A")
+    frames = int(frame_count) if frame_count != "N/A" else round(duration * fps)
+    return int(stream["width"]), int(stream["height"]), fps, frames, duration

processing/common/test_convert_videos.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+"""Regression tests for distinguishing observed sensor rows from instructions."""
+
+import unittest
+
+from convert_videos import parse_timeseries_block, parse_timeseries_data_line
+
+
+class SensorRowTests(unittest.TestCase):
+    def test_format_example_is_not_an_observation(self) -> None:
+        self.assertIsNone(parse_timeseries_data_line("t(s): speed=, acceleration=, steering="))
+
+    def test_instruction_with_commas_is_not_an_observation(self) -> None:
+        self.assertIsNone(parse_timeseries_data_line("Per-frame sensor data, missing = unavailable:"))
+
+    def test_actual_missing_observations_are_preserved(self) -> None:
+        row = parse_timeseries_data_line("1.5: speed=10, acceleration=null")
+        self.assertEqual(row["speed"], 10)
+        self.assertNotEqual(row["acceleration"], row["acceleration"])
+
+    def test_iso_timestamp_rows_are_still_supported(self) -> None:
+        self.assertEqual(parse_timeseries_data_line("2024-06-30T12:00:00Z, speed=10"), {"speed": 10})
+
+    def test_template_line_does_not_increase_sequence_length(self) -> None:
+        frame = parse_timeseries_block(
+            "<timeseries>\nOne-line format example:\nt(s): speed=, acceleration=\n"
+            "1.0: speed=10, acceleration=null\n1.5: speed=9, acceleration=-1\n</timeseries>"
+        )
+        self.assertEqual(frame.shape, (2, 2))
+        self.assertEqual(frame["speed"].tolist(), [10, 9])
+
+
+if __name__ == "__main__":
+    unittest.main()

processing/download.py

@@ -0,0 +1,265 @@
+#!/usr/bin/env python3
+"""Download original datasets from official sources for local reconstruction.
+
+Run with --dry-run to inspect a download plan. No restricted data are hosted
+by MMTA. Account approval and source agreements must be completed upstream.
+Downloads and private derivatives must remain outside this release tree.
+"""
+
+from __future__ import annotations
+
+import argparse
+import fnmatch
+import hashlib
+import json
+import os
+import shutil
+import subprocess
+import sys
+import urllib.parse
+import urllib.request
+from pathlib import Path, PurePosixPath
+
+
+RELEASE = Path(__file__).resolve().parents[1]
+CUHK_PORTAL = "https://aiot-public-dataset-cuhk-x.cuhkaiot.com"
+HF_REPOS = {
+    "covla": "turing-motors/CoVLA-Dataset",
+    "agibot": "agibot-world/AgiBotWorld2026",
+    "sp500": "Wenyan0110/Multimodal-Dataset-Image_Text_Table_TimeSeries-for-Financial-Time-Series-Forecasting",
+    "terra": "onedean/Terra",
+}
+PIXELREC = {
+    "covers": ("file", "17V70KN6UOAdphNEc0wXlocFwgmI7hVOo", "covers.archive"),
+    "interactions": ("folder", "1vR1lgQUZCy1cuhzPkM2q7AsdYRP43feQ", "interactions"),
+    "item-info": ("folder", "1rXBM-zi5sSdLHNshXWtGgVReWLuYNgDB", "item-info"),
+    "pixel200k": ("file", "1fu0tqCmmXkte5PAsyMo0DQrDS0zofTLH", "Pixel200K.archive"),
+}
+HOLOASSIST = {
+    "videos": "video_compress.tar", "eyes": "eyes.tar", "head": "head.tar", "imu": "imu.tar",
+    "annotations": "data-annotation-trainval-v1_1.json", "splits": "data-splits-v1_2.zip",
+}
+PHYSIONET = {"mimiciv": "3.1", "mimic-cxr-jpg": "2.1.0", "mimic-cxr": "2.1.0", "mimic-iv-note": "2.2"}
+TERRA_PORTAL = "https://hkustgz-my.sharepoint.com/:f:/g/personal/wchen110_connect_hkust-gz_edu_cn/Ev1pUSErKghFkzmXb5j7svgBf2XwMn095VNz1kOOtjhTXA?e=lUCxZb"
+
+
+def relative_path(raw: str) -> str:
+    path = PurePosixPath(raw)
+    if not raw or path.is_absolute() or any(x in {"..", "."} for x in path.parts) or "\\" in raw or ":" in raw or raw != path.as_posix():
+        raise ValueError(f"Expected a normalized relative file path: {raw}")
+    return raw
+
+
+def download_url(url: str, target: Path, expected_sha256: str | None = None) -> None:
+    """Stream a public URL to an atomic file and reject failed/HTML downloads."""
+    target.parent.mkdir(parents=True, exist_ok=True)
+    partial = target.with_name(target.name + ".partial")
+    request = urllib.request.Request(url, headers={"User-Agent": "MMTA-source-downloader/1.0"})
+    digest = hashlib.sha256()
+    received = 0
+    with urllib.request.urlopen(request, timeout=120) as response, partial.open("wb") as handle:
+        content_type = response.headers.get("Content-Type", "").lower()
+        expected_length = response.headers.get("Content-Length")
+        if "text/html" in content_type:
+            raise RuntimeError("The source returned a web/login page. Complete upstream access steps and obtain a file-download URL.")
+        first = True
+        while block := response.read(8 * 1024 * 1024):
+            if first and block.lstrip().lower().startswith((b"<!doctype html", b"<html")):
+                raise RuntimeError("The source returned HTML instead of a data file")
+            first = False
+            digest.update(block)
+            handle.write(block)
+            received += len(block)
+    if not partial.stat().st_size:
+        raise RuntimeError("The download was empty")
+    if expected_length and received != int(expected_length):
+        raise RuntimeError("The source download ended before all advertised bytes were received")
+    if expected_sha256 and digest.hexdigest() != expected_sha256:
+        raise RuntimeError("The downloaded file failed SHA-256 verification")
+    partial.replace(target)
+    print(json.dumps({"file": str(target), "bytes": target.stat().st_size, "sha256": digest.hexdigest()}))
+
+
+def hf_download(args: argparse.Namespace) -> None:
+    repo = HF_REPOS[args.dataset]
+    patterns = args.include or (["*.tar.gz", "*.jsonl", "metadata*", "README.md"] if args.dataset == "covla" else ["*"])
+    if args.dataset == "agibot" and not args.include:
+        patterns = ["task_3641/*", "task_3777/*", "task3641/*", "task3777/*", "README.md"]
+    if args.dry_run:
+        print(json.dumps({"method": "huggingface_hub.snapshot_download", "repo_id": repo, "revision": args.revision,
+                          "allow_patterns": patterns, "output": str(args.output), "token_environment": "HF_TOKEN"}, indent=2))
+        return
+    try:
+        from huggingface_hub import HfApi, snapshot_download
+    except ImportError as exc:
+        raise RuntimeError("Install huggingface-hub from processing/requirements.txt") from exc
+    token = os.environ.get("HF_TOKEN") or None
+    info = HfApi().dataset_info(repo_id=repo, revision=args.revision, token=token)
+    matched = [entry.rfilename for entry in info.siblings if any(fnmatch.fnmatch(entry.rfilename, pattern) for pattern in patterns)]
+    if not matched:
+        raise RuntimeError("No upstream files matched --include")
+    snapshot_download(repo_id=repo, repo_type="dataset", revision=info.sha, local_dir=args.output,
+                      allow_patterns=patterns, token=token, max_workers=args.workers)
+    args.output.mkdir(parents=True, exist_ok=True)
+    (args.output / "download-provenance.json").write_text(json.dumps({"source": repo, "revision": info.sha, "files": matched}, indent=2) + "\n")
+
+
+def pixelrec_download(args: argparse.Namespace) -> None:
+    components = args.component or ["pixel200k"]
+    for name in components:
+        if name not in PIXELREC:
+            raise ValueError(f"PixelRec components: {', '.join(PIXELREC)}")
+        kind, identifier, filename = PIXELREC[name]
+        url = f"https://drive.google.com/{'file/d' if kind == 'file' else 'drive/folders'}/{identifier}"
+        if args.dry_run:
+            print(json.dumps({"component": name, "url": url, "method": "gdown", "output": str(args.output / filename)}))
+            continue
+        try:
+            import gdown
+        except ImportError as exc:
+            raise RuntimeError("Install gdown from processing/requirements.txt") from exc
+        args.output.mkdir(parents=True, exist_ok=True)
+        if kind == "folder":
+            result = gdown.download_folder(url=url, output=str(args.output / filename), quiet=False, remaining_ok=True)
+        else:
+            result = gdown.download(id=identifier, output=str(args.output / filename), quiet=False, resume=True)
+        if not result:
+            raise RuntimeError(f"Official Google Drive download failed for {name}; use the upstream README to obtain access")
+
+
+def mimic_download(args: argparse.Namespace) -> None:
+    if args.physionet_dataset not in PHYSIONET:
+        raise ValueError("Unknown PhysioNet dataset")
+    version = args.version or PHYSIONET[args.physionet_dataset]
+    if not version or any(character not in "0123456789." for character in version):
+        raise ValueError("Expected a numeric PhysioNet version")
+    base = f"https://physionet.org/files/{args.physionet_dataset}/{version}/"
+    paths = list(args.file or [])
+    if args.file_list:
+        paths.extend(line.strip() for line in args.file_list.read_text().splitlines() if line.strip() and not line.lstrip().startswith("#"))
+    if not paths:
+        raise ValueError("Use --file or --file-list to select personally authorized source files; whole medical datasets are not downloaded implicitly")
+    for raw in paths:
+        path = relative_path(raw)
+        url = base + urllib.parse.quote(path, safe="/")
+        command = ["wget", "--continue", "--no-verbose", "--user", args.username or "PHYSIONET_USERNAME", "--ask-password",
+                   "--output-document", str(args.output / args.physionet_dataset / path), url]
+        if args.dry_run:
+            print(json.dumps({"command": command, "access": "PhysioNet credentialing, training and dataset DUA acceptance are required."}))
+            continue
+        if not args.username:
+            raise ValueError("Supply --username or PHYSIONET_USERNAME; the password is requested by wget and is never written to the command line")
+        if not shutil.which("wget"):
+            raise RuntimeError("Install wget to download credentialed PhysioNet files")
+        if not sys.stdin.isatty():
+            raise RuntimeError("Run in a terminal so wget can ask for your PhysioNet password")
+        target = args.output / args.physionet_dataset / path
+        target.parent.mkdir(parents=True, exist_ok=True)
+        subprocess.run(command, check=True)
+        if not target.stat().st_size:
+            raise RuntimeError("PhysioNet returned an empty file")
+
+
+def cuhk_download(args: argparse.Namespace) -> None:
+    files = [relative_path(raw) for raw in args.file or []]
+    if args.list_directory is not None:
+        directory = args.list_directory.strip("/")
+        if directory:
+            directory = relative_path(directory)
+        url = CUHK_PORTAL + "/api/files/" + urllib.parse.quote(directory, safe="/") + ("/" if directory else "")
+        if args.dry_run:
+            print(json.dumps({"listing_url": url}))
+        else:
+            with urllib.request.urlopen(url, timeout=60) as response:
+                print(json.dumps(json.load(response), indent=2))
+        return
+    if not files:
+        raise ValueError("Select official portal files with --file; use --list-directory CUHK-S/HAR to inspect archive names. Complete the upstream DUA first.")
+    for raw in files:
+        url = CUHK_PORTAL + "/data/" + urllib.parse.quote(raw, safe="/")
+        if args.dry_run:
+            print(json.dumps({"url": url, "output": str(args.output / raw)}))
+        else:
+            download_url(url, args.output / raw)
+
+
+def public_download(args: argparse.Namespace) -> None:
+    if args.dataset == "holo_assist":
+        for component in args.component or ["annotations", "splits"]:
+            if component not in HOLOASSIST:
+                raise ValueError(f"HoloAssist components: {', '.join(HOLOASSIST)}")
+            filename = HOLOASSIST[component]
+            base = "https://holoassist.github.io/label_files/" if component == "splits" else "https://hl2data.z5.web.core.windows.net/holoassist-data-release/"
+            if args.dry_run:
+                print(json.dumps({"url": base + filename, "output": str(args.output / filename)}))
+            else:
+                download_url(base + filename, args.output / filename)
+    elif args.dataset == "future_factories":
+        command = ["kaggle", "datasets", "download", "-d", "ramyharik/ff-2024-08-13-multi-modal-dataset-33", "-p", str(args.output)]
+        if args.dry_run:
+            print(json.dumps({"command": command, "version": 1, "note": "Configure your own Kaggle account; this source archive is about 104 GB."}))
+        else:
+            if not shutil.which("kaggle"):
+                raise RuntimeError("Install the Kaggle CLI and configure your own Kaggle credentials")
+            args.output.mkdir(parents=True, exist_ok=True)
+            subprocess.run(command, check=True)
+    elif args.dataset == "terra":
+        if not args.url or not args.filename:
+            print(json.dumps({"official_dataset_folder": TERRA_PORTAL, "next_step": "Use the official folder to obtain a direct file-download URL, then pass --url and --filename."}, indent=2))
+            if not args.dry_run:
+                raise ValueError("Terra's public SharePoint folder is not a file URL. --url and --filename are required for an actual download")
+            return
+        parsed = urllib.parse.urlsplit(args.url)
+        if parsed.scheme != "https" or not parsed.hostname or not (parsed.hostname.endswith(".sharepoint.com") or parsed.hostname.endswith(".1drv.com")):
+            raise ValueError("Use a direct HTTPS file link from Terra's official SharePoint source")
+        name = relative_path(args.filename)
+        if args.dry_run:
+            print(json.dumps({"method": "official SharePoint direct file", "filename": name, "output": str(args.output / name)}))
+        else:
+            download_url(args.url, args.output / name, args.sha256)
+
+
+def main(dataset: str | None = None) -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--dataset", choices=["mimic", "pixelrec", "covla", "cuhk_x_har", "agibot", "sp500", "terra", "future_factories", "holo_assist"], required=dataset is None, default=dataset)
+    parser.add_argument("--output", type=Path, required=True, help="Local source directory outside the public release.")
+    parser.add_argument("--dry-run", action="store_true", help="Print a plan without network access or file writes.")
+    parser.add_argument("--accept-terms", action="store_true", help="Confirm that your own upstream access and source agreement requirements have been completed.")
+    parser.add_argument("--component", action="append", help="Source component to download; repeat as needed.")
+    parser.add_argument("--include", action="append", help="Hugging Face filename pattern; repeat as needed.")
+    parser.add_argument("--revision", default="main", help="Hugging Face revision; the resolved commit is recorded locally.")
+    parser.add_argument("--workers", type=int, default=4)
+    parser.add_argument("--file", action="append", help="Source-relative PhysioNet or CUHK file path.")
+    parser.add_argument("--file-list", type=Path, help="Private file list for PhysioNet, one source-relative path per line.")
+    parser.add_argument("--physionet-dataset", choices=list(PHYSIONET), default="mimiciv")
+    parser.add_argument("--version", help="PhysioNet version (defaults match the original benchmark sources).")
+    parser.add_argument("--username", default=os.environ.get("PHYSIONET_USERNAME"))
+    parser.add_argument("--list-directory", help="List a CUHK official portal directory.")
+    parser.add_argument("--url", help="Direct Terra file URL from the official SharePoint folder.")
+    parser.add_argument("--terra-source", choices=["sharepoint", "huggingface"], default="sharepoint",
+                        help="Terra source: current SharePoint folder or original Hugging Face files. The original repository has no satellite archive.")
+    parser.add_argument("--filename", help="Local Terra download filename.")
+    parser.add_argument("--sha256", help="Optional expected Terra file SHA-256.")
+    args = parser.parse_args()
+    args.output = args.output.expanduser().resolve()
+    if args.output.is_relative_to(RELEASE):
+        parser.error("Raw downloads must be stored outside the MMTA public release directory")
+    if not args.dry_run and not args.accept_terms:
+        parser.error("Complete upstream requirements, then pass --accept-terms; --dry-run needs no access")
+    try:
+        if args.dataset in HF_REPOS and (args.dataset != "terra" or args.terra_source == "huggingface"):
+            hf_download(args)
+        elif args.dataset == "mimic":
+            mimic_download(args)
+        elif args.dataset == "pixelrec":
+            pixelrec_download(args)
+        elif args.dataset == "cuhk_x_har":
+            cuhk_download(args)
+        else:
+            public_download(args)
+    except (ValueError, RuntimeError, OSError, subprocess.CalledProcessError) as exc:
+        raise SystemExit(str(exc)) from exc
+
+
+if __name__ == "__main__":
+    main()

processing/provenance.json

@@ -0,0 +1,184 @@
+{
+  "path_base": "release_root",
+  "revision_date": "2026-10-13",
+  "scope": "Source acquisition and local reconstruction code for six recipe-only domains; no upstream data or generated records included.",
+  "adapted_scripts": [
+    {
+      "script": "processing/common/convert_images.py",
+      "source_label": "common/convert_image_jsonl.py",
+      "source_sha256": "dbaf7a30f6df8c3c61ee2e7225ca4ea15ed407893ffc86877cbabfb2f024e169",
+      "packaged_sha256": "1b9b78e9cbe0dcd700c3f1245ad34ce55bd079a63b7293df1289e1281a56a9bf",
+      "changes": "Portable media roots and prefix remapping; signal shape excludes timestamp columns; blank forecast history values keep their column positions; array fallback includes history only, never future targets. English CLI/docs and source parsing preserved otherwise. Vector reference answers are formatted as comma-separated numerical channels."
+    },
+    {
+      "script": "processing/common/convert_videos.py",
+      "source_label": "common/convert_covla.py",
+      "source_sha256": "a2b82a280ac0ac41be293ad1106b6aee851eea74b4626c0f4f3343bd2e25e4fd",
+      "packaged_sha256": "65a5496d1f8b2bbb859a4db93582bd40e4cbb66322b9e281bd8544cfdc37a54b",
+      "changes": "English documentation and CLI text; portable defaults; standalone media probes and explicit source-path remapping where needed. Timestamp-free template and prose lines are now excluded from sensor observations; ISO-dated and numeric observations remain supported."
+    },
+    {
+      "script": "sample/video-timeseries/covla/extract_brake_reasons.py",
+      "source_label": "covla/extract_brake_reasons.py",
+      "source_sha256": "de74e6b57aa99b205c9499062ab0933649af35e86fa26fceadd58fc4c85e0919",
+      "packaged_sha256": "9a0d6169d95b20560ffcb4346b4de37b3ab52117de6dad979c0ded8ed1fb1203",
+      "changes": "English documentation and CLI text; portable defaults; standalone media probes and explicit source-path remapping where needed."
+    },
+    {
+      "script": "sample/video-timeseries/covla/enrich_segments.py",
+      "source_label": "covla/build_brake_reason_dataset.py",
+      "source_sha256": "56b408dca809580d91852e55246971343ec9dd8f02a004c76c404b438f7a658f",
+      "packaged_sha256": "2183e11568d3cea03c058108e36f1c887bde663a1439bee8e83a6b6617b65428",
+      "changes": "English documentation and CLI text; portable defaults; standalone media probes and explicit source-path remapping where needed."
+    },
+    {
+      "script": "sample/video-timeseries/covla/build_prompts.py",
+      "source_label": "covla/build_prompt_dataset.py",
+      "source_sha256": "c1d7d9260a21e14b9a383b8eb4c32b71f1ca2ae6087f696809b52216859cfb8b",
+      "packaged_sha256": "d3f061e344a92dc4f9ea238eff1db46e83a6be730227bbb47a22cb691fe4be25",
+      "changes": "English documentation and CLI text; portable defaults; standalone media probes and explicit source-path remapping where needed."
+    },
+    {
+      "script": "sample/video-timeseries/covla/split_dataset.py",
+      "source_label": "covla/split_brake_dataset.py",
+      "source_sha256": "b12976b11ff095dc44d573ceb8cc99a9350a01172b33f13088559ec5b722f9f7",
+      "packaged_sha256": "a81a76c1d8b6e53b7df7113155004513e3398451b3a08604d44d974f02f04349",
+      "changes": "English documentation and CLI text; portable defaults; standalone media probes and explicit source-path remapping where needed."
+    },
+    {
+      "script": "sample/image-timeseries/sp500/prepare.py",
+      "source_label": "sp500/build_jsonl_forcast_withoutpng.py",
+      "source_sha256": "b9901e8ecc46e8bf74826d609dc051003adceebdfe8505c4fd255a64f04510ba",
+      "packaged_sha256": "12a63395c73d6d300bfaa91acc2b908acd76d930889793490e98b2049305ba6f",
+      "changes": "English CLI/docs and portable roots. The first-half-2024 price history and target horizon remain. News selection was corrected: mandatory forecast-day cutoff in a documented timezone, valid source ISO Date required, strict pre-cutoff filtering, chronological latest-three selection and per-record selection metadata."
+    },
+    {
+      "script": "sample/video-timeseries/cuhk_x_har/prepare.py",
+      "source_label": "cuhk_x_har/build_cuhkx_action_prompt_jsonl.py",
+      "source_sha256": "2c96996a7ba25588c1b7a01a1322cca7a4dc3e2b814921b3130447dfe3a0bb96",
+      "packaged_sha256": "ad086660e0dbad56b94a359cb5436007c7e73ecc87eef96d993ebfd5f7baf628",
+      "changes": "English documentation and CLI text; portable defaults; standalone media probes and explicit source-path remapping where needed.",
+      "source_location": "original_dataset_directory"
+    },
+    {
+      "script": "sample/image-timeseries/pixelrec/prepare.py",
+      "source_label": "PixelRec/build_day.py",
+      "source_sha256": "d5712923fa7323ff16e2f0bcf5a3a7d803ec424f5011fd89b7a71df6f9096883",
+      "changes": "Refactored daily longest-consecutive-segment forecasting as a CLI; English documentation, explicit input paths, deterministic item traversal and required image checks. Original translated metadata and exact split membership are not asserted to be reproduced.",
+      "packaged_sha256": "913bb0bfaedffe0ee13d56cd762aa6b5556149abc95670d92e2110fa65cb6df9"
+    },
+    {
+      "script": "sample/image-timeseries/mimic_death/build_json_QA_death.py",
+      "source_label": "mimic/python/build_json_QA_death.py",
+      "source_sha256": "ad0e50d4cbd0bfcb93ff1582828b5b11e38313e96063d7915079ff25f11264d7",
+      "source_location": "original_dataset_directory",
+      "changes": "Portable CLI paths, compressed inputs, English code and JSON-safe values; original patient and encounter joins, temporal windows and labels retained. Image fields are consistent and record IDs are unique. Mortality stays are not duplicated to fill quotas.",
+      "packaged_sha256": "6290dd36fab73fa91644135e7f46bff9f3a5e3b94e9fda3b275125abdadd23f8"
+    },
+    {
+      "script": "sample/image-timeseries/mimic_death/json_prompt_death.py",
+      "source_label": "mimic/python/json_prompt_death.py",
+      "source_sha256": "8e4acc9c8ba64faf0c225777dc9433c80a1afd11f504d962576ea87e1695737e",
+      "source_location": "original_dataset_directory",
+      "changes": "Portable CLI paths, compressed inputs, English code and JSON-safe values; original patient and encounter joins, temporal windows and labels retained. Image fields are consistent and record IDs are unique. Mortality stays are not duplicated to fill quotas.",
+      "packaged_sha256": "71cd42b2b8c01f5d79c1fd7ec35fcb07eb44080d978ffa18a3ee3de6d3df20fa"
+    },
+    {
+      "script": "sample/image-timeseries/mimic_disch/build_json_QA.py",
+      "source_label": "mimic/python/build_json_QA.py",
+      "source_sha256": "6adc0f28ce7554509dfef980db5b56390405dc2228a0d36580194c94219a36d6",
+      "source_location": "original_dataset_directory",
+      "changes": "Portable CLI paths, compressed inputs, English code and JSON-safe values; original patient and encounter joins, temporal windows and labels retained. Image fields are consistent and record IDs are unique. Mortality stays are not duplicated to fill quotas.",
+      "packaged_sha256": "84c2fd9807a0eef8ff30e5893d558869c2acf4fcd08ea0d4898f5a63fdbad0cf"
+    },
+    {
+      "script": "sample/image-timeseries/mimic_disch/json_prompt.py",
+      "source_label": "mimic/python/json_prompt.py",
+      "source_sha256": "f027f60a90b2235b2d1645f831510301e03feb43051552ce835a7970b3061f35",
+      "source_location": "original_dataset_directory",
+      "changes": "Portable CLI paths, compressed inputs, English code and JSON-safe values; original patient and encounter joins, temporal windows and labels retained. Image fields are consistent and record IDs are unique. Mortality stays are not duplicated to fill quotas.",
+      "packaged_sha256": "6fe8b8c53cb8fb998b9c1aad9f0a8348a59ba72b742a2efe28d0574f1a3b4c88"
+    },
+    {
+      "script": "sample/image-timeseries/mimic_death/split_dataset.py",
+      "source_label": "mimic/python/split_jsonl_train_test_stratified.py",
+      "source_sha256": "4870fe3ec136d0236ef84c9cca2e91d25e32fa521715fd2e09ff3bcdf49dca37",
+      "source_location": "original_dataset_directory",
+      "changes": "Portable CLI paths, compressed inputs, English code and JSON-safe values; original patient and encounter joins, temporal windows and labels retained. Image fields are consistent and record IDs are unique. Mortality stays are not duplicated to fill quotas.",
+      "packaged_sha256": "f7f7586d6b8dbca9ef795f17964346eac46c90504890d8f2a39db37be2546f8c"
+    },
+    {
+      "script": "sample/video-timeseries/cuhk_x_har/imu_skeleton_to_jsonl.py",
+      "source_label": "cuhk-x/imu_skeleton_to_jsonl.py",
+      "source_sha256": "6ef1638d2c33497a04a9af2e2755ea74d949ec69f1f13dc12b908ec40bd7da6b",
+      "source_location": "original_dataset_directory",
+      "changes": "Portable CLI paths and English code; original trial matching, stream selection, per-second sampling and 20 fps rendering retained. Generated tables and videos are written to a separate output tree. Original column names are supported through Unicode aliases.",
+      "packaged_sha256": "901019d61c74640dd96263e5fb781d2f5f43cd3eb2121f1beb4ebae0c0e9394a"
+    },
+    {
+      "script": "sample/video-timeseries/cuhk_x_har/images_to_video.py",
+      "source_label": "cuhk-x/images_to_video_20fps.py",
+      "source_sha256": "c0cf7f251ea3b2b9227b9443b0aaf88970ce33cc548ad9a589792b49821ee095",
+      "source_location": "original_dataset_directory",
+      "changes": "Portable CLI paths and English code; original trial matching, stream selection, per-second sampling and 20 fps rendering retained. Generated tables and videos are written to a separate output tree. Original column names are supported through Unicode aliases.",
+      "packaged_sha256": "1c83937ceebeebaa83795c96359612f907d2a26a70e3841ba5ff4ec115293bd0"
+    },
+    {
+      "script": "sample/image-timeseries/mimic_death/bucket_chartevents.py",
+      "source_label": "mimic/python/csv_split.py",
+      "source_sha256": "fd782af054c35389fd407ada022d479562ed5d90b64abfb92a1d608800fe233f",
+      "source_location": "original_dataset_directory",
+      "changes": "Explicit chartevents input replaces the original labevents default; stream subject/admission grouping to a new output tree and retain the five columns used by the task builders.",
+      "packaged_sha256": "54de1a5ab6255166a87ca376adf1dd1c9f06ed275a22d73ed5ba44802de9f3d1"
+    },
+    {
+      "script": "sample/video-timeseries/cuhk_x_har/xlsx_to_csv.py",
+      "source_label": "cuhk-x/xlsx_to_csv.py",
+      "source_sha256": "82eef22f3a0962ec353d81bd24f924fd8ce631f7597bd1440eed9771171f1bcb",
+      "source_location": "original_dataset_directory",
+      "changes": "Portable CLI paths and English code; original trial matching, stream selection, per-second sampling and 20 fps rendering retained. Generated tables and videos are written to a separate output tree. Original column names are supported through Unicode aliases.",
+      "packaged_sha256": "06b68b5b53c91cd17d6d1bc49590b73e7addff2dc9499c48732ae36e31c1d54a"
+    }
+  ],
+  "new_scripts": [
+    "processing/common/local_generation.py",
+    "processing/common/probe.py",
+    "processing/common/test_convert_videos.py",
+    "processing/download.py",
+    "sample/image-timeseries/mimic_death/download.py",
+    "sample/image-timeseries/mimic_death/generate.py",
+    "sample/image-timeseries/mimic_death/source_tables.py",
+    "sample/image-timeseries/mimic_disch/download.py",
+    "sample/image-timeseries/mimic_disch/generate.py",
+    "sample/image-timeseries/pixelrec/download.py",
+    "sample/image-timeseries/pixelrec/generate.py",
+    "sample/image-timeseries/sp500/download.py",
+    "sample/image-timeseries/sp500/generate.py",
+    "sample/image-timeseries/sp500/test_news_cutoff.py",
+    "sample/video-timeseries/covla/download.py",
+    "sample/video-timeseries/covla/generate.py",
+    "sample/video-timeseries/cuhk_x_har/download.py",
+    "sample/video-timeseries/cuhk_x_har/generate.py"
+  ],
+  "new_script_hashes": {
+    "processing/common/local_generation.py": "af00dadb5c8e4426eebae3f48d4420f4107ff9df30041fffb5348751d19352de",
+    "processing/common/probe.py": "55aae997c410d00574796cc289873cba655dec1b603447c7555341892c98bfff",
+    "processing/common/test_convert_videos.py": "f76ecfdde59cd94fca6e541df3a4ef58479dcf9e8f9007c91f641f0f81dfe4ac",
+    "processing/download.py": "043037ca6338af10da9bc764c5310497e48337696a95221b023c17aba20c8786",
+    "sample/image-timeseries/mimic_death/download.py": "74a57466a27215b53929c6b77f3ce2aa8a53685e20cdd635b4990373be7c4ad3",
+    "sample/image-timeseries/mimic_death/generate.py": "feeb788569344338789e3c59247943317a4b77331ea566115bc8a893518e6f8f",
+    "sample/image-timeseries/mimic_death/source_tables.py": "d4528e9a9eec1e1e9e2c69f736492d4b2fa91f5856da96940c6a0d40255dae81",
+    "sample/image-timeseries/mimic_disch/download.py": "74a57466a27215b53929c6b77f3ce2aa8a53685e20cdd635b4990373be7c4ad3",
+    "sample/image-timeseries/mimic_disch/generate.py": "484c4b62831722adcc325d03f6f143af27f2c7d5344ec038be67b55ac1c28ac6",
+    "sample/image-timeseries/pixelrec/download.py": "1ae7b74455119f3ba7c9ba791136c3b81608949f7d80fdb33f110ee0fa9e81ea",
+    "sample/image-timeseries/pixelrec/generate.py": "93eb4357d97652199487d5ccc9e607b3ecaf321d1d182139717f36e299466a70",
+    "sample/image-timeseries/sp500/download.py": "262e885f1d468e661aadae2b02f2ad65b0f441459c2f5ea610487e1972612000",
+    "sample/image-timeseries/sp500/generate.py": "de3c90d97492d158a24fb19d06c17840b1ed271af893b3eaaeb28ce4b7b92b6c",
+    "sample/image-timeseries/sp500/test_news_cutoff.py": "609489ed7ac2c27cfdc963e12c226ee202b11cf955c053c5cec37ddf892cb0f7",
+    "sample/video-timeseries/covla/download.py": "2fc4a588c292adabf5a5581a9f319005473b830a9991899b4950f2bd5ba14bb2",
+    "sample/video-timeseries/covla/generate.py": "b135bac2c71c3389a3859356a03eff2734095fcd753cc8f0633fd222ee913407",
+    "sample/video-timeseries/cuhk_x_har/download.py": "84c5093a46b38518b33fd1d880a957809ac00b547a956b9181fa5213c0277de7",
+    "sample/video-timeseries/cuhk_x_har/generate.py": "16f8f14216371bc3b3522af7e9edc67063354e706fee6a10980ca40949eebca9"
+  },
+  "local_generation_note": "Excluded-domain recipes are in sample/<modality>/<domain>/. MIMIC patient joins, labels, prompts and splitting and CUHK-X raw IMU/skeleton alignment use original source scripts. SP500 requires source-dated news strictly before the forecast-day cutoff."
+}

processing/requirements.txt

@@ -0,0 +1,10 @@
+numpy>=1.23
+pandas>=1.5
+Pillow>=9
+opencv-python-headless>=4.7
+pyarrow>=12
+jsonschema>=4.18
+huggingface-hub>=0.24
+gdown>=5.2
+openpyxl>=3.1
+xlrd>=2.0

sample/image-timeseries/mimic_death/README.md

@@ -0,0 +1,27 @@
+# MIMIC mortality
+
+**Processing code only:** source data and generated task records are not
+included. Obtain the sources with your own approved access and follow their
+terms. See the [shared setup instructions](../../../processing/README.md).
+Run the commands below from the directory containing `MMTA-v1.0/`, keeping
+`local_sources/` and `local_work/` outside the release folder.
+
+Download MIMIC-IV 3.1, MIMIC-IV-Note 2.2 and MIMIC-CXR-JPG 2.1.0 from [PhysioNet](https://physionet.org/) using your approved account. Required tables: patients, admissions, chartevents, radiology and CXR metadata; mortality also needs icustays. `download.py` accepts `--file` or `--file-list` for each selected source.
+
+```bash
+python -B MMTA-v1.0/sample/image-timeseries/mimic_death/download.py \
+  --output local_sources/mimic --physionet-dataset mimiciv \
+  --file icu/chartevents.csv.gz --username YOUR_USERNAME --accept-terms
+python -B MMTA-v1.0/sample/image-timeseries/mimic_death/generate.py \
+  --mimic-hosp-dir local_sources/mimic/mimiciv/hosp \
+  --mimic-icu-dir local_sources/mimic/mimiciv/icu \
+  --mimic-note-dir local_sources/mimic/mimic-iv-note/note \
+  --cxr-metadata-csv local_sources/mimic/mimic-cxr-jpg/mimic-cxr-2.0.0-metadata.csv.gz \
+  --cxr-jpg-root local_sources/mimic/mimic-cxr-jpg/files \
+  --chartevents local_sources/mimic/mimiciv/icu/chartevents.csv.gz \
+  --output-dir local_work/mimic_death_build
+```
+
+Join ICU stays, admissions, radiology reports and same-day chest images. Use the first 48 hours after ICU admission, exclude deaths during the observation window, and label later in-hospital deaths (20 positive / 130 negative). The command buckets raw vitals, constructs labels and prompts, makes a 50/50 stratified split, and exports image/CSV records. Existing buckets can be supplied with `--chartevents-root`.
+
+Output: `--output-dir/mimic_death/mimic_death.omnits.jsonl`, with `timeseries/` and intermediate train/test JSONL. Images stay in the source tree; paths are relative to the output domain directory. `--split train` selects the training output.

sample/image-timeseries/mimic_death/bucket_chartevents.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+"""Split raw MIMIC chartevents into subject/admission CSV buckets."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+import pandas as pd
+
+
+def split_chartevents_by_subject_hadm(
+    chartevents_csv: Path,
+    output_root: Path,
+    chunksize: int = 1000000,
+) -> None:
+    """Adapt the original csv_split.py grouping to an explicit input path."""
+    if output_root.exists():
+        raise ValueError(f"Choose a new bucket directory: {output_root}")
+    output_root.mkdir(parents=True)
+    columns = ["subject_id", "hadm_id", "charttime", "itemid", "valuenum"]
+    reader = pd.read_csv(
+        chartevents_csv,
+        usecols=columns,
+        chunksize=chunksize,
+        dtype={"subject_id": "Int64", "hadm_id": "Int64"},
+        low_memory=False,
+    )
+    for index, chunk in enumerate(reader, 1):
+        chunk = chunk.dropna(subset=["subject_id", "hadm_id"])
+        for (subject, admission), rows in chunk.groupby(
+            ["subject_id", "hadm_id"], sort=False
+        ):
+            directory = output_root / str(int(subject)) / str(int(admission))
+            directory.mkdir(parents=True, exist_ok=True)
+            target = directory / "chartevents.csv"
+            rows.to_csv(target, index=False, mode="a", header=not target.exists())
+        print(f"Processed chunk {index}: {len(chunk)} rows")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--input", type=Path, required=True)
+    parser.add_argument("--output-root", type=Path, required=True)
+    parser.add_argument("--chunksize", type=int, default=1000000)
+    args = parser.parse_args()
+    if args.chunksize < 1:
+        parser.error("--chunksize must be positive")
+    split_chartevents_by_subject_hadm(args.input, args.output_root, args.chunksize)
+
+
+if __name__ == "__main__":
+    main()

sample/image-timeseries/mimic_death/build_json_QA_death.py

@@ -0,0 +1,572 @@
+#!/usr/bin/env python3
+"""Adapted from the original dataset construction script."""
+
+import argparse
+import os
+import json
+import random
+from datetime import timedelta
+from typing import Dict, List, Optional, Tuple, Any
+import pandas as pd
+import sys
+from pathlib import Path
+
+sys.dont_write_bytecode = True
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "mimic_death"))
+from source_tables import json_safe, study_date, table_path
+
+FIXED_VITAL_ITEMIDS = {
+    220045: "heart_rate_bpm",
+    220210: "resp_rate_insp_per_min",
+    220277: "spo2_percent",
+    223762: "temp_c",
+    220179: "nbp_systolic_mmhg",
+    220180: "nbp_diastolic_mmhg",
+}
+
+
+def parse_args():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--mimic_hosp_dir", "--mimic-hosp-dir", required=True)
+    ap.add_argument("--mimic_icu_dir", "--mimic-icu-dir", required=True)
+    ap.add_argument("--mimic_note_dir", "--mimic-note-dir", required=True)
+    ap.add_argument("--cxr_metadata_csv", "--cxr-metadata-csv", required=True)
+    ap.add_argument("--cxr_jpg_root", "--cxr-jpg-root", required=True)
+    ap.add_argument(
+        "--chartevents_root",
+        "--chartevents-root",
+        help="Bucketed chartevents root: <root>/<subject_id>/<hadm_id>/chartevents.csv",
+        required=True,
+    )
+    ap.add_argument("--out_jsonl", "--out-jsonl", required=True)
+    ap.add_argument("--qc_csv", "--qc-csv", required=True)
+    ap.add_argument("--seed", type=int, default=42)
+    ap.add_argument("--window_hours", "--window-hours", type=int, default=48)
+    ap.add_argument("--n_death", "--n-death", type=int, default=20)
+    ap.add_argument("--n_alive", "--n-alive", type=int, default=130)
+    ap.add_argument("--max_notes_per_stay", "--max-notes-per-stay", type=int, default=3)
+    ap.add_argument(
+        "--max_images_per_stay", "--max-images-per-stay", type=int, default=4
+    )
+    ap.add_argument("--image_day_slack", "--image-day-slack", type=int, default=0)
+    ap.add_argument("--k_per_var", "--k-per-var", type=int, default=16)
+    ap.add_argument(
+        "--require_image_file_exists",
+        "--require-image-file-exists",
+        action="store_true",
+    )
+    ap.add_argument(
+        "--max_passes_over_pool", "--max-passes-over-pool", type=int, default=3
+    )
+    return ap.parse_args()
+
+
+def to_date_str_yyyy_mm_dd_from_studydate(x) -> Optional[str]:
+    return study_date(x)
+
+
+def subject_folder(subject_id: int) -> str:
+    s = str(int(subject_id))
+    return f"p{s[:2]}"
+
+
+def build_jpg_path(
+    cxr_jpg_root: str, subject_id: int, study_id: int, dicom_id: str
+) -> str:
+    return os.path.abspath(
+        os.path.join(
+            cxr_jpg_root,
+            subject_folder(subject_id),
+            f"p{int(subject_id)}",
+            f"s{int(study_id)}",
+            f"{dicom_id}.jpg",
+        )
+    )
+
+
+def load_radiology_rr_notes(note_dir: str) -> pd.DataFrame:
+    path = table_path(note_dir, "radiology.csv")
+    r = pd.read_csv(path)
+    r = r[r["note_type"].astype(str).eq("RR")].copy()
+    r["charttime"] = pd.to_datetime(r["charttime"], errors="coerce")
+    r = r[r["charttime"].notna()].copy()
+    r = r[r["text"].notna()].copy()
+    r = r[r["hadm_id"].notna()].copy()
+    r["subject_id"] = r["subject_id"].astype(int)
+    r["hadm_id"] = r["hadm_id"].astype(int)
+    r["note_date"] = r["charttime"].dt.date.astype(str)
+    return r
+
+
+def load_cxr_metadata(meta_csv: str) -> pd.DataFrame:
+    m = pd.read_csv(meta_csv)
+    missing = {"dicom_id", "subject_id", "study_id", "StudyDate"} - set(m.columns)
+    if missing:
+        raise RuntimeError(f"metadata missing required columns: {missing}")
+    m["subject_id"] = m["subject_id"].astype(int)
+    m["study_id"] = m["study_id"].astype(int)
+    m["dicom_id"] = m["dicom_id"].astype(str)
+    m["study_date"] = m["StudyDate"].apply(to_date_str_yyyy_mm_dd_from_studydate)
+    return m
+
+
+def load_patients(hosp_dir: str) -> Dict[int, Dict]:
+    path = table_path(hosp_dir, "patients.csv")
+    p = pd.read_csv(
+        path,
+        usecols=lambda c: c
+        in {"subject_id", "gender", "anchor_age", "anchor_year", "anchor_year_group"},
+    )
+    p["subject_id"] = p["subject_id"].astype(int)
+    return p.set_index("subject_id").to_dict(orient="index")
+
+
+def load_admissions_df(hosp_dir: str) -> pd.DataFrame:
+    path = table_path(hosp_dir, "admissions.csv")
+    cols = {
+        "subject_id",
+        "hadm_id",
+        "admittime",
+        "dischtime",
+        "deathtime",
+        "admission_type",
+        "insurance",
+        "language",
+        "marital_status",
+        "race",
+        "hospital_expire_flag",
+    }
+    a = pd.read_csv(path, usecols=lambda c: c in cols)
+    a["subject_id"] = a["subject_id"].astype(int)
+    a["hadm_id"] = a["hadm_id"].astype(int)
+    a["admittime"] = pd.to_datetime(a["admittime"], errors="coerce")
+    a["dischtime"] = pd.to_datetime(a["dischtime"], errors="coerce")
+    a["deathtime"] = pd.to_datetime(a["deathtime"], errors="coerce")
+    a = a[a["admittime"].notna() & a["dischtime"].notna()].copy()
+    return a
+
+
+def load_icustays_df(icu_dir: str) -> pd.DataFrame:
+    path = table_path(icu_dir, "icustays.csv")
+    cols = {
+        "subject_id",
+        "hadm_id",
+        "stay_id",
+        "intime",
+        "outtime",
+        "first_careunit",
+        "last_careunit",
+    }
+    icu = pd.read_csv(path, usecols=lambda c: c in cols)
+    icu["subject_id"] = icu["subject_id"].astype(int)
+    icu["hadm_id"] = icu["hadm_id"].astype(int)
+    icu["stay_id"] = icu["stay_id"].astype(int)
+    icu["intime"] = pd.to_datetime(icu["intime"], errors="coerce")
+    icu["outtime"] = pd.to_datetime(icu["outtime"], errors="coerce")
+    icu = icu[icu["intime"].notna()].copy()
+    return icu
+
+
+def match_images_for_note_relaxed(
+    note_row: Dict[str, Any],
+    cxr_by_subject: Dict[int, pd.DataFrame],
+    cxr_jpg_root: str,
+    day_slack: int = 1,
+    require_exists: bool = False,
+) -> Tuple[List[str], List[Dict[str, Any]]]:
+    sid = int(note_row["subject_id"])
+    note_date = pd.to_datetime(str(note_row["note_date"])).date()
+    subm = cxr_by_subject.get(sid)
+    if subm is None or subm.empty:
+        return ([], [])
+    ok_dates = set(
+        (
+            (note_date + timedelta(days=d)).isoformat()
+            for d in range(-day_slack, day_slack + 1)
+        )
+    )
+    matched = subm[subm["study_date"].isin(ok_dates)].copy()
+    if matched.empty:
+        return ([], [])
+    matched = matched.drop_duplicates(["study_id", "dicom_id"])
+    images, metas = ([], [])
+    for _, r in matched.iterrows():
+        jpg = build_jpg_path(cxr_jpg_root, sid, int(r["study_id"]), str(r["dicom_id"]))
+        if require_exists and (not os.path.exists(jpg)):
+            continue
+        images.append(jpg)
+        metas.append(
+            {
+                "dicom_id": str(r["dicom_id"]),
+                "study_id": int(r["study_id"]),
+                "StudyDate": r.get("StudyDate"),
+                "StudyTime": r.get("StudyTime"),
+                "ViewPosition": r.get("ViewPosition"),
+            }
+        )
+    return (images, metas)
+
+
+def iter_chartevents_window(
+    chartevents_root: str,
+    subject_id: int,
+    hadm_id: int,
+    itemids: set,
+    t_start: pd.Timestamp,
+    t_end: pd.Timestamp,
+    chunksize: int = 200000,
+    filename: str = "chartevents.csv",
+) -> pd.DataFrame:
+    p = os.path.join(
+        chartevents_root, str(int(subject_id)), str(int(hadm_id)), filename
+    )
+    usecols = ["charttime", "itemid", "valuenum"]
+    if not os.path.exists(p):
+        return pd.DataFrame(columns=["charttime", "itemid", "valuenum"])
+    out = []
+    for chunk in pd.read_csv(
+        p, usecols=lambda c: c in set(usecols), chunksize=chunksize
+    ):
+        if "itemid" not in chunk.columns:
+            continue
+        chunk = chunk[chunk["itemid"].isin(itemids)].copy()
+        if chunk.empty:
+            continue
+        chunk["charttime"] = pd.to_datetime(chunk["charttime"], errors="coerce")
+        chunk = chunk[chunk["charttime"].notna()].copy()
+        chunk = chunk[
+            (chunk["charttime"] >= t_start) & (chunk["charttime"] <= t_end)
+        ].copy()
+        if chunk.empty:
+            continue
+        chunk["valuenum"] = pd.to_numeric(chunk["valuenum"], errors="coerce")
+        chunk = chunk[chunk["valuenum"].notna()].copy()
+        if chunk.empty:
+            continue
+        out.append(chunk[["charttime", "itemid", "valuenum"]])
+    if not out:
+        return pd.DataFrame(columns=["charttime", "itemid", "valuenum"])
+    df = pd.concat(out, ignore_index=True)
+    df = df.sort_values("charttime")
+    return df
+
+
+def take_last_k_per_var(
+    df: pd.DataFrame, itemid_to_var: Dict[int, str], k: int
+) -> Dict[str, List[Dict[str, Any]]]:
+    out: Dict[str, List[Dict[str, Any]]] = {v: [] for v in itemid_to_var.values()}
+    if df.empty:
+        return out
+    df = df.copy()
+    df["var"] = df["itemid"].map(itemid_to_var)
+    df = df[df["var"].notna()].copy()
+    for v in out.keys():
+        sub = df[df["var"] == v].sort_values("charttime")
+        if sub.empty:
+            continue
+        sub = sub.tail(k)
+        out[v] = [
+            {"t": t.isoformat(), "v": float(val)}
+            for (t, val) in zip(sub["charttime"], sub["valuenum"])
+        ]
+    return out
+
+
+def build_sample_for_stay(
+    stay_row: Dict[str, Any],
+    notes_grouped: Dict[Tuple[int, int], pd.DataFrame],
+    cxr_by_subject: Dict[int, pd.DataFrame],
+    patients_map: Dict[int, Dict],
+    args,
+    itemids: set,
+    itemid_to_var: Dict[int, str],
+) -> Tuple[Optional[Dict[str, Any]], str, Dict[str, Any]]:
+    sid = int(stay_row["subject_id"])
+    hadm_id = int(stay_row["hadm_id"])
+    stay_id = int(stay_row["stay_id"])
+    t0 = pd.to_datetime(stay_row["t0"])
+    t1 = pd.to_datetime(stay_row["t1"])
+    label = int(stay_row["label_death_in_hosp"])
+    g = notes_grouped.get((sid, hadm_id))
+    if g is None or g.empty:
+        return (None, "NO_NOTE_FOR_ADMISSION", {})
+    notes_win = g[(g["charttime"] >= t0) & (g["charttime"] <= t1)].copy()
+    if notes_win.empty:
+        return (None, "NO_NOTE_IN_WINDOW", {})
+    notes_win = notes_win.sort_values("charttime").head(args.max_notes_per_stay)
+    kept_notes: List[Dict[str, Any]] = []
+    all_images: List[str] = []
+    all_image_meta: List[Dict[str, Any]] = []
+    for _, nr in notes_win.iterrows():
+        note_row = nr.to_dict()
+        kept_notes.append(
+            {
+                "charttime": pd.to_datetime(nr["charttime"]).isoformat(),
+                "note_date": str(nr["note_date"]),
+                "text": str(nr["text"]),
+                "note_type": str(nr.get("note_type", "RR")),
+            }
+        )
+        imgs, metas = match_images_for_note_relaxed(
+            note_row,
+            cxr_by_subject=cxr_by_subject,
+            cxr_jpg_root=args.cxr_jpg_root,
+            day_slack=args.image_day_slack,
+            require_exists=args.require_image_file_exists,
+        )
+        if imgs:
+            all_images.extend(imgs)
+            all_image_meta.extend(metas)
+    seen = set()
+    uniq_images, uniq_meta = ([], [])
+    for img, meta in zip(all_images, all_image_meta):
+        if img in seen:
+            continue
+        seen.add(img)
+        uniq_images.append(img)
+        uniq_meta.append(meta)
+    uniq_images = uniq_images[: args.max_images_per_stay]
+    uniq_meta = uniq_meta[: args.max_images_per_stay]
+    if not kept_notes:
+        return (None, "NO_NOTE_AFTER_FILTER", {})
+    if not uniq_images:
+        return (None, "NO_IMAGE_MATCHED", {"n_notes": len(kept_notes)})
+    ce = iter_chartevents_window(
+        chartevents_root=args.chartevents_root,
+        subject_id=sid,
+        hadm_id=hadm_id,
+        itemids=itemids,
+        t_start=t0,
+        t_end=t1,
+        chunksize=200000,
+    )
+    vitals = take_last_k_per_var(ce, itemid_to_var, k=args.k_per_var)
+    n_nonempty_vars = sum((1 for v in vitals.keys() if len(vitals[v]) > 0))
+    if n_nonempty_vars < 1:
+        return (
+            None,
+            "ALL_VITALS_EMPTY",
+            {"n_notes": len(kept_notes), "n_images": len(uniq_images)},
+        )
+    pat = patients_map.get(sid, {})
+    sample = {
+        "subject_id": sid,
+        "hadm_id": hadm_id,
+        "stay_id": stay_id,
+        "icu_intime": (
+            pd.to_datetime(stay_row["intime"]).isoformat()
+            if pd.notna(stay_row.get("intime"))
+            else None
+        ),
+        "icu_outtime": (
+            pd.to_datetime(stay_row["outtime"]).isoformat()
+            if pd.notna(stay_row.get("outtime"))
+            else None
+        ),
+        "window_start": t0.isoformat(),
+        "window_end": t1.isoformat(),
+        "window_hours": float(args.window_hours),
+        "label_death_in_hosp": label,
+        "admission": {
+            "admittime": (
+                pd.to_datetime(stay_row["admittime"]).isoformat()
+                if pd.notna(stay_row.get("admittime"))
+                else None
+            ),
+            "dischtime": (
+                pd.to_datetime(stay_row["dischtime"]).isoformat()
+                if pd.notna(stay_row.get("dischtime"))
+                else None
+            ),
+            "deathtime": (
+                pd.to_datetime(stay_row["deathtime"]).isoformat()
+                if pd.notna(stay_row.get("deathtime"))
+                else None
+            ),
+            "hospital_expire_flag": (
+                int(stay_row["hospital_expire_flag"])
+                if pd.notna(stay_row.get("hospital_expire_flag"))
+                else None
+            ),
+        },
+        "notes_rr_in_window": kept_notes,
+        "images_path": uniq_images,
+        "image_meta": uniq_meta,
+        "vitals_in_window": vitals,
+        "stats": {
+            "n_notes": len(kept_notes),
+            "n_images": len(uniq_images),
+            "n_vital_vars_nonempty": int(n_nonempty_vars),
+        },
+    }
+    return (
+        sample,
+        "OK",
+        {
+            "n_notes": len(kept_notes),
+            "n_images": len(uniq_images),
+            "n_vital_vars_nonempty": int(n_nonempty_vars),
+        },
+    )
+
+
+def main():
+    args = parse_args()
+    random.seed(args.seed)
+    patients_map = load_patients(args.mimic_hosp_dir)
+    adm_df = load_admissions_df(args.mimic_hosp_dir)
+    icu_df = load_icustays_df(args.mimic_icu_dir)
+    notes_df = load_radiology_rr_notes(args.mimic_note_dir)
+    cxr_meta = load_cxr_metadata(args.cxr_metadata_csv)
+    cxr_by_subject = {sid: df for (sid, df) in cxr_meta.groupby("subject_id")}
+    itemid_to_var = dict(FIXED_VITAL_ITEMIDS)
+    itemids = set(itemid_to_var.keys())
+    stays = icu_df.merge(adm_df, on=["subject_id", "hadm_id"], how="inner").copy()
+    stays["t0"] = stays["intime"]
+    stays["t1"] = stays["intime"] + pd.Timedelta(hours=float(args.window_hours))
+    mask_die_le_48h = (
+        stays["deathtime"].notna()
+        & (stays["deathtime"] >= stays["t0"])
+        & (stays["deathtime"] <= stays["t1"])
+    )
+    stays = stays[~mask_die_le_48h].copy()
+    stays["label_death_in_hosp"] = (
+        stays["deathtime"].notna() & (stays["deathtime"] > stays["t1"])
+    ).astype(int)
+    notes_grouped: Dict[Tuple[int, int], pd.DataFrame] = {}
+    for (sid, hadm), g in notes_df.groupby(["subject_id", "hadm_id"]):
+        notes_grouped[int(sid), int(hadm)] = g.sort_values("charttime")
+    pos_pool = (
+        stays[stays["label_death_in_hosp"] == 1]
+        .sample(frac=1, random_state=args.seed)
+        .to_dict(orient="records")
+    )
+    neg_pool = (
+        stays[stays["label_death_in_hosp"] == 0]
+        .sample(frac=1, random_state=args.seed)
+        .to_dict(orient="records")
+    )
+    if args.n_death and len(pos_pool) == 0:
+        raise RuntimeError(
+            "No positive (death-after-window) ICU stays found after leakage guard."
+        )
+    if args.n_alive and len(neg_pool) == 0:
+        raise RuntimeError("No negative (alive) ICU stays found after leakage guard.")
+    os.makedirs(os.path.dirname(args.out_jsonl) or ".", exist_ok=True)
+    os.makedirs(os.path.dirname(args.qc_csv) or ".", exist_ok=True)
+    qc_rows: List[Dict[str, Any]] = []
+    need_pos = int(args.n_death)
+    need_neg = int(args.n_alive)
+    pos_written = 0
+    neg_written = 0
+    max_passes = max(1, int(args.max_passes_over_pool))
+    written_stays = set()
+    with open(args.out_jsonl, "w", encoding="utf-8") as f:
+        for pass_id in range(max_passes):
+            if pos_written >= need_pos and neg_written >= need_neg:
+                break
+            random.shuffle(pos_pool)
+            random.shuffle(neg_pool)
+            if pos_written < need_pos:
+                for stay_row in pos_pool:
+                    if pos_written >= need_pos:
+                        break
+                    key = (
+                        int(stay_row["subject_id"]),
+                        int(stay_row["hadm_id"]),
+                        int(stay_row["stay_id"]),
+                    )
+                    if key in written_stays:
+                        continue
+                    sample, status, extra = build_sample_for_stay(
+                        stay_row,
+                        notes_grouped,
+                        cxr_by_subject,
+                        patients_map,
+                        args,
+                        itemids,
+                        itemid_to_var,
+                    )
+                    sid = int(stay_row["subject_id"])
+                    hadm_id = int(stay_row["hadm_id"])
+                    stay_id = int(stay_row["stay_id"])
+                    qc = {
+                        "subject_id": sid,
+                        "hadm_id": hadm_id,
+                        "stay_id": stay_id,
+                        "label": 1,
+                        "status": status,
+                        "pass": pass_id,
+                    }
+                    qc.update(extra)
+                    qc_rows.append(qc)
+                    if status != "OK":
+                        continue
+                    written_stays.add(key)
+                    f.write(
+                        json.dumps(
+                            json_safe(sample), ensure_ascii=False, allow_nan=False
+                        )
+                        + "\n"
+                    )
+                    pos_written += 1
+            if neg_written < need_neg:
+                for stay_row in neg_pool:
+                    if neg_written >= need_neg:
+                        break
+                    key = (
+                        int(stay_row["subject_id"]),
+                        int(stay_row["hadm_id"]),
+                        int(stay_row["stay_id"]),
+                    )
+                    if key in written_stays:
+                        continue
+                    sample, status, extra = build_sample_for_stay(
+                        stay_row,
+                        notes_grouped,
+                        cxr_by_subject,
+                        patients_map,
+                        args,
+                        itemids,
+                        itemid_to_var,
+                    )
+                    sid = int(stay_row["subject_id"])
+                    hadm_id = int(stay_row["hadm_id"])
+                    stay_id = int(stay_row["stay_id"])
+                    qc = {
+                        "subject_id": sid,
+                        "hadm_id": hadm_id,
+                        "stay_id": stay_id,
+                        "label": 0,
+                        "status": status,
+                        "pass": pass_id,
+                    }
+                    qc.update(extra)
+                    qc_rows.append(qc)
+                    if status != "OK":
+                        continue
+                    written_stays.add(key)
+                    f.write(
+                        json.dumps(
+                            json_safe(sample), ensure_ascii=False, allow_nan=False
+                        )
+                        + "\n"
+                    )
+                    neg_written += 1
+    qc_df = pd.DataFrame(qc_rows)
+    qc_df.to_csv(args.qc_csv, index=False)
+    written = pos_written + neg_written
+    print(
+        f"[DONE] wrote={written} (pos={pos_written}/{need_pos}, neg={neg_written}/{need_neg}) -> {args.out_jsonl}"
+    )
+    print(f"[DONE] qc rows={len(qc_df)} -> {args.qc_csv}")
+    if pos_written < need_pos or neg_written < need_neg:
+        bad = qc_df[qc_df["status"] != "OK"]
+        top = bad["status"].value_counts().head(10).to_dict() if not bad.empty else {}
+        raise RuntimeError(
+            f"Only wrote pos={pos_written}/{need_pos}, neg={neg_written}/{need_neg}. Top failure reasons: {top}. See patient_qc.csv for filtering reasons."
+        )
+
+
+if __name__ == "__main__":
+    main()

sample/image-timeseries/mimic_death/download.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python3
+"""Acquire official MIMIC files with the user's own credentialed access."""
+
+import sys
+from pathlib import Path
+
+sys.dont_write_bytecode = True
+sys.path.insert(0, str(Path(__file__).resolve().parents[3] / "processing"))
+from download import main
+
+if __name__ == "__main__":
+    main("mimic")

sample/image-timeseries/mimic_death/generate.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python3
+"""Generate local mortality records from MIMIC source tables."""
+
+import sys
+from pathlib import Path
+
+sys.dont_write_bytecode = True
+sys.path.insert(0, str(Path(__file__).resolve().parents[3] / "processing" / "common"))
+from local_generation import main
+
+if __name__ == "__main__":
+    main("mimic_death")

sample/image-timeseries/mimic_death/json_prompt_death.py

@@ -0,0 +1,228 @@
+#!/usr/bin/env python3
+"""Adapted from the original dataset construction script."""
+
+import argparse
+import json
+from typing import Any, Dict, List, Optional, Tuple
+import numpy as np
+
+VITAL_DESC = {
+    "heart_rate_bpm": "Heart rate in beats per minute (bpm), reflecting the patient’s cardiovascular rate and physiologic stress level.",
+    "resp_rate_insp_per_min": "Respiratory rate in breaths per minute, indicating how frequently the patient is breathing and potential respiratory distress.",
+    "spo2_percent": "Peripheral oxygen saturation (SpO₂) as a percentage, estimating arterial oxygenation measured by pulse oximetry.",
+    "temp_c": "Body temperature in degrees Celsius (°C), used to screen for fever, hypothermia, or systemic inflammatory response.",
+    "nbp_systolic_mmhg": "Non-invasive systolic blood pressure (mmHg), representing peak arterial pressure during cardiac contraction and overall perfusion pressure.",
+    "nbp_diastolic_mmhg": "Non-invasive diastolic blood pressure (mmHg), representing arterial pressure between heartbeats and reflecting vascular tone and baseline perfusion.",
+}
+VITAL_VARS = [
+    "heart_rate_bpm",
+    "resp_rate_insp_per_min",
+    "spo2_percent",
+    "temp_c",
+    "nbp_systolic_mmhg",
+    "nbp_diastolic_mmhg",
+]
+
+
+def determine_decimals(values: List[float], decimals: int = None) -> int:
+    """Same rule as your reference: choose decimals based on avg abs diff."""
+    if len(values) == 0:
+        return 0
+    if len(values) > 1:
+        diffs = [abs(values[i + 1] - values[i]) for i in range(len(values) - 1)]
+        avg_diff = float(np.mean(diffs)) if diffs else 0.0
+    else:
+        avg_diff = abs(values[0]) * 0.01 if values[0] != 0 else 1.0
+    if decimals is None:
+        if avg_diff == 0:
+            decimals = 0
+        elif avg_diff >= 10:
+            decimals = 0
+        elif avg_diff >= 1:
+            decimals = 1
+        elif avg_diff >= 0.1:
+            decimals = 2
+        elif avg_diff >= 0.01:
+            decimals = 3
+        elif avg_diff >= 0.001:
+            decimals = 4
+        else:
+            decimals = 5
+    return int(decimals)
+
+
+def safe_float(x) -> Optional[float]:
+    try:
+        if x is None:
+            return None
+        v = float(x)
+        if np.isnan(v) or np.isinf(v):
+            return None
+        return v
+    except Exception:
+        return None
+
+
+def _fmt_img_time(meta: Dict[str, Any]) -> str:
+    sd = meta.get("StudyDate")
+    st = meta.get("StudyTime")
+    vp = meta.get("ViewPosition")
+    study_id = meta.get("study_id")
+    dicom_id = meta.get("dicom_id")
+    sd_s = str(sd) if sd is not None and str(sd).strip() != "" else "UNKNOWN_DATE"
+    st_s = str(st) if st is not None and str(st).strip() != "" else "UNKNOWN_TIME"
+    vp_s = str(vp) if vp is not None and str(vp).strip() != "" else "UNKNOWN_VIEW"
+    extras = []
+    if study_id is not None:
+        extras.append(f"study_id={study_id}")
+    if dicom_id is not None:
+        extras.append(f"dicom_id={dicom_id}")
+    extras.append(f"view={vp_s}")
+    return f"{sd_s} {st_s} ({', '.join(extras)})"
+
+
+def _val_to_str(x: Any) -> str:
+    return "" if x is None else str(x)
+
+
+def build_prompt(sample: Dict[str, Any]) -> str:
+    images: List[str] = sample.get("images_path", sample.get("image_path", sample.get("images", []))) or []
+    image_meta: List[Dict[str, Any]] = sample.get("image_meta", []) or []
+    notes: List[Dict[str, Any]] = sample.get("notes_rr_in_window", []) or []
+    vit_aligned: Dict[str, Any] = sample.get("vitals_aligned", {}) or {}
+    timestamps: List[str] = vit_aligned.get("timestamps", []) or []
+    img_path_lines = []
+    for p in images:
+        img_path_lines.append(f"<image>{p}</image>")
+    img_path_block = "\n".join(img_path_lines).strip()
+    img_info_lines = []
+    if images:
+        for i, p in enumerate(images):
+            meta = (
+                image_meta[i]
+                if i < len(image_meta) and isinstance(image_meta[i], dict)
+                else {}
+            )
+            img_info_lines.append(f"- Image {i + 1}: {p}")
+            img_info_lines.append(
+                f"  Acquisition time (from metadata): {_fmt_img_time(meta)}"
+            )
+    img_info_block = "\n".join(img_info_lines).strip()
+    report_lines = []
+    for i, n in enumerate(notes):
+        ct = n.get("charttime", "")
+        txt = n.get("text", "")
+        report_lines.append(f"[RR Note {i + 1} | charttime={ct}]\n{txt}".strip())
+    report_block = "\n\n".join(report_lines).strip()
+    var_lines = []
+    for v in VITAL_VARS:
+        var_lines.append(f"- {v}: {VITAL_DESC.get(v, v)}")
+    var_block = "\n".join(var_lines)
+    ts_lines = []
+    arrays = {v: vit_aligned.get(v, []) or [] for v in VITAL_VARS}
+    for idx, t in enumerate(timestamps):
+        parts = [
+            f"{v}={(_val_to_str(arrays[v][idx]) if idx < len(arrays[v]) else '')}"
+            for v in VITAL_VARS
+        ]
+        ts_lines.append(f"{t}: " + ", ".join(parts))
+    timeseries_block = "\n".join(ts_lines).strip()
+    question = "Question: Based on the chest X-ray image(s), radiology report(s), and the ICU first-48-hour vital signs, will the patient die during this hospital admission?"
+    options = "Answer (choose one option):\nA. Yes.\nB. No.\n\nReturn only the option letter (A or B)."
+    prompt = f"\nYou are given a question-answering (QA) task.\n\nUse the chest X-ray image(s), radiology report(s), and ICU first-48-hour vital signs as evidence to answer the multiple-choice question.\nDo NOT output any analysis. Return only the option letter.\n\n<image>\nMIMIC-CXR-JPG images: Each image is a JPG converted from an original DICOM chest X-ray.\nMetadata includes StudyDate (an anonymized date; per-patient ordering and time intervals are preserved) and StudyTime (time-of-day; not modified during de-identification).\nBelow are the image paths and acquisition times from metadata:\n{img_info_block}\n</image>\n\n<report>\nRadiology report(s) (RR notes) within ICU first 48 hours:\n{report_block}\n</report>\n\n<variables>\nVital sign variables (within ICU first 48 hours):\n{var_block}\n</variables>\n\n<timeseries>\nAligned time series (each line is one timestamp; missing values are empty):\n{timeseries_block}\n</timeseries>\n\n{question}\n{options}\n"
+    return "\n".join([ln.rstrip() for ln in prompt.splitlines()]).strip()
+
+
+def align_and_round_vitals(
+    vitals_in_window: Dict[str, Any],
+) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+    var_points: Dict[str, List[Tuple[str, float]]] = {v: [] for v in VITAL_VARS}
+    if isinstance(vitals_in_window, dict):
+        for var in VITAL_VARS:
+            seq = vitals_in_window.get(var, [])
+            if not isinstance(seq, list):
+                continue
+            for p in seq:
+                if not isinstance(p, dict):
+                    continue
+                t = p.get("t")
+                v = safe_float(p.get("v"))
+                if isinstance(t, str) and t and (v is not None):
+                    var_points[var].append((t, v))
+    vitals_rounding: Dict[str, int] = {}
+    var_maps: Dict[str, Dict[str, float]] = {}
+    for var in VITAL_VARS:
+        pts = sorted(var_points[var], key=lambda x: x[0])
+        values = [v for (_, v) in pts]
+        dec = determine_decimals(values)
+        vitals_rounding[var] = dec
+        m: Dict[str, float] = {}
+        for t, v in pts:
+            m[t] = round(v, dec)
+        var_maps[var] = m
+    all_ts = set()
+    for var in VITAL_VARS:
+        all_ts.update(var_maps[var].keys())
+    timestamps = sorted(all_ts)
+    vitals_aligned: Dict[str, Any] = {"timestamps": timestamps}
+    for var in VITAL_VARS:
+        m = var_maps[var]
+        vitals_aligned[var] = [m.get(t, None) for t in timestamps]
+    return (vitals_aligned, vitals_rounding)
+
+
+def parse_args():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--in_jsonl", "--in-jsonl", required=True)
+    ap.add_argument("--out_jsonl", "--out-jsonl", required=True)
+    ap.add_argument("--start_id", "--start-id", type=int, default=0)
+    return ap.parse_args()
+
+
+def main():
+    args = parse_args()
+    task_id = int(args.start_id)
+    n_in = 0
+    n_out = 0
+    with open(args.in_jsonl, "r", encoding="utf-8") as fin, open(
+        args.out_jsonl, "w", encoding="utf-8"
+    ) as fout:
+        for line in fin:
+            line = line.strip()
+            if not line:
+                continue
+            n_in += 1
+            obj = json.loads(line)
+            obj["image_path"] = obj.get("images_path", obj.get("image_path", []))
+            obj["task_id"] = f"MIMIC_death{task_id}"
+            obj["task_type"] = "mimic_task"
+            obj["dimension"] = "complementary evidence"
+            obj["sub_dimension"] = "mimicIV_QA"
+            obj["sub2_dimension"] = "death"
+            obj["evaluation_type"] = "QA"
+            vit_raw = (
+                obj.get("time_series_recent")
+                or obj.get("vitals_lookback")
+                or obj.get("vitals_in_window")
+                or {}
+            )
+            vitals_aligned, vitals_rounding = align_and_round_vitals(vit_raw)
+            obj["question"] = (
+                "Question: Based on the chest X-ray image(s), radiology report(s), and the ICU first-48-hour vital signs, will the patient die during this hospital admission?"
+            )
+            obj["vitals_aligned"] = vitals_aligned
+            obj["vitals_rounding"] = vitals_rounding
+            obj["prompt"] = build_prompt(obj)
+            if obj["label_death_in_hosp"] == 1:
+                obj["ground_truth"] = "A"
+            else:
+                obj["ground_truth"] = "B"
+            fout.write(json.dumps(obj, ensure_ascii=False, allow_nan=False) + "\n")
+            task_id += 1
+            n_out += 1
+    print(f"[DONE] in={n_in}, out={n_out}")
+    print(f"[DONE] wrote -> {args.out_jsonl}")
+
+
+if __name__ == "__main__":
+    main()

sample/image-timeseries/mimic_death/source_tables.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+"""Input and JSON helpers for the recovered MIMIC task builders."""
+
+from __future__ import annotations
+
+import math
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+
+def table_path(directory: str, name: str) -> str:
+    path = Path(directory) / name
+    if path.is_file():
+        return str(path)
+    compressed = path.with_suffix(path.suffix + ".gz")
+    if compressed.is_file():
+        return str(compressed)
+    raise FileNotFoundError(f"Missing source table: {path}")
+
+
+def study_date(value) -> str | None:
+    if pd.isna(value):
+        return None
+    text = str(value).strip().removesuffix(".0")
+    stamp = (
+        pd.to_datetime(text, format="%Y%m%d", errors="coerce")
+        if len(text) == 8 and text.isdigit()
+        else pd.to_datetime(text, errors="coerce")
+    )
+    return None if pd.isna(stamp) else stamp.date().isoformat()
+
+
+def json_safe(value):
+    if isinstance(value, dict):
+        return {key: json_safe(item) for key, item in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [json_safe(item) for item in value]
+    if isinstance(value, np.generic):
+        value = value.item()
+    if (
+        isinstance(value, float)
+        and not math.isfinite(value)
+        or value is pd.NA
+        or value is pd.NaT
+    ):
+        return None
+    if isinstance(value, pd.Timestamp):
+        return value.isoformat()
+    return value

sample/image-timeseries/mimic_death/split_dataset.py

@@ -0,0 +1,170 @@
+#!/usr/bin/env python3
+"""Adapted from the original dataset construction script."""
+
+from __future__ import annotations
+import argparse
+import json
+import math
+import random
+from collections import defaultdict
+from pathlib import Path
+from typing import Dict, List, Sequence, Tuple
+
+
+def read_jsonl(path: Path) -> List[dict]:
+    items: List[dict] = []
+    with path.open("r", encoding="utf-8") as f:
+        for line_no, line in enumerate(f, start=1):
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                items.append(json.loads(line))
+            except json.JSONDecodeError as e:
+                raise ValueError(f"Invalid JSON at {path}:{line_no}") from e
+    return items
+
+
+def write_jsonl(path: Path, items: Sequence[dict]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", encoding="utf-8") as f:
+        for obj in items:
+            f.write(json.dumps(obj, ensure_ascii=False) + "\n")
+
+
+def stratified_split(
+    items: List[dict], train_ratio: float, seed: int
+) -> Tuple[List[dict], List[dict]]:
+    if not items:
+        return ([], [])
+    rng = random.Random(seed)
+    groups: Dict[str, List[dict]] = defaultdict(list)
+    for obj in items:
+        label = str(obj.get("ground_truth", ""))
+        groups[label].append(obj)
+    for group_items in groups.values():
+        rng.shuffle(group_items)
+    n = len(items)
+    train_target = int(round(n * train_ratio))
+    train_target = max(0, min(n, train_target))
+    test_target = n - train_target
+    labels = sorted(groups.keys())
+    train_counts: Dict[str, int] = {}
+    fractions: List[Tuple[float, str]] = []
+    for label in labels:
+        cnt = len(groups[label])
+        exact = cnt * train_ratio
+        base = math.floor(exact)
+        train_counts[label] = base
+        fractions.append((exact - base, label))
+    current = sum(train_counts.values())
+    need = train_target - current
+    if need > 0:
+        fractions.sort(reverse=True)
+        i = 0
+        while need > 0 and fractions:
+            _, label = fractions[i % len(fractions)]
+            if train_counts[label] < len(groups[label]):
+                train_counts[label] += 1
+                need -= 1
+            i += 1
+    elif need < 0:
+        fractions.sort()
+        i = 0
+        while need < 0 and fractions:
+            _, label = fractions[i % len(fractions)]
+            if train_counts[label] > 0:
+                train_counts[label] -= 1
+                need += 1
+            i += 1
+    train_items: List[dict] = []
+    test_items: List[dict] = []
+    for label in labels:
+        group_items = groups[label]
+        k = train_counts[label]
+        train_items.extend(group_items[:k])
+        test_items.extend(group_items[k:])
+    rng.shuffle(train_items)
+    rng.shuffle(test_items)
+    assert len(train_items) + len(test_items) == n
+    assert len(train_items) == train_target
+    assert len(test_items) == test_target
+    return (train_items, test_items)
+
+
+def split_one_file(
+    in_path: Path, out_train: Path, out_test: Path, seed: int, train_ratio: float
+) -> None:
+    items = read_jsonl(in_path)
+    train_items, test_items = stratified_split(
+        items, train_ratio=train_ratio, seed=seed
+    )
+    write_jsonl(out_train, train_items)
+    write_jsonl(out_test, test_items)
+
+    def ratio(xs: Sequence[dict]) -> Dict[str, int]:
+        c: Dict[str, int] = defaultdict(int)
+        for x in xs:
+            c[str(x.get("ground_truth", ""))] += 1
+        return dict(c)
+
+    print(
+        f"[DONE] {in_path.name}: total={len(items)} train={len(train_items)} test={len(test_items)}"
+    )
+    print(f"       train label counts: {ratio(train_items)}")
+    print(f"       test  label counts: {ratio(test_items)}")
+    print(f"       wrote -> {out_train}")
+    print(f"       wrote -> {out_test}")
+
+
+def default_output_paths(in_path: Path) -> Tuple[Path, Path]:
+    stem = in_path.with_suffix("")
+    return (
+        stem.with_name(stem.name + "_train.jsonl"),
+        stem.with_name(stem.name + "_test.jsonl"),
+    )
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(
+        description="Split JSONL into train/test with stratification by ground_truth"
+    )
+    ap.add_argument("inputs", nargs="+", help="JSONL input paths.")
+    ap.add_argument(
+        "--train_ratio",
+        "--train-ratio",
+        type=float,
+        default=0.5,
+        help="Training fraction.",
+    )
+    ap.add_argument("--seed", type=int, default=42, help="Random seed.")
+    ap.add_argument(
+        "--out_dir",
+        "--out-dir",
+        default="",
+        help="Output directory; defaults to the input directory.",
+    )
+    args = ap.parse_args()
+    if not 0.0 < args.train_ratio < 1.0:
+        raise ValueError("--train-ratio must be between zero and one")
+    for idx, in_file in enumerate(args.inputs):
+        in_path = Path(in_file)
+        if not in_path.exists():
+            raise FileNotFoundError(f"Input file not found: {in_path}")
+        if args.out_dir:
+            out_dir = Path(args.out_dir)
+            out_train = out_dir / (in_path.stem + "_train.jsonl")
+            out_test = out_dir / (in_path.stem + "_test.jsonl")
+        else:
+            out_train, out_test = default_output_paths(in_path)
+        split_one_file(
+            in_path,
+            out_train,
+            out_test,
+            seed=args.seed + idx,
+            train_ratio=args.train_ratio,
+        )
+
+
+if __name__ == "__main__":
+    main()

sample/image-timeseries/mimic_disch/README.md

@@ -0,0 +1,26 @@
+# MIMIC discharge
+
+**Processing code only:** source data and generated task records are not
+included. Obtain the sources with your own approved access and follow their
+terms. See the [shared setup instructions](../../../processing/README.md).
+Run the commands below from the directory containing `MMTA-v1.0/`, keeping
+`local_sources/` and `local_work/` outside the release folder.
+
+Download MIMIC-IV 3.1, MIMIC-IV-Note 2.2 and MIMIC-CXR-JPG 2.1.0 from [PhysioNet](https://physionet.org/) using your approved account. Required tables: patients, admissions, chartevents, radiology and CXR metadata. `download.py` accepts `--file` or `--file-list` for each selected source.
+
+```bash
+python -B MMTA-v1.0/sample/image-timeseries/mimic_disch/download.py \
+  --output local_sources/mimic --physionet-dataset mimiciv \
+  --file icu/chartevents.csv.gz --username YOUR_USERNAME --accept-terms
+python -B MMTA-v1.0/sample/image-timeseries/mimic_disch/generate.py \
+  --mimic-hosp-dir local_sources/mimic/mimiciv/hosp \
+  --mimic-note-dir local_sources/mimic/mimic-iv-note/note \
+  --cxr-metadata-csv local_sources/mimic/mimic-cxr-jpg/mimic-cxr-2.0.0-metadata.csv.gz \
+  --cxr-jpg-root local_sources/mimic/mimic-cxr-jpg/files \
+  --chartevents local_sources/mimic/mimiciv/icu/chartevents.csv.gz \
+  --output-dir local_work/mimic_disch_build
+```
+
+Join admissions, radiology reports and same-day chest images. Use 48 hours of vital signs before the report anchor and label discharge within the following 48 hours (50 positive / 100 negative); positive anchors are sampled within 24 hours before discharge. The command buckets raw vitals, constructs labels and prompts, makes a 50/50 stratified split, and exports image/CSV records. Existing buckets can be supplied with `--chartevents-root`.
+
+Output: `--output-dir/mimic_disch/mimic_disch.omnits.jsonl`, with `timeseries/` and intermediate train/test JSONL. Images stay in the source tree; paths are relative to the output domain directory. `--split train` selects the training output.

sample/image-timeseries/mimic_disch/build_json_QA.py

@@ -0,0 +1,483 @@
+#!/usr/bin/env python3
+"""Adapted from the original dataset construction script."""
+
+import argparse
+import os
+import json
+import random
+import pandas as pd
+import sys
+from pathlib import Path
+
+sys.dont_write_bytecode = True
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "mimic_death"))
+from source_tables import json_safe, study_date, table_path
+from typing import Dict, List, Optional, Tuple, Any
+
+FIXED_VITAL_ITEMIDS = {
+    220045: "heart_rate_bpm",
+    220210: "resp_rate_insp_per_min",
+    220277: "spo2_percent",
+    223762: "temp_c",
+    220179: "nbp_systolic_mmhg",
+    220180: "nbp_diastolic_mmhg",
+}
+
+
+def parse_args():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--mimic_hosp_dir", "--mimic-hosp-dir", required=True)
+    ap.add_argument("--mimic_note_dir", "--mimic-note-dir", required=True)
+    ap.add_argument("--cxr_metadata_csv", "--cxr-metadata-csv", required=True)
+    ap.add_argument("--cxr_jpg_root", "--cxr-jpg-root", required=True)
+    ap.add_argument(
+        "--chartevents_root",
+        "--chartevents-root",
+        help="Bucketed chartevents root: <root>/<subject_id>/<hadm_id>/chartevents.csv",
+        required=True,
+    )
+    ap.add_argument("--out_jsonl", "--out-jsonl", required=True)
+    ap.add_argument(
+        "--qc_csv", "--qc-csv", help="Write per-sample QC summary here", required=True
+    )
+    ap.add_argument("--seed", type=int, default=42)
+    ap.add_argument("--n_samples", "--n-samples", type=int, default=120)
+    ap.add_argument(
+        "--min_complete_vars",
+        "--min-complete-vars",
+        type=int,
+        default=2,
+        help="Require at least this many variables have full k_per_var observations in lookback window",
+    )
+    ap.add_argument(
+        "--complete_requires_full_k",
+        "--complete-requires-full-k",
+        action="store_true",
+        help="If set, 'complete' means len==k_per_var; otherwise len>=1 counts as complete (not recommended)",
+    )
+    ap.add_argument(
+        "--horizon_hours",
+        "--horizon-hours",
+        type=int,
+        default=48,
+        help="Predict discharge within this many hours after anchor",
+    )
+    ap.add_argument(
+        "--pos_short_window_hours",
+        "--pos-short-window-hours",
+        type=int,
+        default=24,
+        help="For positives, require note+image within this many hours before discharge",
+    )
+    ap.add_argument(
+        "--lookback_hours",
+        "--lookback-hours",
+        type=int,
+        default=48,
+        help="Search vitals in [anchor-lookback, anchor]",
+    )
+    ap.add_argument(
+        "--k_per_var",
+        "--k-per-var",
+        type=int,
+        default=12,
+        help="Keep last k observations per variable",
+    )
+    ap.add_argument(
+        "--max_pos",
+        "--max-pos",
+        type=int,
+        default=50,
+        help="limit positives, -1 means no limit",
+    )
+    ap.add_argument(
+        "--max_neg",
+        "--max-neg",
+        type=int,
+        default=100,
+        help="limit negatives, -1 means no limit",
+    )
+    ap.add_argument(
+        "--drop_if_all_vars_empty", "--drop-if-all-vars-empty", action="store_true"
+    )
+    return ap.parse_args()
+
+
+def to_date_str_yyyy_mm_dd_from_studydate(x) -> Optional[str]:
+    return study_date(x)
+
+
+def subject_folder(subject_id: int) -> str:
+    s = str(int(subject_id))
+    return f"p{s[:2]}"
+
+
+def build_jpg_path(
+    cxr_jpg_root: str, subject_id: int, study_id: int, dicom_id: str
+) -> str:
+    return os.path.abspath(
+        os.path.join(
+            cxr_jpg_root,
+            subject_folder(subject_id),
+            f"p{int(subject_id)}",
+            f"s{int(study_id)}",
+            f"{dicom_id}.jpg",
+        )
+    )
+
+
+def load_radiology_rr_notes(note_dir: str) -> pd.DataFrame:
+    path = table_path(note_dir, "radiology.csv")
+    r = pd.read_csv(path)
+    r = r[r["note_type"].astype(str).eq("RR")].copy()
+    r["charttime"] = pd.to_datetime(r["charttime"], errors="coerce")
+    r = r[r["charttime"].notna()].copy()
+    r = r[r["text"].notna()].copy()
+    r = r[r["hadm_id"].notna()].copy()
+    r["subject_id"] = r["subject_id"].astype(int)
+    r["hadm_id"] = r["hadm_id"].astype(int)
+    r["note_date"] = r["charttime"].dt.date.astype(str)
+    return r
+
+
+def load_cxr_metadata(meta_csv: str) -> pd.DataFrame:
+    m = pd.read_csv(meta_csv)
+    missing = {"dicom_id", "subject_id", "study_id", "StudyDate"} - set(m.columns)
+    if missing:
+        raise RuntimeError(f"metadata missing required columns: {missing}")
+    m["subject_id"] = m["subject_id"].astype(int)
+    m["study_id"] = m["study_id"].astype(int)
+    m["dicom_id"] = m["dicom_id"].astype(str)
+    m["study_date"] = m["StudyDate"].apply(to_date_str_yyyy_mm_dd_from_studydate)
+    return m
+
+
+def load_patients(hosp_dir: str) -> Dict[int, Dict]:
+    path = table_path(hosp_dir, "patients.csv")
+    p = pd.read_csv(
+        path,
+        usecols=lambda c: c
+        in {"subject_id", "gender", "anchor_age", "anchor_year", "anchor_year_group"},
+    )
+    p["subject_id"] = p["subject_id"].astype(int)
+    return p.set_index("subject_id").to_dict(orient="index")
+
+
+def load_admissions_df(hosp_dir: str) -> pd.DataFrame:
+    path = table_path(hosp_dir, "admissions.csv")
+    cols = {
+        "subject_id",
+        "hadm_id",
+        "admittime",
+        "dischtime",
+        "admission_type",
+        "insurance",
+        "language",
+        "marital_status",
+        "race",
+        "hospital_expire_flag",
+    }
+    a = pd.read_csv(path, usecols=lambda c: c in cols)
+    a["subject_id"] = a["subject_id"].astype(int)
+    a["hadm_id"] = a["hadm_id"].astype(int)
+    a["admittime"] = pd.to_datetime(a["admittime"], errors="coerce")
+    a["dischtime"] = pd.to_datetime(a["dischtime"], errors="coerce")
+    a = a[a["dischtime"].notna() & a["admittime"].notna()].copy()
+    return a
+
+
+def admissions_maps(
+    adm_df: pd.DataFrame,
+) -> Tuple[Dict[Tuple[int, int], Dict], Dict[Tuple[int, int], pd.Timestamp]]:
+    out = adm_df.copy()
+    out2 = out.copy()
+    out["admittime"] = out["admittime"].astype("datetime64[ns]").astype(str)
+    out["dischtime"] = out["dischtime"].astype("datetime64[ns]").astype(str)
+    info_map = out.set_index(["subject_id", "hadm_id"]).to_dict(orient="index")
+    disch_map = out2.set_index(["subject_id", "hadm_id"])["dischtime"].to_dict()
+    return (info_map, disch_map)
+
+
+def match_all_images_for_note(
+    note_row, cxr_by_subject: Dict[int, pd.DataFrame], cxr_jpg_root: str
+):
+    sid = int(note_row["subject_id"])
+    date_str = str(note_row["note_date"])
+    subm = cxr_by_subject.get(sid)
+    if subm is None:
+        return ([], [])
+    matched = subm[subm["study_date"].eq(date_str)].copy()
+    if matched.empty:
+        return ([], [])
+    matched = matched.drop_duplicates(["study_id", "dicom_id"])
+    images, metas = ([], [])
+    for _, r in matched.iterrows():
+        images.append(
+            build_jpg_path(cxr_jpg_root, sid, int(r["study_id"]), str(r["dicom_id"]))
+        )
+        metas.append(
+            {
+                "dicom_id": str(r["dicom_id"]),
+                "study_id": int(r["study_id"]),
+                "StudyDate": r.get("StudyDate"),
+                "StudyTime": r.get("StudyTime"),
+                "ViewPosition": r.get("ViewPosition"),
+                "Rows": r.get("Rows"),
+                "Columns": r.get("Columns"),
+                "PerformedProcedureStepDescription": r.get(
+                    "PerformedProcedureStepDescription"
+                ),
+                "ProcedureCodeSequence_CodeMeaning": r.get(
+                    "ProcedureCodeSequence_CodeMeaning"
+                ),
+                "ViewCodeSequence_CodeMeaning": r.get("ViewCodeSequence_CodeMeaning"),
+                "PatientOrientationCodeSequence_CodeMeaning": r.get(
+                    "PatientOrientationCodeSequence_CodeMeaning"
+                ),
+            }
+        )
+    return (images, metas)
+
+
+def iter_chartevents_window(
+    chartevents_root: str,
+    subject_id: int,
+    hadm_id: int,
+    itemids: set,
+    t_start: pd.Timestamp,
+    t_end: pd.Timestamp,
+    chunksize: int,
+    filename: str = "chartevents.csv",
+) -> pd.DataFrame:
+    p = os.path.join(
+        chartevents_root, str(int(subject_id)), str(int(hadm_id)), filename
+    )
+    usecols = ["charttime", "itemid", "valuenum"]
+    if not os.path.exists(p):
+        return pd.DataFrame(columns=["charttime", "itemid", "valuenum"])
+    out = []
+    for chunk in pd.read_csv(
+        p, usecols=lambda c: c in set(usecols), chunksize=chunksize
+    ):
+        if "itemid" not in chunk.columns:
+            continue
+        chunk = chunk[chunk["itemid"].isin(itemids)].copy()
+        if chunk.empty:
+            continue
+        chunk["charttime"] = pd.to_datetime(chunk["charttime"], errors="coerce")
+        chunk = chunk[chunk["charttime"].notna()].copy()
+        chunk = chunk[
+            (chunk["charttime"] >= t_start) & (chunk["charttime"] <= t_end)
+        ].copy()
+        if chunk.empty:
+            continue
+        chunk["valuenum"] = pd.to_numeric(chunk["valuenum"], errors="coerce")
+        chunk = chunk[chunk["valuenum"].notna()].copy()
+        if chunk.empty:
+            continue
+        out.append(chunk[["charttime", "itemid", "valuenum"]])
+    if not out:
+        return pd.DataFrame(columns=["charttime", "itemid", "valuenum"])
+    df = pd.concat(out, ignore_index=True)
+    df = df.sort_values("charttime")
+    return df
+
+
+def take_last_k_per_var(
+    df: pd.DataFrame, itemid_to_var: Dict[int, str], k: int
+) -> Dict[str, List[Dict[str, Any]]]:
+    out: Dict[str, List[Dict[str, Any]]] = {v: [] for v in itemid_to_var.values()}
+    if df.empty:
+        return out
+    df = df.copy()
+    df["var"] = df["itemid"].map(itemid_to_var)
+    df = df[df["var"].notna()].copy()
+    for v in out.keys():
+        sub = df[df["var"] == v].sort_values("charttime")
+        if sub.empty:
+            continue
+        sub = sub.tail(k)
+        out[v] = [
+            {"t": t.isoformat(), "v": float(val)}
+            for (t, val) in zip(sub["charttime"], sub["valuenum"])
+        ]
+    return out
+
+
+def main():
+    args = parse_args()
+    random.seed(args.seed)
+    notes = load_radiology_rr_notes(args.mimic_note_dir)
+    cxr_meta = load_cxr_metadata(args.cxr_metadata_csv)
+    cxr_by_subject = {sid: df for (sid, df) in cxr_meta.groupby("subject_id")}
+    patient_map = load_patients(args.mimic_hosp_dir)
+    adm_df = load_admissions_df(args.mimic_hosp_dir)
+    admission_map, disch_map = admissions_maps(adm_df)
+    itemid_to_var = dict(FIXED_VITAL_ITEMIDS)
+    itemids = set(itemid_to_var.keys())
+    m = cxr_meta[["subject_id", "study_date"]].dropna().drop_duplicates()
+    notes = notes.merge(
+        m,
+        left_on=["subject_id", "note_date"],
+        right_on=["subject_id", "study_date"],
+        how="inner",
+    ).drop(columns=["study_date"])
+    notes = notes.merge(
+        adm_df[["subject_id", "hadm_id", "dischtime"]],
+        on=["subject_id", "hadm_id"],
+        how="inner",
+    )
+    notes["dischtime"] = pd.to_datetime(notes["dischtime"], errors="coerce")
+    notes = notes[notes["dischtime"].notna()].copy()
+    notes = notes[notes["charttime"] <= notes["dischtime"]].copy()
+    notes["delta_to_discharge_hours"] = (
+        notes["dischtime"] - notes["charttime"]
+    ).dt.total_seconds() / 3600.0
+    notes["label_discharge_48h"] = (
+        notes["delta_to_discharge_hours"] <= float(args.horizon_hours)
+    ).astype(int)
+    pos = notes[
+        (notes["label_discharge_48h"] == 1)
+        & (notes["delta_to_discharge_hours"] <= float(args.pos_short_window_hours))
+    ].copy()
+    neg = notes[notes["label_discharge_48h"] == 0].copy()
+    pos = (
+        pos.sort_values(["subject_id", "hadm_id", "delta_to_discharge_hours"])
+        .groupby(["subject_id", "hadm_id"], as_index=False)
+        .head(1)
+    )
+    neg_grouped = []
+    for (sid, hadm), g in neg.groupby(["subject_id", "hadm_id"]):
+        neg_grouped.append(g.sample(n=1, random_state=args.seed))
+    neg = pd.concat(neg_grouped, ignore_index=True) if neg_grouped else neg
+    pos_rows = pos.to_dict(orient="records")
+    neg_rows = neg.to_dict(orient="records")
+    random.shuffle(pos_rows)
+    random.shuffle(neg_rows)
+    need_pos = 100 if args.max_pos < 0 else args.max_pos
+    need_neg = 200 if args.max_neg < 0 else args.max_neg
+    pos_rows = pos.to_dict(orient="records")
+    neg_rows = neg.to_dict(orient="records")
+    random.shuffle(pos_rows)
+    random.shuffle(neg_rows)
+    candidates = [("pos", r) for r in pos_rows] + [("neg", r) for r in neg_rows]
+    random.shuffle(candidates)
+    args.n_samples = need_pos + need_neg
+    os.makedirs(os.path.dirname(args.out_jsonl) or ".", exist_ok=True)
+    os.makedirs(os.path.dirname(args.qc_csv) or ".", exist_ok=True)
+    qc_rows = []
+    written = 0
+    task_id = 0
+    pos_written = 0
+    neg_written = 0
+    with open(args.out_jsonl, "w", encoding="utf-8") as f:
+        for tag, row in candidates:
+            if pos_written >= need_pos and neg_written >= need_neg:
+                break
+            label = int(row["label_discharge_48h"])
+            if tag == "pos" and label != 1:
+                continue
+            if tag == "neg" and label != 0:
+                continue
+            if label == 1 and pos_written >= need_pos:
+                continue
+            if label == 0 and neg_written >= need_neg:
+                continue
+            sid = int(row["subject_id"])
+            hadm_id = int(row["hadm_id"])
+            anchor_time = pd.to_datetime(row["charttime"])
+            dischtime = pd.to_datetime(row["dischtime"])
+            images, image_meta = match_all_images_for_note(
+                row, cxr_by_subject, args.cxr_jpg_root
+            )
+            if not images:
+                qc_rows.append(
+                    {
+                        "subject_id": sid,
+                        "hadm_id": hadm_id,
+                        "label": label,
+                        "status": "NO_IMAGE",
+                    }
+                )
+                continue
+            t_start = anchor_time - pd.Timedelta(hours=args.lookback_hours)
+            t_end = anchor_time
+            df = iter_chartevents_window(
+                chartevents_root=args.chartevents_root,
+                subject_id=sid,
+                hadm_id=hadm_id,
+                itemids=itemids,
+                t_start=t_start,
+                t_end=t_end,
+                chunksize=20000000,
+            )
+            series = take_last_k_per_var(df, itemid_to_var, k=args.k_per_var)
+            per_var_n = {v: len(series[v]) for v in series}
+            if args.complete_requires_full_k:
+                n_complete = sum((1 for n in per_var_n.values() if n == args.k_per_var))
+            else:
+                n_complete = sum((1 for n in per_var_n.values() if n >= 1))
+            if n_complete < args.min_complete_vars:
+                qc_rows.append(
+                    {
+                        "subject_id": sid,
+                        "hadm_id": hadm_id,
+                        "label": label,
+                        "n_complete_vars": int(n_complete),
+                        "status": "TOO_FEW_COMPLETE_VARS",
+                        **{f"n_{v}": int(n) for (v, n) in per_var_n.items()},
+                    }
+                )
+                continue
+            sample = {
+                "task_id": f"mimicIV_{task_id}",
+                "task_type": "mimicIV",
+                "dimension": "complementary evidence",
+                "sub_dimension": "mimicIV_QA",
+                "Class": "mimic",
+                "subject_id": sid,
+                "hadm_id": hadm_id,
+                "t_anchor": anchor_time.isoformat(),
+                "label": label,
+                "horizon_hours": int(args.horizon_hours),
+                "lookback_hours": int(args.lookback_hours),
+                "k_per_var": int(args.k_per_var),
+                "time_series_recent": series,
+                "vars": list(FIXED_VITAL_ITEMIDS.values()),
+                "text": str(row["text"]),
+                "note_id": str(row.get("note_id", "")),
+                "note_seq": (
+                    int(row.get("note_seq", 0))
+                    if not pd.isna(row.get("note_seq", 0))
+                    else 0
+                ),
+                "images_path": images,
+                "image_meta": image_meta,
+                "patient_info": patient_map.get(sid, {}),
+                "admission_info": admission_map.get((sid, hadm_id), {}),
+            }
+            f.write(
+                json.dumps(json_safe(sample), ensure_ascii=False, allow_nan=False)
+                + "\n"
+            )
+            task_id += 1
+            if label == 1:
+                pos_written += 1
+            else:
+                neg_written += 1
+    written = pos_written + neg_written
+    pd.DataFrame(qc_rows).to_csv(args.qc_csv, index=False, encoding="utf-8")
+    print(f"[DONE] wrote={written} -> {args.out_jsonl}")
+    print(f"[DONE] qc rows={len(qc_rows)} -> {args.qc_csv}")
+    if pos_written < need_pos or neg_written < need_neg:
+        raise RuntimeError(
+            f"Only wrote pos={pos_written}/{need_pos}, neg={neg_written}/{need_neg}. See QC for dominant failure reasons."
+        )
+    if written < args.n_samples:
+        raise RuntimeError(
+            f"Only wrote {written} samples. Try increasing candidate pool or relaxing pos_short_window_hours / drop_if_all_vars_empty."
+        )
+
+
+if __name__ == "__main__":
+    main()

sample/image-timeseries/mimic_disch/download.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python3
+"""Acquire official MIMIC files with the user's own credentialed access."""
+
+import sys
+from pathlib import Path
+
+sys.dont_write_bytecode = True
+sys.path.insert(0, str(Path(__file__).resolve().parents[3] / "processing"))
+from download import main
+
+if __name__ == "__main__":
+    main("mimic")

sample/image-timeseries/mimic_disch/generate.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python3
+"""Generate local discharge records from MIMIC source tables."""
+
+import sys
+from pathlib import Path
+
+sys.dont_write_bytecode = True
+sys.path.insert(0, str(Path(__file__).resolve().parents[3] / "processing" / "common"))
+from local_generation import main
+
+if __name__ == "__main__":
+    main("mimic_disch")

sample/image-timeseries/mimic_disch/json_prompt.py

@@ -0,0 +1,331 @@
+#!/usr/bin/env python3
+"""Adapted from the original dataset construction script."""
+
+import argparse
+import json
+from typing import Any, Dict, List, Optional, Tuple
+import numpy as np
+
+VITAL_VARS = [
+    "heart_rate_bpm",
+    "resp_rate_insp_per_min",
+    "spo2_percent",
+    "temp_c",
+    "nbp_systolic_mmhg",
+    "nbp_diastolic_mmhg",
+]
+VITAL_DESC = {
+    "heart_rate_bpm": "Heart rate in beats per minute (bpm), reflecting the patient’s cardiovascular rate and overall physiologic stress.",
+    "resp_rate_insp_per_min": "Respiratory rate in breaths per minute, indicating ventilation demand and potential respiratory distress.",
+    "spo2_percent": "Peripheral oxygen saturation (SpO₂) in percent, a pulse-oximetry estimate of arterial oxygenation.",
+    "temp_c": "Body temperature in degrees Celsius (°C), used to screen for fever/hypothermia and systemic inflammatory response.",
+    "nbp_systolic_mmhg": "Non-invasive systolic blood pressure (mmHg), the peak arterial pressure during cardiac contraction related to perfusion.",
+    "nbp_diastolic_mmhg": "Non-invasive diastolic blood pressure (mmHg), the arterial pressure between beats reflecting vascular tone and baseline perfusion.",
+}
+
+
+def determine_decimals(values: List[float], decimals: int = None) -> int:
+    """Same rule as your reference: choose decimals based on avg abs diff."""
+    if len(values) == 0:
+        return 0
+    if len(values) > 1:
+        diffs = [abs(values[i + 1] - values[i]) for i in range(len(values) - 1)]
+        avg_diff = float(np.mean(diffs)) if diffs else 0.0
+    else:
+        avg_diff = abs(values[0]) * 0.01 if values[0] != 0 else 1.0
+    if decimals is None:
+        if avg_diff == 0:
+            decimals = 0
+        elif avg_diff >= 10:
+            decimals = 0
+        elif avg_diff >= 1:
+            decimals = 1
+        elif avg_diff >= 0.1:
+            decimals = 2
+        elif avg_diff >= 0.01:
+            decimals = 3
+        elif avg_diff >= 0.001:
+            decimals = 4
+        else:
+            decimals = 5
+    return int(decimals)
+
+
+def safe_float(x) -> Optional[float]:
+    try:
+        if x is None:
+            return None
+        v = float(x)
+        if np.isnan(v) or np.isinf(v):
+            return None
+        return v
+    except Exception:
+        return None
+
+
+def _val_to_str(x: Any) -> str:
+    return "" if x is None else str(x)
+
+
+def _fmt_img_time(meta: Dict[str, Any]) -> str:
+    """
+    MIMIC-CXR-JPG metadata:
+    - StudyDate: anonymized date; per-patient ordering and time intervals are preserved
+    - StudyTime: time-of-day; not modified during de-identification
+    """
+    sd = meta.get("StudyDate")
+    st = meta.get("StudyTime")
+    vp = meta.get("ViewPosition")
+    study_id = meta.get("study_id")
+    dicom_id = meta.get("dicom_id")
+    sd_s = str(sd) if sd is not None and str(sd).strip() != "" else "UNKNOWN_DATE"
+    st_s = str(st) if st is not None and str(st).strip() != "" else "UNKNOWN_TIME"
+    vp_s = str(vp) if vp is not None and str(vp).strip() != "" else "UNKNOWN_VIEW"
+    extras = []
+    if study_id is not None:
+        extras.append(f"study_id={study_id}")
+    if dicom_id is not None:
+        extras.append(f"dicom_id={dicom_id}")
+    extras.append(f"view={vp_s}")
+    return f"{sd_s} {st_s} ({', '.join(extras)})"
+
+
+def align_and_round_vitals(
+    vitals_raw: Dict[str, Any],
+) -> Tuple[Dict[str, Any], Dict[str, int]]:
+    if isinstance(vitals_raw, dict) and "timestamps" in vitals_raw:
+        rounding = vitals_raw.get("vitals_rounding", {})
+        return (vitals_raw, rounding if isinstance(rounding, dict) else {})
+    var_points: Dict[str, List[Tuple[str, float]]] = {v: [] for v in VITAL_VARS}
+    if isinstance(vitals_raw, dict):
+        for var in VITAL_VARS:
+            seq = vitals_raw.get(var, [])
+            if not isinstance(seq, list):
+                continue
+            for p in seq:
+                if not isinstance(p, dict):
+                    continue
+                t = p.get("t")
+                v = safe_float(p.get("v"))
+                if isinstance(t, str) and t and (v is not None):
+                    var_points[var].append((t, v))
+    vitals_rounding: Dict[str, int] = {}
+    var_maps: Dict[str, Dict[str, float]] = {}
+    for var in VITAL_VARS:
+        pts = sorted(var_points[var], key=lambda x: x[0])
+        values = [v for (_, v) in pts]
+        dec = determine_decimals(values)
+        vitals_rounding[var] = dec
+        m: Dict[str, float] = {}
+        for t, v in pts:
+            m[t] = round(v, dec)
+        var_maps[var] = m
+    all_ts = set()
+    for var in VITAL_VARS:
+        all_ts.update(var_maps[var].keys())
+    timestamps = sorted(all_ts)
+    vitals_aligned: Dict[str, Any] = {"timestamps": timestamps}
+    for var in VITAL_VARS:
+        m = var_maps[var]
+        vitals_aligned[var] = [m.get(t, None) for t in timestamps]
+    return (vitals_aligned, vitals_rounding)
+
+
+def pick_anchor_time(sample: Dict[str, Any]) -> str:
+    v = sample.get("t_anchor")
+    if isinstance(v, str) and v.strip():
+        return v.strip()
+    return ""
+
+
+def normalize_rr_notes(sample: Dict[str, Any]) -> List[Dict[str, Any]]:
+    """
+    Return a list of RR-note-like dicts, each with at least:
+      - charttime (string, may be empty)
+      - text (string)
+      - note_id (optional)
+      - note_seq (optional)
+
+    Supports:
+      A) death-style: notes_rr_in_window / notes_rr / notes (list of dicts)
+      B) discharge-style: flat fields: text + note_id/note_seq (+ optional charttime)
+    """
+    for k in ["notes_rr_in_window", "notes_rr", "notes"]:
+        v = sample.get(k)
+        if isinstance(v, list) and v:
+            out = []
+            for it in v:
+                if not isinstance(it, dict):
+                    continue
+                out.append(
+                    {
+                        "charttime": str(it.get("charttime", "") or ""),
+                        "text": str(it.get("text", "") or ""),
+                        "note_id": it.get("note_id"),
+                        "note_seq": it.get("note_seq"),
+                    }
+                )
+            out = [x for x in out if x["text"].strip() != ""]
+            return out
+    txt = sample.get("text")
+    if isinstance(txt, str) and txt.strip():
+        ct = (
+            sample.get("note_charttime")
+            or sample.get("charttime")
+            or sample.get("t_note")
+            or sample.get("t_anchor")
+            or ""
+        )
+        return [
+            {
+                "charttime": str(ct or ""),
+                "text": txt,
+                "note_id": sample.get("note_id"),
+                "note_seq": sample.get("note_seq"),
+            }
+        ]
+    return []
+
+
+def build_prompt_discharge(
+    sample: Dict[str, Any],
+    horizon_hours_default: int = 48,
+    lookback_hours_default: int = 48,
+) -> str:
+    images: List[str] = sample.get("images_path", sample.get("image_path", sample.get("images", []))) or []
+    image_meta: List[Dict[str, Any]] = sample.get("image_meta", []) or []
+    notes = normalize_rr_notes(sample)
+    vit_raw = (
+        sample.get("time_series_recent")
+        or sample.get("vitals_lookback")
+        or sample.get("vitals_in_window")
+        or {}
+    )
+    vit_aligned = sample.get("vitals_aligned", None)
+    if not isinstance(vit_aligned, dict) or "timestamps" not in vit_aligned:
+        vit_aligned, _ = align_and_round_vitals(vit_raw)
+    timestamps: List[str] = vit_aligned.get("timestamps", []) or []
+    arrays = {v: vit_aligned.get(v, []) or [] for v in VITAL_VARS}
+    horizon = sample.get("horizon_hours", horizon_hours_default)
+    lookback = sample.get("lookback_hours", lookback_hours_default)
+    try:
+        horizon = int(horizon)
+    except Exception:
+        horizon = horizon_hours_default
+    try:
+        lookback = int(lookback)
+    except Exception:
+        lookback = lookback_hours_default
+    anchor_time = pick_anchor_time(sample)
+    img_path_block = "\n".join([f"<image>{p}</image>" for p in images]).strip()
+    img_info_lines = []
+    for i, p in enumerate(images):
+        meta = (
+            image_meta[i]
+            if i < len(image_meta) and isinstance(image_meta[i], dict)
+            else {}
+        )
+        img_info_lines.append(f"- Image {i + 1}: {p}")
+        img_info_lines.append(
+            f"  Acquisition time (from metadata): {_fmt_img_time(meta)}"
+        )
+    img_info_block = "\n".join(img_info_lines).strip()
+    report_lines = []
+    for i, n in enumerate(notes):
+        if not isinstance(n, dict):
+            continue
+        ct = n.get("charttime", "")
+        txt = n.get("text", "")
+        report_lines.append(f"[RR Note {i + 1} | charttime={ct}]\n{txt}".strip())
+    report_block = "\n\n".join(report_lines).strip()
+    var_block = "\n".join([f"- {v}: {VITAL_DESC.get(v, v)}" for v in VITAL_VARS])
+    ts_lines = []
+    for idx, t in enumerate(timestamps):
+        parts = []
+        for v in VITAL_VARS:
+            val = arrays[v][idx] if idx < len(arrays[v]) else None
+            parts.append(f"{v}={_val_to_str(val)}")
+        ts_lines.append(f"{t}: " + ", ".join(parts))
+    timeseries_block = "\n".join(ts_lines).strip()
+    question = f"Question: Using the chest X-ray image(s), radiology report(s), and the vital signs observed in the {lookback}-hour lookback window ending at the anchor time, will the patient be discharged within the next {horizon} hours after the anchor time?"
+    options = "Answer (choose one option):\nA. Yes.\nB. No.\n\nReturn only the option letter (A or B)."
+    anchor_line = (
+        f"Anchor time: {anchor_time}" if anchor_time else "Anchor time: (not provided)"
+    )
+    prompt = f"\nYou are given a question-answering (QA) task.\n\nUse the chest X-ray image(s), radiology report(s), and vital signs as evidence to answer the multiple-choice question.\nDo NOT output any analysis. Return only the option letter.\n\n<image>\nMIMIC-CXR-JPG images: Each image is a JPG converted from an original DICOM chest X-ray.\nMetadata includes StudyDate (an anonymized date; per-patient ordering and time intervals are preserved) and StudyTime (time-of-day; not modified during de-identification).\nBelow are the image paths and acquisition times from metadata:\n{img_info_block}\n</image>\n\n<context>\n{anchor_line}\nVital signs are provided as an aligned time series covering the lookback window ending at the anchor time.\n</context>\n\n<report>\nRadiology report(s) (RR notes) associated with the imaging evidence:\n{report_block}\n</report>\n\n<variables>\nVital sign variables:\n{var_block}\n</variables>\n\n<timeseries>\nAligned time series (each line is one timestamp; missing values are empty):\n{timeseries_block}\n</timeseries>\n\n{question}\n{options}\n"
+    return "\n".join([ln.rstrip() for ln in prompt.splitlines()]).strip()
+
+
+def parse_args():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--in_jsonl", "--in-jsonl", required=True)
+    ap.add_argument("--out_jsonl", "--out-jsonl", required=True)
+    ap.add_argument("--start_id", "--start-id", type=int, default=0)
+    ap.add_argument("--task_id_prefix", "--task-id-prefix", default="MIMIC_discharge")
+    ap.add_argument("--sub2_dimension", "--sub2-dimension", default="discharge")
+    ap.add_argument(
+        "--default_horizon_hours", "--default-horizon-hours", type=int, default=48
+    )
+    ap.add_argument(
+        "--default_lookback_hours", "--default-lookback-hours", type=int, default=48
+    )
+    ap.add_argument(
+        "--drop_old_vitals_fields", "--drop-old-vitals-fields", action="store_true"
+    )
+    return ap.parse_args()
+
+
+def main():
+    args = parse_args()
+    task_id = int(args.start_id)
+    n_in = 0
+    n_out = 0
+    with open(args.in_jsonl, "r", encoding="utf-8") as fin, open(
+        args.out_jsonl, "w", encoding="utf-8"
+    ) as fout:
+        for line in fin:
+            line = line.strip()
+            if not line:
+                continue
+            n_in += 1
+            obj = json.loads(line)
+            obj["image_path"] = obj.get("images_path", obj.get("image_path", []))
+            vit_raw = (
+                obj.get("time_series_recent")
+                or obj.get("vitals_lookback")
+                or obj.get("vitals_in_window")
+                or {}
+            )
+            vit_aligned, vit_rounding = align_and_round_vitals(vit_raw)
+            obj["vitals_aligned"] = vit_aligned
+            obj["vitals_rounding"] = vit_rounding
+            if args.drop_old_vitals_fields:
+                obj.pop("vitals_lookback", None)
+                obj.pop("vitals_in_window", None)
+            obj["task_id"] = f"MIMIC_disch{task_id}"
+            obj["task_type"] = "mimic_task"
+            obj["dimension"] = "complementary evidence"
+            obj["sub_dimension"] = "mimicIV_QA"
+            obj["sub2_dimension"] = "disch"
+            obj["evaluation_type"] = "QA"
+            obj["prompt"] = build_prompt_discharge(
+                obj,
+                horizon_hours_default=args.default_horizon_hours,
+                lookback_hours_default=args.default_lookback_hours,
+            )
+            obj["question"] = (
+                f"Question: Using the chest X-ray image(s), radiology report(s), and the vital signs observed in the 48-hour lookback window ending at the anchor time, will the patient be discharged within the next 48 hours after the anchor time?"
+            )
+            if obj["label"] == 1:
+                obj["ground_truth"] = "A"
+            else:
+                obj["ground_truth"] = "B"
+            fout.write(json.dumps(obj, ensure_ascii=False, allow_nan=False) + "\n")
+            task_id += 1
+            n_out += 1
+    print(f"[DONE] in={n_in}, out={n_out}")
+    print(f"[DONE] wrote -> {args.out_jsonl}")
+
+
+if __name__ == "__main__":
+    main()

sample/image-timeseries/pixelrec/README.md

@@ -0,0 +1,22 @@
+# PixelRec
+
+**Processing code only:** source data and generated task records are not
+included. Obtain the sources from the upstream project and follow its terms.
+See the [shared setup instructions](../../../processing/README.md).
+Run the commands below from the directory containing `MMTA-v1.0/`, keeping
+`local_sources/` and `local_work/` outside the release folder.
+
+Download the interactions, item metadata and covers from the Google Drive links in the [PixelRec repository](https://github.com/westlake-repl/PixelRec), then unpack the archives.
+
+```bash
+python -B MMTA-v1.0/sample/image-timeseries/pixelrec/download.py --output local_sources/pixelrec --component interactions --component item-info --component covers --accept-terms
+python -B MMTA-v1.0/sample/image-timeseries/pixelrec/generate.py \
+  --interactions local_sources/pixelrec/Pixel200K.csv \
+  --item-info local_sources/pixelrec/item_info.csv \
+  --image-root local_sources/pixelrec/image/cover \
+  --output-dir local_work/pixelrec_build
+```
+
+Build: daily interaction counts -> longest consecutive history -> six-day forecasts -> cover-image/CSV conversion.
+
+Output: `--output-dir/pixelrec/pixelrec.omnits.jsonl`, plus media and history CSVs. Paths are relative to that output domain directory.

sample/image-timeseries/pixelrec/download.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python3
+"""Download pixelrec from its official source for local processing."""
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[3] / "processing"))
+from download import main
+
+
+if __name__ == "__main__":
+    main("pixelrec")

sample/image-timeseries/pixelrec/generate.py

@@ -0,0 +1,13 @@
+#!/usr/bin/env python3
+"""Generate local PixelRec daily forecasts and unified image/time-series records."""
+
+import sys
+from pathlib import Path
+
+sys.dont_write_bytecode = True
+sys.path.insert(0, str(Path(__file__).resolve().parents[3] / "processing" / "common"))
+from local_generation import main
+
+
+if __name__ == "__main__":
+    main("pixelrec")

sample/image-timeseries/pixelrec/prepare.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+"""Build daily PixelRec forecasting tasks from personally obtained source data.
+
+Adapted from PixelRec/build_day.py. This script does not grant permission to
+redistribute its inputs or outputs. Data acquisition terms remain applicable.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+import pandas as pd
+
+
+def longest_segment(days: list, counts: list[int]) -> tuple[list, list[int]]:
+    best_start, best_length, start = 0, 0, 0
+    for index in range(1, len(days) + 1):
+        if index == len(days) or (days[index] - days[index - 1]).days != 1:
+            if index - start > best_length:
+                best_start, best_length = start, index - start
+            start = index
+    return days[best_start:best_start + best_length], counts[best_start:best_start + best_length]
+
+
+def safe_text(value: object) -> str:
+    return "" if pd.isna(value) else str(value).strip()
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--interactions", type=Path, required=True, help="Interaction CSV with item_id and Unix-second timestamp.")
+    parser.add_argument("--item-info", type=Path, required=True, help="Item metadata CSV with item_id, title, tag and description.")
+    parser.add_argument("--image-root", type=Path, required=True, help="Directory containing item cover JPGs.")
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--min-segment-length", type=int, default=20)
+    parser.add_argument("--max-segment-length", type=int, default=200)
+    parser.add_argument("--horizon", type=int, default=6)
+    parser.add_argument("--limit", type=int, default=200, help="Maximum tasks; 0 means all eligible items.")
+    args = parser.parse_args()
+    if args.horizon < 1 or args.min_segment_length <= args.horizon or args.max_segment_length < args.min_segment_length or args.limit < 0:
+        parser.error("Invalid segment length, horizon or limit")
+    data = pd.read_csv(args.interactions, dtype={"item_id": str, "user_id": str})
+    data["day"] = pd.to_datetime(data["timestamp"], unit="s", utc=True).dt.floor("D").dt.date
+    daily = data.groupby(["item_id", "day"]).size().reset_index(name="count").sort_values(["item_id", "day"])
+    metadata = pd.read_csv(args.item_info, dtype={"item_id": str}).drop_duplicates("item_id").set_index("item_id")
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    written = 0
+    with args.output.open("w", encoding="utf-8") as handle:
+        for item_id, group in daily.groupby("item_id", sort=False):
+            days, counts = longest_segment(group["day"].tolist(), group["count"].tolist())
+            if len(days) < args.min_segment_length:
+                continue
+            days, counts = days[-args.max_segment_length:], counts[-args.max_segment_length:]
+            image = args.image_root / f"{item_id}.jpg"
+            if not image.is_file():
+                raise FileNotFoundError(f"Missing cover image for {item_id}: {image}")
+            history_days = [day.strftime("%Y-%m-%d") for day in days[:-args.horizon]]
+            future_days = [day.strftime("%Y-%m-%d") for day in days[-args.horizon:]]
+            history_values, targets = counts[:-args.horizon], counts[-args.horizon:]
+            item = metadata.loc[item_id].to_dict() if item_id in metadata.index else {}
+            context = "\n".join(f"{key}: {safe_text(item.get(key, ''))}" for key in ("title", "tag", "description"))
+            history = "\n".join(f"({timestamp}, {value})" for timestamp, value in zip(history_days, history_values))
+            prompt = (
+                "I have a time series forecasting task for you.\n\n"
+                "Here is some context about the item (title/tag/description). Also note the image above is the item's cover.\n"
+                f"<context>\n{context}\n</context>\n\n"
+                "Here is a historical time series. Timestamps are daily; values are daily interaction counts.\n"
+                f"<history>\n{history}\n</history>\n\n"
+                f"Now please predict the value at the following timestamps: {future_days}.\n\n"
+                "Return the forecast in (timestamp, value) format in between <forecast> and </forecast> tags.\n"
+                "Do not include any other information (e.g., comments) in the forecast.\n"
+            )
+            record = {"task_id": f"Pixelrec_{written}", "item_id": item_id, "image_path": str(image.resolve()),
+                      "hist_timestamp": history_days, "hist_interaction_count": history_values,
+                      "ground_truth": targets, "meta_info": {"future_timestamps": future_days},
+                      "evaluation_type": "prediction", "task": "prediction", "prompt": prompt}
+            handle.write(json.dumps(record, ensure_ascii=False, allow_nan=False) + "\n")
+            written += 1
+            if args.limit and written >= args.limit:
+                break
+    if not written:
+        raise SystemExit("No eligible tasks were produced")
+    print(json.dumps({"records": written, "output": str(args.output)}))
+
+
+if __name__ == "__main__":
+    main()

sample/image-timeseries/sp500/README.md

@@ -0,0 +1,22 @@
+# SP500 / FinMultiTime
+
+**Processing code only:** source data and generated task records are not
+included. Obtain the sources from the upstream project and follow its terms.
+See the [shared setup instructions](../../../processing/README.md).
+Run the commands below from the directory containing `MMTA-v1.0/`, keeping
+`local_sources/` and `local_work/` outside the release folder.
+
+Download [FinMultiTime](https://huggingface.co/datasets/Wenyan0110/Multimodal-Dataset-Image_Text_Table_TimeSeries-for-Financial-Time-Series-Forecasting) using download.py and unpack the price, news and chart files.
+
+```bash
+python -B MMTA-v1.0/sample/image-timeseries/sp500/download.py --output local_sources/finmultitime --accept-terms
+python -B MMTA-v1.0/sample/image-timeseries/sp500/generate.py \
+  --time-series-dir local_sources/finmultitime/SP500_time_series \
+  --news-dir local_sources/finmultitime/sp500_news \
+  --image-root local_sources/finmultitime/image/image \
+  --output-dir local_work/sp500_build --limit 200
+```
+
+Build: 2024 H1 price history and charts -> next 12 closing-price targets -> three latest eligible articles -> image/CSV conversion. News must be strictly before midnight on the first forecast date in America/New_York; invalid or missing dates are excluded.
+
+Output: `--output-dir/sp500/sp500.omnits.jsonl`, plus media and history CSVs. Paths are relative to that output domain directory.

sample/image-timeseries/sp500/download.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python3
+"""Download sp500 from its official source for local processing."""
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[3] / "processing"))
+from download import main
+
+
+if __name__ == "__main__":
+    main("sp500")

sample/image-timeseries/sp500/generate.py

@@ -0,0 +1,13 @@
+#!/usr/bin/env python3
+"""Generate local SP500 forecasts with strictly pre-horizon news."""
+
+import sys
+from pathlib import Path
+
+sys.dont_write_bytecode = True
+sys.path.insert(0, str(Path(__file__).resolve().parents[3] / "processing" / "common"))
+from local_generation import main
+
+
+if __name__ == "__main__":
+    main("sp500")

sample/image-timeseries/sp500/prepare.py

@@ -0,0 +1,398 @@
+#!/usr/bin/env python3
+"""Build SP500 forecasting tasks with strictly pre-horizon news.
+
+Adapted from the local build_jsonl_forcast_withoutpng.py. Price histories
+retain the first-half-2024 window. News is filtered by its source Date and
+sorted before selecting the latest three eligible articles.
+"""
+import os
+import json
+import glob
+import argparse
+import re
+from zoneinfo import ZoneInfo
+import pandas as pd
+import numpy as np
+
+DATE_START = "2024-01-01"
+DATE_END = "2024-06-30"
+FUT_LEN = 12
+HIST_TIME_STR = "2024.1.1-2024.6.30"
+
+CLASS_NAME = "S&P500"
+NEWS_TIMEZONE = "America/New_York"
+
+
+def to_day_str_from_any_datetime(x) -> str | None:
+    if x is None:
+        return None
+    s = str(x).strip()
+    if not s:
+        return None
+
+    dt = pd.to_datetime(s, errors="coerce", utc=True)
+    if pd.isna(dt):
+        return None
+
+    try:
+        dt = dt.tz_convert("Asia/Shanghai")
+    except Exception:
+        pass
+
+    return dt.strftime("%Y-%m-%d")
+
+
+def find_sp500_image_by_convention(image_root: str, label_lower: str) -> str | None:
+    """
+    SP500_image/S&P500_image_a/aa/aa_2024_H1_candlestick.png
+    """
+    if not label_lower:
+        return None
+    bucket = label_lower[0].lower()
+    base_dir = os.path.join(image_root, f"S&P500_image_{bucket}", label_lower)
+
+    exts = ["png", "jpg", "jpeg", "webp", "bmp"]
+    candidates = []
+    for ext in exts:
+        p = os.path.join(base_dir, f"{label_lower}_2024_H1_candlestick.{ext}")
+        if os.path.isfile(p):
+            candidates.append(p)
+    candidates.sort()
+    return candidates[0] if candidates else None
+
+
+def find_sp500_news_by_convention(news_dir: str, label_upper: str) -> str | None:
+    """
+    sp500_news/AA.jsonl
+    """
+    p = os.path.join(news_dir, f"{label_upper}.jsonl")
+    return p if os.path.isfile(p) else None
+
+
+def parse_news_timestamp(value: object, timezone: str) -> pd.Timestamp | None:
+    """Parse an ISO source date; undated and ambiguous records are ineligible."""
+    if not isinstance(value, str):
+        return None
+    value = value.strip()
+    if not re.fullmatch(r"\d{4}-\d{2}-\d{2}(?:[T ].+)?", value):
+        return None
+    try:
+        timestamp = pd.Timestamp(value)
+        if pd.isna(timestamp):
+            return None
+        if timestamp.tzinfo is None:
+            timestamp = timestamp.tz_localize(timezone, ambiguous="NaT", nonexistent="NaT")
+        if pd.isna(timestamp):
+            return None
+        return timestamp.tz_convert("UTC")
+    except (ValueError, TypeError, OverflowError):
+        return None
+
+
+def load_pre_horizon_news(
+    news_file: str,
+    *,
+    forecast_start: str,
+    k: int = 3,
+    timezone: str = NEWS_TIMEZONE,
+) -> list[dict[str, str]]:
+    """Select the latest k articles strictly before the first forecast day.
+
+    The cutoff is midnight at the start of that day in the source timezone.
+    Date-only and naive timestamps use that timezone; aware timestamps retain
+    their actual instant. Missing or invalid dates never enter the prompt.
+    """
+    ZoneInfo(timezone)
+    if k < 1:
+        raise ValueError("k must be positive")
+    if not isinstance(forecast_start, str) or not re.fullmatch(r"\d{4}-\d{2}-\d{2}", forecast_start):
+        raise ValueError("forecast_start must be an ISO calendar date")
+    cutoff = parse_news_timestamp(forecast_start, timezone)
+    if cutoff is None:
+        raise ValueError("Invalid forecast_start")
+    if not news_file or not os.path.isfile(news_file):
+        return []
+
+    eligible = []
+    with open(news_file, "r", encoding="utf-8") as f:
+        for line_no, line in enumerate(f, 1):
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                obj = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            if not isinstance(obj, dict):
+                continue
+            published_at = parse_news_timestamp(obj.get("Date"), timezone)
+            if published_at is None or published_at >= cutoff:
+                continue
+            s = obj.get("Article", None)
+            if not isinstance(s, str):
+                continue
+            s = s.strip()
+            if not s:
+                continue
+            eligible.append((published_at, line_no, {
+                "date": obj["Date"].strip(),
+                "published_at": published_at.isoformat(),
+                "article": s,
+                "url": str(obj.get("Url") or ""),
+            }))
+
+    eligible.sort(key=lambda item: (item[0], item[1]))
+    return [item[2] for item in eligible[-k:]]
+
+
+def load_last_k_news_summaries(
+    news_file: str,
+    *,
+    forecast_start: str,
+    k: int = 3,
+    timezone: str = NEWS_TIMEZONE,
+) -> list[str]:
+    """Return article text using the same mandatory pre-horizon cutoff."""
+    return [item["article"] for item in load_pre_horizon_news(
+        news_file, forecast_start=forecast_start, k=k, timezone=timezone,
+    )]
+
+
+def choose_decimals_by_avg_diff(values: list[float]) -> int:
+    if len(values) == 0:
+        return 0
+    if len(values) > 1:
+        diffs = [abs(values[i + 1] - values[i]) for i in range(len(values) - 1)]
+        avg_diff = float(np.mean(diffs)) if diffs else 0.0
+    else:
+        avg_diff = abs(values[0]) * 0.01 if values[0] != 0 else 1.0
+
+    if avg_diff == 0:
+        return 0
+    if avg_diff >= 10:
+        return 0
+    if avg_diff >= 1:
+        return 1
+    if avg_diff >= 0.1:
+        return 2
+    if avg_diff >= 0.01:
+        return 3
+    if avg_diff >= 0.001:
+        return 4
+    return 5
+
+
+def format_history_pairs(timestamps: list[str], values: list[float], max_display: int = None) -> str:
+    """Format timestamp/value pairs, with optional display truncation."""
+    dec = choose_decimals_by_avg_diff(values)
+
+    def fmt(v: float) -> str:
+        return f"{float(v):.{dec}f}"
+
+    pairs = [f"({ts}, {fmt(v)})" for ts, v in zip(timestamps, values)]
+
+    if max_display is None or len(pairs) <= max_display:
+        return "\n".join(pairs)
+
+    first_n = max_display // 2
+    last_n = max_display - first_n
+    return "\n".join(pairs[:first_n] + ["..."] + pairs[-last_n:])
+
+
+def build_prompt_sp500(
+    image_abs_path: str,
+    label_upper: str,
+    history_str: str,
+    pred_time: list[str],
+    last3_texts: list[str],
+) -> str:
+    
+    context_lines = []
+    if last3_texts:
+        context_lines.append("Recent news summaries (most recent last):")
+        for i, t in enumerate(last3_texts, 1):
+            context_lines.append(f"{i}. {t}")
+    else:
+        context_lines.append("Recent news summaries: (none)")
+
+    context = "\n".join(context_lines)
+    pred_time_str = ", ".join(pred_time)
+
+    prompt = f"""
+I have a time series forecasting task for you.
+
+Here is some context about the task. Make sure to factor in any background knowledge,
+satisfy any constraints, and respect any scenarios.
+<context>
+Asset: {label_upper} (S&P 500 constituent)
+{context}
+</context>
+
+Here is a historical time series in (timestamp, value) format:
+<history>
+{history_str}
+</history>
+
+Now please predict the value at the following timestamps: {pred_time_str}.
+
+Return the forecast in (timestamp, value) format in between <forecast> and </forecast> tags.
+Do not include any other information (e.g., comments) in the forecast.
+
+Example:
+<history>
+(t1, v1)
+(t2, v2)
+(t3, v3)
+</history>
+<forecast>
+(t4, v4)
+(t5, v5)
+</forecast>
+"""
+    return prompt
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--time-series-dir", "--time_series_dir", dest="time_series_dir", default="SP500_time_series")
+    ap.add_argument("--news-dir", "--news_dir", dest="news_dir", default="sp500_news")
+    ap.add_argument("--image-dir", "--image_dir", dest="image_dir", default="image/image")
+    ap.add_argument("--out-jsonl", "--out_jsonl", dest="out_jsonl", default="sp500_prompt_test.jsonl")
+    ap.add_argument("--max-files", "--max_files", dest="max_files", type=int, default=200)
+    ap.add_argument("--fut-len", "--fut_len", dest="fut_len", type=int, default=FUT_LEN)
+    ap.add_argument("--history-max-display", "--history_max_display", dest="history_max_display", type=int, default=None)  
+    ap.add_argument("--news-timezone", default=NEWS_TIMEZONE,
+                    help="Timezone for source date-only and naive news timestamps.")
+    args = ap.parse_args()
+    if args.fut_len < 1 or args.max_files == 0 or args.max_files < -1:
+        ap.error("--fut-len must be positive; --max-files must be positive or -1")
+    ZoneInfo(args.news_timezone)
+
+    ts_files = sorted(glob.glob(os.path.join(args.time_series_dir, "*.csv")))
+    target_written = args.max_files 
+    os.makedirs(os.path.dirname(args.out_jsonl) or ".", exist_ok=True)
+
+    start_day = pd.to_datetime(DATE_START).date()
+    end_day = pd.to_datetime(DATE_END).date()
+
+    written, skipped = 0, 0
+    predict_id = 0
+
+    with open(args.out_jsonl, "w", encoding="utf-8") as out_f:
+        for csv_path in ts_files:
+            label_lower = os.path.splitext(os.path.basename(csv_path))[0].strip()
+            if not label_lower:
+                skipped += 1
+
+                continue
+            label_upper = label_lower.upper()
+
+            try:
+                df = pd.read_csv(csv_path)
+            except Exception:
+                skipped += 1
+
+                continue
+
+            if "Date" not in df.columns or "Close" not in df.columns:
+                skipped += 1
+                continue
+
+            
+            dt = pd.to_datetime(df["Date"], errors="coerce", utc=True)
+            df = df.assign(_dt=dt).dropna(subset=["_dt"]).copy()
+            df["_day"] = df["_dt"].dt.date
+            df = df.sort_values("_dt").reset_index(drop=True)
+
+            hist_df = df[(df["_day"] >= start_day) & (df["_day"] <= end_day)].copy()
+            if hist_df.empty:
+                skipped += 1
+                continue
+
+            last_hist_pos = hist_df.index.max()
+            fut_df = df.iloc[last_hist_pos + 1: last_hist_pos + 1 + args.fut_len].copy()
+            if len(fut_df) < args.fut_len:
+                skipped += 1
+                continue
+
+            
+            img_path = find_sp500_image_by_convention(args.image_dir, label_lower)
+            if img_path is None:
+                skipped += 1
+                continue
+
+            
+            image_abs_path = str(os.path.abspath(img_path)).replace("\\", "/")
+
+            
+            image_path_rel = os.path.relpath(img_path, start=args.image_dir).replace("\\", "/")
+            image_path_rel = f"{os.path.basename(args.image_dir)}/{image_path_rel}"
+
+            
+            hist_timestamps = [d.strftime("%Y-%m-%d") for d in hist_df["_day"].tolist()]
+            hist_values = hist_df["Close"].astype(float).tolist()
+
+            fut_timestamps = [d.strftime("%Y-%m-%d") for d in fut_df["_day"].tolist()]
+            fut_values = fut_df["Close"].astype(float).tolist()
+
+            news_file = find_sp500_news_by_convention(args.news_dir, label_upper)
+            selected_news = load_pre_horizon_news(
+                news_file, forecast_start=fut_timestamps[0], k=3,
+                timezone=args.news_timezone,
+            )
+            last3_texts = [item["article"] for item in selected_news]
+
+            history_str = format_history_pairs(
+                hist_timestamps, hist_values, max_display=args.history_max_display
+            )
+
+            prompt = build_prompt_sp500(
+                image_abs_path=image_abs_path,
+                label_upper=label_upper,
+                history_str=history_str,
+                pred_time=fut_timestamps,
+                last3_texts=last3_texts,
+            )
+
+            record = {
+                "task_id": f"Fin_{predict_id}",
+                "task_type": "Fin",
+                "dimension": "complementary evidence",
+                "sub_dimension": "Fin_predict",
+                "text": last3_texts,
+                "prompt": prompt,
+                "evaluation_type":"prediction",
+                "time_index": list(range(len(hist_timestamps))),
+                "timestamp": hist_timestamps,
+                "time_series_data": hist_values,
+                "ground_truth": fut_values,
+                "image_path": image_abs_path,
+                "label": label_upper,
+                "Class": CLASS_NAME,
+                "hist length": len(hist_timestamps),
+                "Fut length": args.fut_len,
+                "Hist time": HIST_TIME_STR,
+            }
+            record["meta_info"] = {
+                "future_timestamps": fut_timestamps,
+                "news_cutoff_exclusive": parse_news_timestamp(
+                    fut_timestamps[0], args.news_timezone,
+                ).isoformat(),
+                "news_timezone": args.news_timezone,
+                "news_selection": "latest_3_strictly_before_forecast_start",
+                "selected_news": [
+                    {key: item[key] for key in ("date", "published_at", "url")}
+                    for item in selected_news
+                ],
+            }
+            out_f.write(json.dumps(record, ensure_ascii=False) + "\n")
+            written += 1
+            predict_id += 1
+            if target_written > 0 and written >= target_written:
+                break
+
+    print(f"Done. written={written}, skipped={skipped}, out={args.out_jsonl}")
+
+
+if __name__ == "__main__":
+    main()

sample/image-timeseries/sp500/test_news_cutoff.py

@@ -0,0 +1,111 @@
+#!/usr/bin/env python3
+"""Regression tests for source news availability at the forecast boundary."""
+
+from __future__ import annotations
+
+import importlib.util
+import json
+import tempfile
+import unittest
+from pathlib import Path
+
+
+SPEC = importlib.util.spec_from_file_location("sp500_prepare", Path(__file__).with_name("prepare.py"))
+BUILDER = importlib.util.module_from_spec(SPEC)
+SPEC.loader.exec_module(BUILDER)
+
+
+class NewsCutoffTests(unittest.TestCase):
+    def setUp(self) -> None:
+        self.temporary = tempfile.TemporaryDirectory()
+        self.addCleanup(self.temporary.cleanup)
+        self.news_file = Path(self.temporary.name) / "news.jsonl"
+
+    def select(self, records: list[object], **kwargs: object) -> list[str]:
+        self.news_file.write_text(
+            "\n".join(json.dumps(record) for record in records) + "\n", encoding="utf-8",
+        )
+        return BUILDER.load_last_k_news_summaries(
+            str(self.news_file), forecast_start="2024-07-01", **kwargs,
+        )
+
+    def test_excludes_forecast_day_and_later_news(self) -> None:
+        selected = self.select([
+            {"Date": "2024-06-30", "Article": "available before forecast"},
+            {"Date": "2024-07-01", "Article": "at cutoff"},
+            {"Date": "2024-07-10", "Article": "during forecast"},
+            {"Date": "2025-04-18", "Article": "after forecast"},
+        ])
+        self.assertEqual(selected, ["available before forecast"])
+
+    def test_sorts_before_selecting_latest_three(self) -> None:
+        selected = self.select([
+            {"Date": "2024-06-30", "Article": "newest"},
+            {"Date": "2024-06-01", "Article": "oldest"},
+            {"Date": "2024-06-29", "Article": "middle"},
+            {"Date": "2024-06-28", "Article": "third newest"},
+        ])
+        self.assertEqual(selected, ["third newest", "middle", "newest"])
+
+    def test_missing_invalid_dates_and_empty_articles_are_ineligible(self) -> None:
+        selected = self.select([
+            {"Article": "undated"}, {"Date": None, "Article": "null date"},
+            {"Date": 1719705600, "Article": "ambiguous numeric epoch"},
+            {"Date": "06/30/2024", "Article": "ambiguous date format"},
+            {"Date": "2024-02-30", "Article": "invalid day"},
+            {"Date": "2024-06-30", "Article": " "},
+            {"Date": "2024-06-30", "Article": None},
+            {"Date": "2024-06-30", "Article": ["invalid article"]},
+            ["not a news object"],
+        ])
+        self.assertEqual(selected, [])
+
+    def test_exact_timezone_boundary_is_exclusive(self) -> None:
+        selected = self.select([
+            {"Date": "2024-06-30T23:59:59-04:00", "Article": "one second before"},
+            {"Date": "2024-07-01T04:00:00Z", "Article": "at cutoff in UTC"},
+            {"Date": "2024-07-01T12:00:00+08:00", "Article": "same cutoff in Asia"},
+            {"Date": "2024-07-01T04:00:01Z", "Article": "one second after"},
+        ])
+        self.assertEqual(selected, ["one second before"])
+
+    def test_timezone_aware_dates_use_actual_instant(self) -> None:
+        selected = self.select([
+            {"Date": "2024-07-01T03:59:59Z", "Article": "before New York cutoff"},
+            {"Date": "2024-06-30T23:00:00-07:00", "Article": "after New York cutoff"},
+        ])
+        self.assertEqual(selected, ["before New York cutoff"])
+
+    def test_timezone_is_configurable(self) -> None:
+        records = [{"Date": "2024-07-01T03:00:00Z", "Article": "New York only"}]
+        self.assertEqual(self.select(records), ["New York only"])
+        self.assertEqual(self.select(records, timezone="UTC"), [])
+
+    def test_invalid_dst_times_are_rejected(self) -> None:
+        self.assertIsNone(BUILDER.parse_news_timestamp("2024-11-03T01:30:00", "America/New_York"))
+        self.assertIsNone(BUILDER.parse_news_timestamp("2024-03-10T02:30:00", "America/New_York"))
+
+    def test_selection_preserves_auditable_source_metadata(self) -> None:
+        self.select([{"Date": "2024-06-30", "Article": "eligible", "Url": "https://example.org/news"}])
+        selected = BUILDER.load_pre_horizon_news(str(self.news_file), forecast_start="2024-07-01")
+        self.assertEqual(selected[0]["date"], "2024-06-30")
+        self.assertEqual(selected[0]["published_at"], "2024-06-30T04:00:00+00:00")
+        self.assertEqual(selected[0]["url"], "https://example.org/news")
+
+    def test_missing_file_and_no_eligible_news_return_empty(self) -> None:
+        self.assertEqual(BUILDER.load_pre_horizon_news(
+            str(self.news_file), forecast_start="2024-07-01",
+        ), [])
+        self.assertEqual(self.select([{"Date": "2025-04-18", "Article": "future"}]), [])
+
+    def test_cutoff_is_mandatory_and_invalid_selection_is_rejected(self) -> None:
+        with self.assertRaises(TypeError):
+            BUILDER.load_last_k_news_summaries(str(self.news_file))
+        with self.assertRaises(ValueError):
+            BUILDER.load_pre_horizon_news(str(self.news_file), forecast_start="2024-02-30")
+        with self.assertRaises(ValueError):
+            BUILDER.load_pre_horizon_news(str(self.news_file), forecast_start="2024-07-01", k=0)
+
+
+if __name__ == "__main__":
+    unittest.main()

sample/video-timeseries/covla/README.md

@@ -0,0 +1,19 @@
+# CoVLA
+
+**Processing code only:** source data and generated task records are not
+included. Complete the upstream access requirements and follow the source terms.
+See the [shared setup instructions](../../../processing/README.md).
+Run the commands below from the directory containing `MMTA-v1.0/`, keeping
+`local_sources/` and `local_work/` outside the release folder.
+
+Download [CoVLA](https://huggingface.co/datasets/turing-motors/CoVLA-Dataset) with an approved Hugging Face account and unpack the states, front-car signals and videos.
+
+```bash
+python -B MMTA-v1.0/sample/video-timeseries/covla/download.py --output local_sources/covla --accept-terms
+python -B MMTA-v1.0/sample/video-timeseries/covla/generate.py \
+  --source-root local_sources/covla --output-dir local_work/covla_build
+```
+
+Build: braking-event extraction -> signal enrichment -> task prompts -> stratified split -> video/CSV conversion.
+
+Output: `--output-dir/covla/covla.omnits.jsonl`, plus media and history CSVs. Paths are relative to that output domain directory. Use `--split train` to convert the training split where available.

sample/video-timeseries/covla/build_prompts.py

@@ -0,0 +1,274 @@
+#!/usr/bin/env python3
+"""Build local brake-reason task prompts from synchronized source signals."""
+import argparse
+import json
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+
+
+# ── Cause options (English, for prompt) ──────────────────────────────────────
+CAUSE_OPTIONS: dict[str, str] = {
+    "A": "The leading vehicle suddenly decelerated.",
+    "B": "The ego vehicle was making a turn.",
+    "C": (
+        "Other reason "
+        "(e.g., pedestrian about to cross the road, traffic light turning red, "
+        "entering a tunnel, etc.)."
+    ),
+}
+
+# ── Variable descriptions (English) ──────────────────────────────────────────
+VAR_DESC: dict[str, str] = {
+    "vEgo": (
+        "Ego vehicle speed in m/s (forward velocity of the autonomous vehicle)."
+    ),
+    "aEgo": (
+        "Ego vehicle longitudinal acceleration in m/s²; "
+        "negative values indicate deceleration."
+    ),
+    "steeringAngleDeg": (
+        "Steering wheel angle in degrees; "
+        "large non-zero values indicate the vehicle is turning."
+    ),
+    "lead_speed_kmh": (
+        "Speed of the leading (front) vehicle in km/h; "
+        "null if no leading vehicle is detected."
+    ),
+    "lead_a": (
+        "Acceleration of the leading vehicle in m/s²; "
+        "negative values mean the leading vehicle is decelerating; "
+        "null if no leading vehicle is detected."
+    ),
+}
+
+# Variables that go into the prompt timeseries (brake & gas excluded)
+PROMPT_VARS: list[str] = ["vEgo", "aEgo", "steeringAngleDeg", "lead_speed_kmh", "lead_a"]
+
+# Array fields to remove from the final record (they live in the prompt now)
+ARRAYS_TO_DROP: list[str] = [
+    "timestamps",
+    "vEgo",
+    "aEgo",
+    "steeringAngleDeg",
+    "brake",
+    "gas",
+    "lead_speed_kmh",
+    "lead_a",
+]
+
+
+# ── Decimal-precision helper ──────────────────────────────────────────────────
+def choose_decimals_by_avg_diff(values: list[float]) -> int:
+    if len(values) == 0:
+        return 0
+    if len(values) > 1:
+        diffs = [abs(values[i + 1] - values[i]) for i in range(len(values) - 1)]
+        avg_diff = float(np.mean(diffs)) if diffs else 0.0
+    else:
+        avg_diff = abs(values[0]) * 0.01 if values[0] != 0 else 1.0
+
+    if avg_diff == 0:
+        return 0
+    if avg_diff >= 10:
+        return 0
+    if avg_diff >= 1:
+        return 1
+    if avg_diff >= 0.1:
+        return 2
+    if avg_diff >= 0.01:
+        return 3
+    if avg_diff >= 0.001:
+        return 4
+    return 5
+
+
+def fmt_val(v: Any, decimals: int) -> str:
+    if v is None:
+        return "null"
+    try:
+        return f"{float(v):.{decimals}f}"
+    except (TypeError, ValueError):
+        return str(v)
+
+
+def ts_str(v: Any) -> str:
+    if isinstance(v, (int, float)):
+        return f"{v:.1f}s"
+    return str(v)
+
+
+# ── Prompt builder ────────────────────────────────────────────────────────────
+def build_prompt(item: dict[str, Any]) -> str:
+    video_path = item.get("video_path") or ""
+    start_frame: int = item.get("start_frame", 0)
+    end_frame: int = item.get("end_frame", 0)
+    frame_count: int = item.get("frame_count", 0)
+    timestamps: list[Any] = item.get("timestamps") or []
+
+    start_ts = timestamps[0] if timestamps else None
+    end_ts = timestamps[-1] if timestamps else None
+
+    # ── Per-variable rounding ────────────────────────────────────────────────
+    decimals: dict[str, int] = {}
+    rounded: dict[str, list[str]] = {}
+    for var in PROMPT_VARS:
+        raw: list[Any] = item.get(var) or []
+        numeric = [float(v) for v in raw if v is not None]
+        dec = choose_decimals_by_avg_diff(numeric)
+        decimals[var] = dec
+        rounded[var] = [fmt_val(v, dec) for v in raw]
+
+    # ── Time-series block ────────────────────────────────────────────────────
+    example_line = "t(s): vEgo=, aEgo=, steeringAngleDeg=, lead_speed_kmh=, lead_a="
+    ts_lines: list[str] = []
+    for i, t in enumerate(timestamps):
+        t_label = f"{t:.1f}" if isinstance(t, (int, float)) else str(t)
+        parts = [
+            f"{var}={rounded[var][i] if i < len(rounded.get(var, [])) else 'null'}"
+            for var in PROMPT_VARS
+        ]
+        ts_lines.append(f"{t_label}: " + ", ".join(parts))
+    timeseries_block = "\n".join(ts_lines)
+
+    # ── Variable description block ──────────────────────────���────────────────
+    var_block = "\n".join(f"- {var}: {VAR_DESC[var]}" for var in PROMPT_VARS)
+
+    # ── Options block ────────────────────────────────────────────────────────
+    options_lines = ["Answer (choose one option):"]
+    for k, v in CAUSE_OPTIONS.items():
+        options_lines.append(f"{k}. {v}")
+    options_lines += ["", "Return only the option letter (A, B, or C)."]
+    options_block = "\n".join(options_lines)
+
+    # ── Question ─────────────────────────────────────────────────────────────
+    question = (
+        f"Question: Based on the video content and the sensor data above, "
+        f"why did the ego vehicle suddenly brake during the segment ?"
+    )
+
+    prompt = f"""\
+You are given a question-answering (QA) task for autonomous driving.
+
+You are provided with a dashcam video segment from an autonomous driving system (ego vehicle) \
+traveling on public roads. This video is already temporally cropped to only the braking event, \
+and the per-frame sensor data below is aligned to this same braking segment. \
+Your task is to determine the most likely reason for the sudden braking in this segment.
+
+Do NOT output any analysis. Return only the option letter.
+
+<video>
+This video clip contains only the braking segment. The braking segment contains \
+{frame_count} frames. No pre-brake or post-brake frames are included in this clip. The sensor \
+data provided below also contains only this exact braking segment.
+</video>
+
+<variables>
+Sensor variables recorded per frame only within the braking segment:
+{var_block}
+</variables>
+
+<timeseries>
+One-line format example:
+{example_line}
+
+Per-frame sensor data only for the braking segment from braking onset to braking offset \
+(null = not available):
+{timeseries_block}
+</timeseries>
+
+{question}
+{options_block}"""
+
+    return "\n".join(ln.rstrip() for ln in prompt.splitlines()).strip()
+
+
+def build_question(item: dict[str, Any]) -> str:
+    start_frame: int = item.get("start_frame", 0)
+    end_frame: int = item.get("end_frame", 0)
+    timestamps: list[Any] = item.get("timestamps") or []
+    start_ts = timestamps[0] if timestamps else None
+    end_ts = timestamps[-1] if timestamps else None
+    return (
+        f"Based on the video content and the sensor data above, "
+        f"why did the ego vehicle suddenly brake during the segment ?"
+    )
+
+
+# ── Main ──────────────────────────────────────────────────────────────────────
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Build braking-reason prompts and remove redundant raw arrays"
+    )
+    parser.add_argument("--root", type=Path, default=Path("."), help="Dataset root directory")
+    parser.add_argument(
+        "--input",
+        type=Path,
+        default=Path("all_brake_reasons_enriched.jsonl"),
+        help="Input enriched JSONL",
+    )
+    parser.add_argument(
+        "--output",
+        type=Path,
+        default=Path("all_brake_reasons_final.jsonl"),
+        help="Output prompt JSONL",
+    )
+    parser.add_argument(
+        "--sample-output",
+        type=Path,
+        default=Path("all_brake_reasons_final_sample.jsonl"),
+        help="Output inspection JSONL",
+    )
+    parser.add_argument("--sample-size", type=int, default=8, help="Number of inspection records")
+    args = parser.parse_args()
+
+    root = args.root.resolve()
+    input_path = (root / args.input).resolve()
+    output_path = (root / args.output).resolve()
+    sample_path = (root / args.sample_output).resolve()
+
+    total = 0
+    sample_records: list[dict[str, Any]] = []
+
+    with (
+        input_path.open("r", encoding="utf-8") as src,
+        output_path.open("w", encoding="utf-8") as dst,
+    ):
+        for line in src:
+            line = line.strip()
+            if not line:
+                continue
+
+            item: dict[str, Any] = json.loads(line)
+
+            # Build prompt & question BEFORE dropping arrays (they need timestamps etc.)
+            item["prompt"] = build_prompt(item)
+            item["question"] = build_question(item)
+            item["ground_truth"] = item.get("cause_option", "C")
+            item["frames"] = {
+                "start_frame": item.get("start_frame", 0),
+                "end_frame": item.get("end_frame", 0),
+                "frame_count": item.get("frame_count", 0),
+            }
+
+            # Drop raw array fields that are now represented in the prompt
+            for field in ARRAYS_TO_DROP:
+                item.pop(field, None)
+
+            dst.write(json.dumps(item, ensure_ascii=False) + "\n")
+            total += 1
+            if len(sample_records) < args.sample_size:
+                sample_records.append(item)
+
+    with sample_path.open("w", encoding="utf-8") as sf:
+        for r in sample_records:
+            sf.write(json.dumps(r, ensure_ascii=False) + "\n")
+
+    print(f"Processed {total} records")
+    print(f"Complete output: {output_path}")
+    print(f"Inspection output: {sample_path} ({len(sample_records)} records)")
+
+
+if __name__ == "__main__":
+    main()

sample/video-timeseries/covla/download.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python3
+"""Download covla from its official source for local processing."""
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[3] / "processing"))
+from download import main
+
+
+if __name__ == "__main__":
+    main("covla")

sample/video-timeseries/covla/enrich_segments.py

@@ -0,0 +1,214 @@
+#!/usr/bin/env python3
+"""Attach aligned vehicle and lead-car signals to local braking segments."""
+import argparse
+import json
+from pathlib import Path
+from typing import Any
+
+
+def load_frame_dict(file_path: Path) -> dict[int, dict[str, Any] | None]:
+    frame_dict: dict[int, dict[str, Any] | None] = {}
+    with file_path.open("r", encoding="utf-8") as file:
+        for line in file:
+            line = line.strip()
+            if not line:
+                continue
+            item = json.loads(line)
+            if not item:
+                continue
+            frame_key = next(iter(item.keys()))
+            frame_idx = int(frame_key)
+            frame_dict[frame_idx] = item[frame_key]
+    return frame_dict
+
+
+def load_metadata_map(metadata_path: Path, root: Path) -> dict[str, str]:
+    video_path_map: dict[str, str] = {}
+    with metadata_path.open("r", encoding="utf-8") as file:
+        for line in file:
+            line = line.strip()
+            if not line:
+                continue
+            item = json.loads(line)
+            video_id = item.get("video_id")
+            file_name = item.get("file_name")
+            if not isinstance(video_id, str) or not isinstance(file_name, str):
+                continue
+            video_path_map[video_id] = str((root / file_name).resolve())
+    return video_path_map
+
+
+def get_video_start_timestamp(states: dict[int, dict[str, Any] | None]) -> int | None:
+    for frame_idx in sorted(states):
+        info = states.get(frame_idx)
+        if not isinstance(info, dict):
+            continue
+        timestamp = info.get("timestamp")
+        if isinstance(timestamp, (int, float)):
+            return int(timestamp)
+    return None
+
+
+def get_state_value(
+    states: dict[int, dict[str, Any] | None], frame: int, key: str
+) -> Any:
+    info = states.get(frame)
+    if not isinstance(info, dict):
+        return None
+    return info.get(key)
+
+
+def get_front_car_value(
+    front_car: dict[int, dict[str, Any] | None], frame: int, key: str
+) -> Any:
+    info = front_car.get(frame)
+    if not isinstance(info, dict):
+        return None
+    return info.get(key)
+
+
+def build_record(
+    item: dict[str, Any],
+    states: dict[int, dict[str, Any] | None],
+    front_car: dict[int, dict[str, Any] | None],
+    video_abs_path: str | None,
+) -> dict[str, Any]:
+    frames = item.get("frames", [])
+    if not isinstance(frames, list):
+        frames = []
+
+    video_start_ts = get_video_start_timestamp(states)
+
+    
+    timestamps: list[float | None] = []
+    v_ego: list[Any] = []
+    a_ego: list[Any] = []
+    steering_angle_deg: list[Any] = []
+    brake: list[Any] = []
+    gas: list[Any] = []
+    lead_speed_kmh: list[Any] = []
+    lead_a: list[Any] = []
+
+    for frame in frames:
+        if not isinstance(frame, int):
+            timestamps.append(None)
+            v_ego.append(None)
+            a_ego.append(None)
+            steering_angle_deg.append(None)
+            brake.append(None)
+            gas.append(None)
+            lead_speed_kmh.append(None)
+            lead_a.append(None)
+            continue
+
+        raw_ts = get_state_value(states, frame, "timestamp")
+        if isinstance(raw_ts, (int, float)) and video_start_ts is not None:
+            timestamps.append(round((float(raw_ts) - float(video_start_ts)) / 1000.0, 3))
+        else:
+            timestamps.append(None)
+
+        v_ego.append(get_state_value(states, frame, "vEgo"))
+        a_ego.append(get_state_value(states, frame, "aEgo"))
+        steering_angle_deg.append(get_state_value(states, frame, "steeringAngleDeg"))
+        brake.append(get_state_value(states, frame, "brake"))
+        gas.append(get_state_value(states, frame, "gas"))
+        lead_speed_kmh.append(get_front_car_value(front_car, frame, "lead_speed_kmh"))
+        lead_a.append(get_front_car_value(front_car, frame, "lead_a"))
+
+    enriched_item = dict(item)
+    enriched_item["timestamps"] = timestamps
+    enriched_item["vEgo"] = v_ego
+    enriched_item["aEgo"] = a_ego
+    enriched_item["steeringAngleDeg"] = steering_angle_deg
+    enriched_item["brake"] = brake
+    enriched_item["gas"] = gas
+    enriched_item["lead_speed_kmh"] = lead_speed_kmh
+    enriched_item["lead_a"] = lead_a
+    enriched_item["video_path"] = video_abs_path
+    return enriched_item
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Enrich braking segments with synchronized state and lead-vehicle signals")
+    parser.add_argument("--root", type=Path, default=Path("."), help="Dataset root directory")
+    parser.add_argument(
+        "--input",
+        type=Path,
+        default=Path("all_brake_reasons.jsonl"),
+        help="Input merged braking-segment JSONL",
+    )
+    parser.add_argument(
+        "--output",
+        type=Path,
+        default=Path("all_brake_reasons_enriched.jsonl"),
+        help="Output enriched JSONL",
+    )
+    parser.add_argument(
+        "--sample-output",
+        type=Path,
+        default=Path("all_brake_reasons_enriched_sample.jsonl"),
+        help="Small inspection JSONL",
+    )
+    parser.add_argument(
+        "--sample-size",
+        type=int,
+        default=8,
+        help="Number of inspection records (default: 8)",
+    )
+    args = parser.parse_args()
+
+    root = args.root.resolve()
+    input_path = (root / args.input).resolve()
+    output_path = (root / args.output).resolve()
+    sample_output_path = (root / args.sample_output).resolve()
+    metadata_path = root / "metadata.jsonl"
+    states_dir = root / "states"
+    front_car_dir = root / "front_car"
+
+    video_path_map = load_metadata_map(metadata_path, root)
+    states_cache: dict[str, dict[int, dict[str, Any] | None]] = {}
+    front_car_cache: dict[str, dict[int, dict[str, Any] | None]] = {}
+
+    total_records = 0
+    sample_records: list[dict[str, Any]] = []
+
+    with input_path.open("r", encoding="utf-8") as src, output_path.open("w", encoding="utf-8") as dst:
+        for line in src:
+            line = line.strip()
+            if not line:
+                continue
+
+            item = json.loads(line)
+            video_id = item.get("video_id")
+            if not isinstance(video_id, str):
+                continue
+
+            if video_id not in states_cache:
+                states_cache[video_id] = load_frame_dict(states_dir / f"{video_id}.jsonl")
+            if video_id not in front_car_cache:
+                front_car_cache[video_id] = load_frame_dict(front_car_dir / f"{video_id}.jsonl")
+
+            enriched_item = build_record(
+                item=item,
+                states=states_cache[video_id],
+                front_car=front_car_cache[video_id],
+                video_abs_path=video_path_map.get(video_id),
+            )
+
+            dst.write(json.dumps(enriched_item, ensure_ascii=False) + "\n")
+            total_records += 1
+
+            if len(sample_records) < max(args.sample_size, 0):
+                sample_records.append(enriched_item)
+
+    with sample_output_path.open("w", encoding="utf-8") as sample_file:
+        for item in sample_records:
+            sample_file.write(json.dumps(item, ensure_ascii=False) + "\n")
+
+    print(f"Enriched records written to: {output_path}")
+    print(f"Inspection records written to: {sample_output_path}")
+    print(f"Processed {total_records} records; inspection set has {len(sample_records)} records.")
+
+
+if __name__ == "__main__":
+    main()

sample/video-timeseries/covla/extract_brake_reasons.py

@@ -0,0 +1,197 @@
+#!/usr/bin/env python3
+"""Extract continuous braking segments with one synchronized cause label."""
+import argparse
+import json
+from pathlib import Path
+from typing import Any
+
+
+CAUSE_MAP = {
+    "A": "The leading vehicle suddenly decelerated",
+    "B": "Turning",
+    "C": "Other reasons",
+}
+
+
+def load_frame_dict(file_path: Path) -> dict[int, dict[str, Any] | None]:
+    frame_dict: dict[int, dict[str, Any] | None] = {}
+    with file_path.open("r", encoding="utf-8") as file:
+        for line in file:
+            line = line.strip()
+            if not line:
+                continue
+            item = json.loads(line)
+            if not item:
+                continue
+            frame_key = next(iter(item.keys()))
+            frame_idx = int(frame_key)
+            frame_dict[frame_idx] = item[frame_key]
+    return frame_dict
+
+
+def get_true_segments(frames: list[int], min_length: int) -> list[list[int]]:
+    if not frames:
+        return []
+
+    frames = sorted(frames)
+    segments: list[list[int]] = []
+    current = [frames[0]]
+
+    for frame in frames[1:]:
+        if frame == current[-1] + 1:
+            current.append(frame)
+        else:
+            if len(current) >= min_length:
+                segments.append(current)
+            current = [frame]
+
+    if len(current) >= min_length:
+        segments.append(current)
+
+    return segments
+
+
+def condition_a(frame: int, front_car: dict[int, dict[str, Any] | None]) -> bool:
+    info = front_car.get(frame)
+    if not isinstance(info, dict):
+        return False
+    lead_a = info.get("lead_a")
+    if lead_a is None:
+        return False
+    try:
+        return float(lead_a) < 0
+    except (TypeError, ValueError):
+        return False
+
+
+def condition_b(frame: int, states: dict[int, dict[str, Any] | None]) -> bool:
+    info = states.get(frame)
+    if not isinstance(info, dict):
+        return False
+    return bool(info.get("leftBlinker") is True or info.get("rightBlinker") is True)
+
+
+def detect_segment_cause(
+    segment_frames: list[int],
+    states: dict[int, dict[str, Any] | None],
+    front_car: dict[int, dict[str, Any] | None],
+) -> list[str]:
+    a_frames = [frame for frame in segment_frames if condition_a(frame, front_car)]
+    b_frames = [frame for frame in segment_frames if condition_b(frame, states)]
+
+    
+    a_hit = bool(get_true_segments(a_frames, min_length=2))
+    b_hit = bool(get_true_segments(b_frames, min_length=2))
+
+    if a_hit and b_hit:
+        return ["A", "B"]
+    if a_hit:
+        return ["A"]
+    if b_hit:
+        return ["B"]
+    return ["C"]
+
+
+def process_video(
+    video_id: str,
+    states_path: Path,
+    front_car_path: Path,
+    min_length: int,
+) -> list[dict[str, Any]]:
+    states = load_frame_dict(states_path)
+    front_car = load_frame_dict(front_car_path)
+
+    brake_true_frames = [
+        frame
+        for frame, info in states.items()
+        if isinstance(info, dict) and info.get("brakePressed") is True
+    ]
+
+    segments = get_true_segments(brake_true_frames, min_length=min_length)
+    results: list[dict[str, Any]] = []
+
+    for segment in segments:
+        causes = detect_segment_cause(segment, states, front_car)
+        if len(causes) != 1:
+            continue
+
+        cause = causes[0]
+        start_frame = segment[0]
+        end_frame = segment[-1]
+        start_ts = None
+        end_ts = None
+
+        start_info = states.get(start_frame)
+        end_info = states.get(end_frame)
+        if isinstance(start_info, dict):
+            start_ts = start_info.get("timestamp")
+        if isinstance(end_info, dict):
+            end_ts = end_info.get("timestamp")
+
+        results.append(
+            {
+                "video_id": video_id,
+                "start_frame": start_frame,
+                "end_frame": end_frame,
+                "frame_count": len(segment),
+                "frames": segment,
+                "start_timestamp": start_ts,
+                "end_timestamp": end_ts,
+                "cause_option": cause,
+                "cause_text": CAUSE_MAP[cause],
+            }
+        )
+
+    return results
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Extract continuous braking segments with a unique cause label")
+    parser.add_argument("--root", type=Path, default=Path("."), help="Dataset root directory")
+    parser.add_argument("--output-dir", type=Path, default=Path("brake_reasons"), help="Output directory")
+    parser.add_argument("--min-length", type=int, default=6, help="Minimum consecutive braking frames (default: 6)")
+    args = parser.parse_args()
+
+    root = args.root.resolve()
+    states_dir = root / "states"
+    front_car_dir = root / "front_car"
+    output_dir = (root / args.output_dir).resolve()
+    output_dir.mkdir(parents=True, exist_ok=True)
+    merged_output_file = output_dir / "all_brake_reasons.jsonl"
+
+    state_files = sorted(states_dir.glob("*.jsonl"))
+    total_files = 0
+    total_segments = 0
+
+    with merged_output_file.open("w", encoding="utf-8") as merged_file:
+        for states_file in state_files:
+            video_id = states_file.stem
+            front_car_file = front_car_dir / f"{video_id}.jsonl"
+
+            if not front_car_file.exists():
+                continue
+
+            results = process_video(
+                video_id=video_id,
+                states_path=states_file,
+                front_car_path=front_car_file,
+                min_length=args.min_length,
+            )
+
+            out_file = output_dir / f"{video_id}.jsonl"
+            with out_file.open("w", encoding="utf-8") as file:
+                for item in results:
+                    line = json.dumps(item, ensure_ascii=False)
+                    file.write(line + "\n")
+                    merged_file.write(line + "\n")
+
+            total_files += 1
+            total_segments += len(results)
+
+    print(f"Processed {total_files} files; wrote {total_segments} uniquely labeled braking segments.")
+    print(f"Output directory：{output_dir}")
+    print(f"Merged output: {merged_output_file}")
+
+
+if __name__ == "__main__":
+    main()

sample/video-timeseries/covla/generate.py

@@ -0,0 +1,13 @@
+#!/usr/bin/env python3
+"""Generate local CoVLA braking tasks and unified video/time-series records."""
+
+import sys
+from pathlib import Path
+
+sys.dont_write_bytecode = True
+sys.path.insert(0, str(Path(__file__).resolve().parents[3] / "processing" / "common"))
+from local_generation import main
+
+
+if __name__ == "__main__":
+    main("covla")

sample/video-timeseries/covla/split_dataset.py

@@ -0,0 +1,160 @@
+#!/usr/bin/env python3
+"""Construct reproducible A/B/C stratified splits from local CoVLA tasks."""
+import argparse
+import json
+import random
+from pathlib import Path
+from typing import Any
+
+
+def get_label(item: dict[str, Any]) -> str:
+    label = item.get("ground_truth") or item.get("cause_option")
+    if label in {"A", "B", "C"}:
+        return str(label)
+    return "C"
+
+
+def ratio_str(counts: dict[str, int]) -> str:
+    return f"A:{counts['A']} B:{counts['B']} C:{counts['C']}"
+
+
+def split_stratified(
+    items: list[dict[str, Any]], test_ratio: float, seed: int
+) -> tuple[list[dict[str, Any]], list[dict[str, Any]], dict[str, dict[str, int]]]:
+    groups: dict[str, list[dict[str, Any]]] = {"A": [], "B": [], "C": []}
+    for item in items:
+        groups[get_label(item)].append(item)
+
+    rng = random.Random(seed)
+    train: list[dict[str, Any]] = []
+    test: list[dict[str, Any]] = []
+
+    counts = {
+        "all": {"A": 0, "B": 0, "C": 0},
+        "train": {"A": 0, "B": 0, "C": 0},
+        "test": {"A": 0, "B": 0, "C": 0},
+    }
+
+    for cls in ("A", "B", "C"):
+        cls_items = groups[cls]
+        rng.shuffle(cls_items)
+        n = len(cls_items)
+        counts["all"][cls] = n
+
+        # 10:1 => test_ratio = 1/11
+        n_test = int(round(n * test_ratio))
+        if n > 1 and n_test == 0:
+            n_test = 1
+        if n_test >= n:
+            n_test = max(0, n - 1)
+
+        cls_test = cls_items[:n_test]
+        cls_train = cls_items[n_test:]
+        test.extend(cls_test)
+        train.extend(cls_train)
+        counts["test"][cls] = len(cls_test)
+        counts["train"][cls] = len(cls_train)
+
+    rng.shuffle(train)
+    rng.shuffle(test)
+    return train, test, counts
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Split train/test by A/B/C labels at approximately 10:1")
+    parser.add_argument("--root", type=Path, default=Path("."), help="Dataset root directory")
+    parser.add_argument(
+        "--input",
+        type=Path,
+        default=Path("all_brake_reasons_final.jsonl"),
+        help="Input JSONL",
+    )
+    parser.add_argument(
+        "--train-output",
+        type=Path,
+        default=Path("all_brake_reasons_final_train.jsonl"),
+        help="Output training JSONL",
+    )
+    parser.add_argument(
+        "--test-output",
+        type=Path,
+        default=Path("all_brake_reasons_final_test.jsonl"),
+        help="Output test JSONL",
+    )
+    parser.add_argument(
+        "--stats-output",
+        type=Path,
+        default=Path("all_brake_reasons_final_split_stats.json"),
+        help="Output split statistics",
+    )
+    parser.add_argument(
+        "--seed",
+        type=int,
+        default=42,
+        help="Random seed for reproducibility",
+    )
+    args = parser.parse_args()
+
+    root = args.root.resolve()
+    input_path = (root / args.input).resolve()
+    train_path = (root / args.train_output).resolve()
+    test_path = (root / args.test_output).resolve()
+    stats_path = (root / args.stats_output).resolve()
+
+    items: list[dict[str, Any]] = []
+    with input_path.open("r", encoding="utf-8") as file:
+        for line in file:
+            line = line.strip()
+            if not line:
+                continue
+            items.append(json.loads(line))
+
+    # 10:1 -> test ratio 1/(10+1)
+    test_ratio = 1.0 / 11.0
+    train, test, counts = split_stratified(items, test_ratio=test_ratio, seed=args.seed)
+
+    with train_path.open("w", encoding="utf-8") as file:
+        for idx, item in enumerate(train):
+            out_item = dict(item)
+            out_item["task_id"] = idx
+            out_item["split"] = "train"
+            out_item["evaluation_type"] = "qa"
+            out_item["task_type"] = "COVLA_TASK"
+            out_item["sub_dimension"] = "brake_reason"
+            file.write(json.dumps(out_item, ensure_ascii=False) + "\n")
+
+    with test_path.open("w", encoding="utf-8") as file:
+        for idx, item in enumerate(test):
+            out_item = dict(item)
+            out_item["task_id"] = idx
+            out_item["split"] = "test"
+            out_item["evaluation_type"] = "qa"
+            out_item["task_type"] = "COVLA_TASK"
+            out_item["sub_dimension"] = "brake_reason"
+            file.write(json.dumps(out_item, ensure_ascii=False) + "\n")
+
+    total = len(items)
+    train_n = len(train)
+    test_n = len(test)
+    stats = {
+        "total": total,
+        "train": train_n,
+        "test": test_n,
+        "actual_train_test_ratio": round(train_n / test_n, 4) if test_n else None,
+        "class_counts": counts,
+    }
+    with stats_path.open("w", encoding="utf-8") as file:
+        json.dump(stats, file, ensure_ascii=False, indent=2)
+
+    print("Split done.")
+    print(f"total={total} train={train_n} test={test_n}")
+    print(f"all   -> {ratio_str(counts['all'])}")
+    print(f"train -> {ratio_str(counts['train'])}")
+    print(f"test  -> {ratio_str(counts['test'])}")
+    print(f"train file: {train_path}")
+    print(f"test file: {test_path}")
+    print(f"stats file: {stats_path}")
+
+
+if __name__ == "__main__":
+    main()

sample/video-timeseries/cuhk_x_har/README.md

@@ -0,0 +1,19 @@
+# CUHK-X HAR
+
+**Processing code only:** source data and generated task records are not
+included. Complete the upstream data-use agreement and follow its terms.
+See the [shared setup instructions](../../../processing/README.md).
+Run the commands below from the directory containing `MMTA-v1.0/`, keeping
+`local_sources/` and `local_work/` outside the release folder.
+
+Download [CUHK-X](https://github.com/openaiotlab/CUHK-X) from its official portal after completing the data-use agreement. Unpack the matching IMU and Skeleton action/user/trial trees. Use --file CUHK-S/HAR/ARCHIVE_NAME with download.py to download a selected archive.
+
+```bash
+python -B MMTA-v1.0/sample/video-timeseries/cuhk_x_har/download.py --output local_sources/cuhk_x_har --list-directory CUHK-S/HAR --accept-terms
+python -B MMTA-v1.0/sample/video-timeseries/cuhk_x_har/generate.py \
+  --source-root local_sources/cuhk_x_har/data --output-dir local_work/cuhk_x_build
+```
+
+Build: Excel/CSV streams -> skeleton videos at 20 fps -> IMU/video trial matching -> up to five observations per second per device -> action prompts and split -> video/CSV conversion.
+
+Output: `--output-dir/cuhk_x_har/cuhk_x_har.omnits.jsonl`, plus media and history CSVs. Paths are relative to that output domain directory. Use `--split train` to convert the training split where available.

sample/video-timeseries/cuhk_x_har/download.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python3
+"""Download cuhk_x_har from its official source for local processing."""
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[3] / "processing"))
+from download import main
+
+
+if __name__ == "__main__":
+    main("cuhk_x_har")

sample/video-timeseries/cuhk_x_har/generate.py

@@ -0,0 +1,13 @@
+#!/usr/bin/env python3
+"""Generate local CUHK-X records from raw IMU and skeleton trials."""
+
+import sys
+from pathlib import Path
+
+sys.dont_write_bytecode = True
+sys.path.insert(0, str(Path(__file__).resolve().parents[3] / "processing" / "common"))
+from local_generation import main
+
+
+if __name__ == "__main__":
+    main("cuhk_x_har")

sample/video-timeseries/cuhk_x_har/images_to_video.py

@@ -0,0 +1,239 @@
+#!/usr/bin/env python3
+"""Adapted from the original dataset construction script."""
+
+import argparse
+import re
+import shutil
+import sys
+from pathlib import Path
+
+try:
+    import cv2
+    import numpy as np
+except ImportError:
+    print("Install opencv-python-headless to render skeleton videos.")
+    sys.exit(1)
+IMAGE_EXTS = {".jpg", ".jpeg", ".png", ".bmp", ".tif", ".tiff", ".webp"}
+
+
+def natural_key(path: Path):
+    parts = re.split("(\\d+)", path.name)
+    return [int(p) if p.isdigit() else p.lower() for p in parts]
+
+
+def get_images_in_dir(folder: Path):
+    images = [
+        p for p in folder.iterdir() if p.is_file() and p.suffix.lower() in IMAGE_EXTS
+    ]
+    images.sort(key=natural_key)
+    return images
+
+
+def find_image_folders(root: Path, only_subdir_name: str | None = None):
+    image_dirs = []
+    for folder in root.rglob("*"):
+        if folder.is_dir():
+            if only_subdir_name and folder.name != only_subdir_name:
+                continue
+            imgs = get_images_in_dir(folder)
+            if imgs:
+                image_dirs.append((folder, imgs))
+    return image_dirs
+
+
+def to_bgr(frame):
+    if len(frame.shape) == 2:
+        return cv2.cvtColor(frame, cv2.COLOR_GRAY2BGR)
+    if frame.shape[2] == 4:
+        return cv2.cvtColor(frame, cv2.COLOR_BGRA2BGR)
+    return frame
+
+
+def detect_split_x_auto(frame):
+    frame = to_bgr(frame)
+    height, width = frame.shape[:2]
+    if width < 4:
+        return max(1, width // 2)
+    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+    col_mean = gray.mean(axis=0)
+    grad = np.abs(np.diff(col_mean))
+    left = max(1, int(width * 0.3))
+    right = min(width - 2, int(width * 0.7))
+    if right <= left:
+        return max(1, width // 2)
+    local = grad[left:right]
+    if local.size == 0:
+        return max(1, width // 2)
+    idx_local = int(np.argmax(local))
+    best_x = left + idx_local + 1
+    if local[idx_local] < 2.0:
+        return max(1, width // 2)
+    return max(1, min(width - 1, best_x))
+
+
+def get_crop_x(frame, split_mode: str, split_x: int | None):
+    width = frame.shape[1]
+    if split_mode == "none":
+        return None
+    if split_mode == "left-half":
+        return max(1, width // 2)
+    if split_mode == "manual":
+        if split_x is None:
+            raise ValueError("Manual cropping requires --split-x")
+        return max(1, min(width - 1, split_x))
+    if split_mode == "auto":
+        return detect_split_x_auto(frame)
+    raise ValueError(f"Unknown cropping mode: {split_mode}")
+
+
+def apply_left_crop(frame, crop_x):
+    frame = to_bgr(frame)
+    if crop_x is None:
+        return frame
+    return frame[:, :crop_x]
+
+
+def build_output_path(output_dir: Path, fps: int, split_mode: str):
+    suffix = "" if split_mode == "none" else f"_{split_mode}"
+    return output_dir / f"{output_dir.name}_{fps}fps{suffix}.mp4"
+
+
+def resolve_output_dir(image_folder: Path, image_subdir_name: str | None):
+    if image_subdir_name and image_folder.name == image_subdir_name:
+        return image_folder.parent
+    return image_folder
+
+
+def write_video_from_images(
+    image_folder: Path,
+    images,
+    fps: int,
+    overwrite: bool,
+    split_mode: str,
+    split_x: int | None,
+    image_subdir_name: str | None,
+    source_root: Path | None = None,
+    output_root: Path | None = None,
+):
+    output_dir = resolve_output_dir(image_folder, image_subdir_name)
+    if output_root is not None:
+        output_dir = output_root / output_dir.relative_to(source_root)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    out_path = build_output_path(output_dir, fps, split_mode)
+    if out_path.exists() and (not overwrite):
+        print(f"[skip] Already exists: {out_path}")
+        return True
+    first = cv2.imread(str(images[0]), cv2.IMREAD_UNCHANGED)
+    if first is None:
+        print(f"[warn] Cannot read first frame: {images[0]}")
+        return False
+    first = to_bgr(first)
+    crop_x = get_crop_x(first, split_mode, split_x)
+    first = apply_left_crop(first, crop_x)
+    height, width = first.shape[:2]
+    fourcc = cv2.VideoWriter_fourcc(*"mp4v")
+    writer = cv2.VideoWriter(str(out_path), fourcc, fps, (width, height))
+    if not writer.isOpened():
+        print(f"[error] Cannot create video: {out_path}")
+        return False
+    written = 0
+    for img_path in images:
+        frame = cv2.imread(str(img_path), cv2.IMREAD_UNCHANGED)
+        if frame is None:
+            print(f"[warn] Skipping unreadable image: {img_path}")
+            continue
+        frame = to_bgr(frame)
+        frame = apply_left_crop(frame, crop_x)
+        if frame.shape[1] != width or frame.shape[0] != height:
+            frame = cv2.resize(frame, (width, height), interpolation=cv2.INTER_AREA)
+        writer.write(frame)
+        written += 1
+    writer.release()
+    if written == 0:
+        print(f"[error] No frames written: {image_folder}")
+        return False
+    crop_msg = f", crop_x={crop_x}" if crop_x is not None else ""
+    print(f"[ok] {image_folder} -> {out_path} (frames={written}, fps={fps}{crop_msg})")
+    return True
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Render ordered skeleton images at a fixed frame rate."
+    )
+    parser.add_argument("root", help="Skeleton source root.")
+    parser.add_argument(
+        "--output-root",
+        type=Path,
+        help="Preserve trial paths in a separate output tree.",
+    )
+    parser.add_argument("--fps", type=int, default=20, help="Output frame rate.")
+    parser.add_argument(
+        "--image-subdir-name",
+        default="visualizations",
+        help="Image folder stored inside each trial.",
+    )
+    parser.add_argument(
+        "--only-image-subdir",
+        action="store_true",
+        help="Only process the named image subdirectory.",
+    )
+    parser.add_argument(
+        "--split-mode",
+        choices=["left-half", "auto", "manual", "none"],
+        default="left-half",
+        help="Image cropping mode.",
+    )
+    parser.add_argument(
+        "--split-x", type=int, default=None, help="Manual crop boundary."
+    )
+    parser.add_argument(
+        "--overwrite", action="store_true", help="Replace existing output videos."
+    )
+    args = parser.parse_args()
+    root = Path(args.root).resolve()
+    if not root.exists() or not root.is_dir():
+        print(f"Input directory not found: {root}")
+        sys.exit(1)
+    if args.fps < 1:
+        parser.error("--fps must be positive")
+    output_root = args.output_root.resolve() if args.output_root else None
+    if output_root is not None and output_root.is_relative_to(root):
+        parser.error("--output-root must be outside the skeleton input tree")
+    subdir_filter = args.image_subdir_name if args.only_image_subdir else None
+    image_folders = find_image_folders(root, only_subdir_name=subdir_filter)
+    print(f"Found {len(image_folders)} image directories")
+    ok_count = 0
+    for image_folder, images in image_folders:
+        if write_video_from_images(
+            image_folder,
+            images,
+            args.fps,
+            args.overwrite,
+            args.split_mode,
+            args.split_x,
+            args.image_subdir_name,
+            root,
+            output_root,
+        ):
+            ok_count += 1
+    if output_root is not None:
+        for path in sorted(root.rglob("*")):
+            if not path.is_file() or path.suffix.lower() not in {
+                ".mp4",
+                ".avi",
+                ".mov",
+                ".mkv",
+            }:
+                continue
+            target = output_root / path.relative_to(root)
+            if not target.parent.exists() or not any(target.parent.glob("*.mp4")):
+                target.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copy2(path, target)
+    print(f"Completed {ok_count}/{len(image_folders)} image directories")
+    if ok_count < len(image_folders):
+        raise RuntimeError("Some skeleton videos could not be generated")
+
+
+if __name__ == "__main__":
+    main()

sample/video-timeseries/cuhk_x_har/imu_skeleton_to_jsonl.py

@@ -0,0 +1,215 @@
+#!/usr/bin/env python3
+"""Adapted from the original dataset construction script."""
+
+import argparse
+import json
+import os
+from pathlib import Path
+import numpy as np
+import pandas as pd
+
+TIME_COL = "time"
+DEVICE_COL = "device_name"
+ACC_X_COL = "acc_x_g"
+ACC_Y_COL = "acc_y_g"
+ACC_Z_COL = "acc_z_g"
+GYRO_X_COL = "gyro_x_dps"
+GYRO_Y_COL = "gyro_y_dps"
+GYRO_Z_COL = "gyro_z_dps"
+SOURCE_COLUMN_ALIASES = {
+    "\u65f6\u95f4": TIME_COL,
+    "\u8bbe\u5907\u540d\u79f0": DEVICE_COL,
+    "\u52a0\u901f\u5ea6X(g)": ACC_X_COL,
+    "\u52a0\u901f\u5ea6Y(g)": ACC_Y_COL,
+    "\u52a0\u901f\u5ea6Z(g)": ACC_Z_COL,
+    "\u89d2\u901f\u5ea6X(\u00b0/s)": GYRO_X_COL,
+    "\u89d2\u901f\u5ea6Y(\u00b0/s)": GYRO_Y_COL,
+    "\u89d2\u901f\u5ea6Z(\u00b0/s)": GYRO_Z_COL,
+}
+REQUIRED_COLS = [
+    TIME_COL,
+    DEVICE_COL,
+    ACC_X_COL,
+    ACC_Y_COL,
+    ACC_Z_COL,
+    GYRO_X_COL,
+    GYRO_Y_COL,
+    GYRO_Z_COL,
+]
+VIDEO_SUFFIXES = {".mp4", ".avi", ".mov", ".mkv", ".MP4", ".AVI", ".MOV", ".MKV"}
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Convert aligned IMU + Skeleton data to JSONL"
+    )
+    parser.add_argument("--imu-root", type=Path, default=Path("IMU"))
+    parser.add_argument("--skeleton-root", type=Path, default=Path("Skeleton"))
+    parser.add_argument(
+        "--output", type=Path, default=Path("imu_skeleton_aligned.jsonl")
+    )
+    parser.add_argument("--max-records", type=int, default=0)
+    parser.add_argument("--relative-video-path", action="store_true")
+    return parser.parse_args()
+
+
+def clean_columns(df: pd.DataFrame) -> pd.DataFrame:
+    df.columns = [str(col).strip().lstrip("\ufeff") for col in df.columns]
+    return df.rename(columns=SOURCE_COLUMN_ALIASES)
+
+
+def read_imu_pair(csv_files: list[Path]) -> pd.DataFrame:
+    frames = []
+    for csv_file in csv_files:
+        frame = pd.read_csv(csv_file)
+        frame = clean_columns(frame)
+        missing_cols = [col for col in REQUIRED_COLS if col not in frame.columns]
+        if missing_cols:
+            raise ValueError(f"Missing columns in {csv_file}: {missing_cols}")
+        frames.append(frame[REQUIRED_COLS].copy())
+    merged = pd.concat(frames, ignore_index=True)
+    merged[TIME_COL] = pd.to_datetime(merged[TIME_COL], errors="coerce")
+    merged = (
+        merged.dropna(subset=[TIME_COL]).sort_values(TIME_COL).reset_index(drop=True)
+    )
+    merged[DEVICE_COL] = (
+        merged[DEVICE_COL]
+        .astype(str)
+        .str.split("(", n=1, regex=False)
+        .str[0]
+        .str.strip()
+    )
+    for col in [ACC_X_COL, ACC_Y_COL, ACC_Z_COL, GYRO_X_COL, GYRO_Y_COL, GYRO_Z_COL]:
+        merged[col] = pd.to_numeric(merged[col], errors="coerce")
+    merged = merged.dropna(
+        subset=[ACC_X_COL, ACC_Y_COL, ACC_Z_COL, GYRO_X_COL, GYRO_Y_COL, GYRO_Z_COL]
+    )
+    return merged
+
+
+def sample_group(group_df: pd.DataFrame, target_count: int = 5) -> pd.DataFrame:
+    n = len(group_df)
+    if n <= target_count:
+        return group_df
+    idx = np.linspace(0, n - 1, target_count, dtype=int)
+    return group_df.iloc[idx]
+
+
+def downsample_per_second_per_device(df: pd.DataFrame) -> pd.DataFrame:
+    df = df.copy()
+    df["_second"] = df[TIME_COL].dt.floor("s")
+    sampled_parts = []
+    for _, group_df in df.groupby(["_second", DEVICE_COL], sort=True):
+        sampled_parts.append(sample_group(group_df.sort_values(TIME_COL)))
+    if sampled_parts:
+        sampled = pd.concat(sampled_parts, ignore_index=True)
+    else:
+        sampled = df.iloc[0:0].copy()
+    sampled = sampled.sort_values([TIME_COL, DEVICE_COL]).reset_index(drop=True)
+    return sampled
+
+
+def to_output_record(
+    video_path: Path, sampled_df: pd.DataFrame, relative_root: Path | None
+) -> dict:
+    if relative_root is None:
+        video_path_str = str(video_path.resolve())
+    else:
+        video_path_str = os.path.relpath(video_path.resolve(), relative_root.resolve())
+    time_strings = (
+        sampled_df[TIME_COL].dt.strftime("%Y-%m-%d %H:%M:%S.%f").str[:-3].tolist()
+    )
+    return {
+        "video_path": video_path_str,
+        "downsampled_data": {
+            "time": time_strings,
+            "device_name": sampled_df[DEVICE_COL].tolist(),
+            "acc_x_g": sampled_df[ACC_X_COL].tolist(),
+            "acc_y_g": sampled_df[ACC_Y_COL].tolist(),
+            "acc_z_g": sampled_df[ACC_Z_COL].tolist(),
+            "gyro_x_dps": sampled_df[GYRO_X_COL].tolist(),
+            "gyro_y_dps": sampled_df[GYRO_Y_COL].tolist(),
+            "gyro_z_dps": sampled_df[GYRO_Z_COL].tolist(),
+        },
+    }
+
+
+def get_video_file(skeleton_trial_dir: Path) -> Path | None:
+    if not skeleton_trial_dir.exists() or not skeleton_trial_dir.is_dir():
+        return None
+    video_files = sorted(
+        [
+            p
+            for p in skeleton_trial_dir.iterdir()
+            if p.is_file() and p.suffix in VIDEO_SUFFIXES
+        ]
+    )
+    if not video_files:
+        return None
+    return video_files[0]
+
+
+def build_jsonl(
+    imu_root: Path,
+    skeleton_root: Path,
+    output: Path,
+    max_records: int,
+    relative_video_path: bool,
+) -> None:
+    output.parent.mkdir(parents=True, exist_ok=True)
+    total_written = 0
+    skipped = 0
+    relative_root = output.parent if relative_video_path else None
+    with output.open("w", encoding="utf-8") as f_out:
+        for action_dir in sorted([p for p in imu_root.iterdir() if p.is_dir()]):
+            for user_dir in sorted([p for p in action_dir.iterdir() if p.is_dir()]):
+                for trial_dir in sorted([p for p in user_dir.iterdir() if p.is_dir()]):
+                    csv_files = sorted(
+                        [p for p in trial_dir.glob("*.csv") if p.is_file()]
+                    )
+                    if len(csv_files) < 2:
+                        skipped += 1
+                        continue
+                    csv_files = csv_files[:2]
+                    skeleton_trial_dir = (
+                        skeleton_root / action_dir.name / user_dir.name / trial_dir.name
+                    )
+                    video_file = get_video_file(skeleton_trial_dir)
+                    if video_file is None:
+                        skipped += 1
+                        continue
+                    try:
+                        merged_df = read_imu_pair(csv_files)
+                        sampled_df = downsample_per_second_per_device(merged_df)
+                        if sampled_df.empty:
+                            raise ValueError("No valid IMU observations")
+                    except Exception as exc:
+                        print(f"[skip] {trial_dir} -> {exc}")
+                        skipped += 1
+                        continue
+                    record = to_output_record(video_file, sampled_df, relative_root)
+                    f_out.write(
+                        json.dumps(record, ensure_ascii=False, allow_nan=False) + "\n"
+                    )
+                    total_written += 1
+                    if max_records > 0 and total_written >= max_records:
+                        print(
+                            f"Done. written={total_written}, skipped={skipped}, output={output}"
+                        )
+                        return
+    print(f"Done. written={total_written}, skipped={skipped}, output={output}")
+
+
+def main() -> None:
+    args = parse_args()
+    build_jsonl(
+        imu_root=args.imu_root,
+        skeleton_root=args.skeleton_root,
+        output=args.output,
+        max_records=args.max_records,
+        relative_video_path=args.relative_video_path,
+    )
+
+
+if __name__ == "__main__":
+    main()

sample/video-timeseries/cuhk_x_har/prepare.py

@@ -0,0 +1,498 @@
+#!/usr/bin/env python3
+"""Build CUHK-X action prompts from an existing aligned IMU/skeleton JSONL."""
+import argparse
+import json
+import random
+from collections import defaultdict
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+
+
+DATASET_SOURCE = "https://github.com/openaiotlab/CUHK-X"
+
+DEVICE_DESC: dict[str, str] = {
+    "WTLA": "Wearable tracker on Left Arm",
+    "WTRA": "Wearable tracker on Right Arm",
+    "WTC": "Wearable tracker on Chest",
+    "WTLL": "Wearable tracker on Left Leg",
+    "WTRL": "Wearable tracker on Right Leg",
+}
+
+DEVICE_TO_ID: dict[str, int] = {
+    "WTC": 0,
+    "WTLA": 1,
+    "WTLL": 2,
+    "WTRA": 3,
+    "WTRL": 4,
+}
+
+FIELD_DESC: dict[str, str] = {
+    "time_s": "Relative timestamp in seconds from the first sampled IMU record.",
+    "device_id": "Numeric device identifier. See <device_definitions> for the code mapping.",
+    "acc_x_g": "Acceleration on X axis in g.",
+    "acc_y_g": "Acceleration on Y axis in g.",
+    "acc_z_g": "Acceleration on Z axis in g.",
+    "gyro_x_dps": "Angular velocity on X axis in degrees/second.",
+    "gyro_y_dps": "Angular velocity on Y axis in degrees/second.",
+    "gyro_z_dps": "Angular velocity on Z axis in degrees/second.",
+}
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Build prompt-based action-classification JSONL for CUHK-X HAR"
+    )
+    parser.add_argument(
+        "--root",
+        type=Path,
+        default=Path("."),
+        help="Workspace/data root",
+    )
+    parser.add_argument(
+        "--input",
+        type=Path,
+        default=Path("imu_skeleton_aligned.jsonl"),
+        help="Input aligned jsonl from imu_skeleton_to_jsonl.py",
+    )
+    parser.add_argument(
+        "--skeleton-root",
+        type=Path,
+        default=Path("Skeleton"),
+        help="Skeleton root for discovering action space",
+    )
+    parser.add_argument(
+        "--train-output",
+        type=Path,
+        default=Path("imu_action_classification_prompt_train.jsonl"),
+        help="Output train jsonl",
+    )
+    parser.add_argument(
+        "--test-output",
+        type=Path,
+        default=Path("imu_action_classification_prompt_test.jsonl"),
+        help="Output test jsonl",
+    )
+    parser.add_argument(
+        "--train-sample-output",
+        type=Path,
+        default=Path("imu_action_classification_prompt_train.sample.jsonl"),
+        help="Sample output for train split",
+    )
+    parser.add_argument(
+        "--test-sample-output",
+        type=Path,
+        default=Path("imu_action_classification_prompt_test.sample.jsonl"),
+        help="Sample output for test split",
+    )
+    parser.add_argument(
+        "--sample-size",
+        type=int,
+        default=8,
+        help="Number of records to save into each sample output",
+    )
+    parser.add_argument(
+        "--max-records",
+        type=int,
+        default=0,
+        help="If > 0, only process first N records",
+    )
+    parser.add_argument(
+        "--seed",
+        type=int,
+        default=42,
+        help="Random seed for split reproducibility",
+    )
+    return parser.parse_args()
+
+
+def choose_decimals_by_avg_diff(values: list[float]) -> int:
+    if len(values) == 0:
+        return 0
+    if len(values) > 1:
+        diffs = [abs(values[i + 1] - values[i]) for i in range(len(values) - 1)]
+        avg_diff = float(np.mean(diffs)) if diffs else 0.0
+    else:
+        avg_diff = abs(values[0]) * 0.01 if values[0] != 0 else 1.0
+
+    if avg_diff == 0:
+        return 0
+    if avg_diff >= 10:
+        return 0
+    if avg_diff >= 1:
+        return 1
+    if avg_diff >= 0.1:
+        return 2
+    if avg_diff >= 0.01:
+        return 3
+    if avg_diff >= 0.001:
+        return 4
+    return 5
+
+
+def discover_actions(skeleton_root: Path) -> list[dict[str, Any]]:
+    actions: list[dict[str, Any]] = []
+    for action_dir in skeleton_root.iterdir():
+        if not action_dir.is_dir():
+            continue
+        parts = action_dir.name.split("_", 1)
+        if len(parts) != 2:
+            continue
+        try:
+            action_id = int(parts[0])
+        except ValueError:
+            continue
+        action_name = parts[1]
+        actions.append(
+            {
+                "action_id": action_id,
+                "action_name": action_name,
+                "action_dir": action_dir.name,
+            }
+        )
+    actions.sort(key=lambda x: x["action_id"])
+    return actions
+
+
+def parse_action_from_video_path(video_path: str) -> tuple[int, str, str]:
+    p = Path(video_path)
+    parts = p.parts
+    if "Skeleton" not in parts:
+        raise ValueError(f"Cannot locate 'Skeleton' in video_path: {video_path}")
+    skeleton_idx = parts.index("Skeleton")
+    if skeleton_idx + 1 >= len(parts):
+        raise ValueError(f"Cannot locate action directory in video_path: {video_path}")
+    action_dir = parts[skeleton_idx + 1]
+    pair = action_dir.split("_", 1)
+    if len(pair) != 2:
+        raise ValueError(f"Invalid action directory format: {action_dir}")
+    action_id = int(pair[0])
+    action_name = pair[1]
+    return action_id, action_name, action_dir
+
+
+def fmt_val(v: Any, decimals: int) -> str:
+    if v is None:
+        return "null"
+    try:
+        return f"{float(v):.{decimals}f}"
+    except (TypeError, ValueError):
+        return str(v)
+
+
+def parse_time_value(value: Any) -> float | datetime | None:
+    if value is None:
+        return None
+    if isinstance(value, (int, float)):
+        return float(value)
+
+    text = str(value).strip()
+    if not text:
+        return None
+
+    try:
+        return float(text)
+    except ValueError:
+        pass
+
+    candidates = [text]
+    if text.endswith("Z"):
+        candidates.append(text[:-1] + "+00:00")
+    for candidate in candidates:
+        try:
+            return datetime.fromisoformat(candidate)
+        except ValueError:
+            continue
+    return None
+
+
+def build_relative_time_seconds(times: list[Any], size: int) -> list[float]:
+    parsed = [parse_time_value(times[i]) if i < len(times) else None for i in range(size)]
+    first = next((value for value in parsed if value is not None), None)
+    if first is None:
+        return [float(i) for i in range(size)]
+
+    rel_times: list[float] = []
+    for i, value in enumerate(parsed):
+        if value is None:
+            rel_times.append(float(i))
+        elif isinstance(first, datetime) and isinstance(value, datetime):
+            rel_times.append((value - first).total_seconds())
+        elif isinstance(first, (int, float)) and isinstance(value, (int, float)):
+            rel_times.append(float(value) - float(first))
+        else:
+            rel_times.append(float(i))
+    return rel_times
+
+
+def build_timeseries_lines(
+    downsampled_data: dict[str, Any],
+) -> tuple[list[str], dict[str, Any], dict[str, int]]:
+    times = downsampled_data.get("time") or []
+    devices = downsampled_data.get("device_name") or []
+    acc_x = downsampled_data.get("acc_x_g") or []
+    acc_y = downsampled_data.get("acc_y_g") or []
+    acc_z = downsampled_data.get("acc_z_g") or []
+    gyro_x = downsampled_data.get("gyro_x_dps") or []
+    gyro_y = downsampled_data.get("gyro_y_dps") or []
+    gyro_z = downsampled_data.get("gyro_z_dps") or []
+
+    dec_acc_x = choose_decimals_by_avg_diff([float(v) for v in acc_x if v is not None])
+    dec_acc_y = choose_decimals_by_avg_diff([float(v) for v in acc_y if v is not None])
+    dec_acc_z = choose_decimals_by_avg_diff([float(v) for v in acc_z if v is not None])
+    dec_gyro_x = choose_decimals_by_avg_diff([float(v) for v in gyro_x if v is not None])
+    dec_gyro_y = choose_decimals_by_avg_diff([float(v) for v in gyro_y if v is not None])
+    dec_gyro_z = choose_decimals_by_avg_diff([float(v) for v in gyro_z if v is not None])
+
+    precision = {
+        "acc_x_g": dec_acc_x,
+        "acc_y_g": dec_acc_y,
+        "acc_z_g": dec_acc_z,
+        "gyro_x_dps": dec_gyro_x,
+        "gyro_y_dps": dec_gyro_y,
+        "gyro_z_dps": dec_gyro_z,
+    }
+
+    size = min(
+        len(times),
+        len(devices),
+        len(acc_x),
+        len(acc_y),
+        len(acc_z),
+        len(gyro_x),
+        len(gyro_y),
+        len(gyro_z),
+    )
+
+    time_s = build_relative_time_seconds(times, size)
+    lines: list[str] = []
+    unique_devices: set[str] = set()
+    for i in range(size):
+        d = str(devices[i])
+        unique_devices.add(d)
+        device_id = DEVICE_TO_ID.get(d, -1)
+        t_label = fmt_val(time_s[i], 3)
+        lines.append(
+            f"{t_label}: "
+            f"device_id={device_id}, "
+            f"acc_x_g={fmt_val(acc_x[i], dec_acc_x)}, "
+            f"acc_y_g={fmt_val(acc_y[i], dec_acc_y)}, "
+            f"acc_z_g={fmt_val(acc_z[i], dec_acc_z)}, "
+            f"gyro_x_dps={fmt_val(gyro_x[i], dec_gyro_x)}, "
+            f"gyro_y_dps={fmt_val(gyro_y[i], dec_gyro_y)}, "
+            f"gyro_z_dps={fmt_val(gyro_z[i], dec_gyro_z)}"
+        )
+
+    stats = {
+        "num_samples": size,
+        "num_devices": len(unique_devices),
+        "devices": sorted(unique_devices),
+        "device_to_id": DEVICE_TO_ID,
+    }
+    return lines, stats, precision
+
+
+def build_prompt(
+    video_path: str,
+    downsampled_data: dict[str, Any],
+    action_space: list[dict[str, Any]],
+) -> str:
+    field_block = "\n".join([f"- {k}: {v}" for k, v in FIELD_DESC.items()])
+    device_block = "\n".join(
+        [
+            f"- device_id={DEVICE_TO_ID[k]}: {k} - {DEVICE_DESC[k]}"
+            for k in sorted(DEVICE_DESC, key=lambda name: DEVICE_TO_ID[name])
+        ]
+    )
+    action_block = "\n".join(
+        [f"- {x['action_id']}: {x['action_name']}" for x in action_space]
+    )
+
+    ts_lines, _, _ = build_timeseries_lines(downsampled_data)
+    timeseries_block = "\n".join(ts_lines)
+    if not timeseries_block:
+        timeseries_block = "(empty)"
+
+    prompt = f"""\
+You are solving an action-classification task for CUHK-X multimodal HAR.
+
+The video segment and downsampled IMU samples belong to the same action instance.
+
+<field_definitions>
+{field_block}
+</field_definitions>
+
+<device_definitions>
+{device_block}
+</device_definitions>
+
+<action_space>
+{action_block}
+</action_space>
+
+<timeseries>
+Format: time_s: device_id=..., acc_x_g=..., acc_y_g=..., acc_z_g=..., gyro_x_dps=..., gyro_y_dps=..., gyro_z_dps=...
+{timeseries_block}
+</timeseries>
+
+Question: Which action category (action_id) best matches this segment?
+Return only one integer action_id from the action_space.
+"""
+
+    return "\n".join(ln.rstrip() for ln in prompt.splitlines()).strip()
+
+
+def build_question() -> str:
+    return "Which action category (action_id) best matches this video-sensor segment?"
+
+
+def build_options(action_space: list[dict[str, Any]]) -> dict[str, str]:
+    return {str(x["action_id"]): x["action_name"] for x in action_space}
+
+
+def stratified_split_by_action(
+    records: list[dict[str, Any]],
+    train_ratio: float,
+    seed: int,
+) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
+    rng = random.Random(seed)
+    groups: dict[str, list[dict[str, Any]]] = defaultdict(list)
+    for item in records:
+        groups[str(item.get("ground_truth"))].append(item)
+
+    train_items: list[dict[str, Any]] = []
+    test_items: list[dict[str, Any]] = []
+
+    for label in sorted(groups.keys(), key=lambda x: int(x)):
+        bucket = groups[label]
+        rng.shuffle(bucket)
+        n = len(bucket)
+        train_n = int(n * train_ratio)
+        if n >= 2:
+            train_n = min(max(train_n, 1), n - 1)
+        train_bucket = bucket[:train_n]
+        test_bucket = bucket[train_n:]
+
+        for x in train_bucket:
+            x["split"] = "train"
+        for x in test_bucket:
+            x["split"] = "test"
+
+        train_items.extend(train_bucket)
+        test_items.extend(test_bucket)
+
+    rng.shuffle(train_items)
+    rng.shuffle(test_items)
+    return train_items, test_items
+
+
+def main() -> None:
+    args = parse_args()
+    root = args.root.resolve()
+    input_path = (root / args.input).resolve()
+    skeleton_root = (root / args.skeleton_root).resolve()
+    train_output_path = (root / args.train_output).resolve()
+    test_output_path = (root / args.test_output).resolve()
+    train_sample_output_path = (root / args.train_sample_output).resolve()
+    test_sample_output_path = (root / args.test_sample_output).resolve()
+
+    action_space = discover_actions(skeleton_root)
+    if not action_space:
+        raise RuntimeError(f"No actions found under: {skeleton_root}")
+
+    options = build_options(action_space)
+
+    records: list[dict[str, Any]] = []
+    with input_path.open("r", encoding="utf-8") as f:
+        for idx, line in enumerate(f):
+            line = line.strip()
+            if not line:
+                continue
+            raw = json.loads(line)
+
+            video_path = raw.get("video_path", "")
+            downsampled_data = raw.get("downsampled_data") or {}
+
+            action_id, action_name, action_dir = parse_action_from_video_path(video_path)
+            _, sensor_stats, precision = build_timeseries_lines(downsampled_data)
+
+            out_item: dict[str, Any] = dict(raw)
+            out_item["task_id"] = idx
+            out_item["evaluation_type"] = "qa"
+            out_item["task_type"] = "CUHKX_HAR"
+            out_item["sub_dimension"] = "ActionClassification"
+
+            out_item["action_id"] = action_id
+            out_item["action_name"] = action_name
+            out_item["action_dir"] = action_dir
+
+            out_item["prompt"] = build_prompt(video_path, downsampled_data, action_space)
+            out_item["question"] = build_question()
+            out_item["options"] = options
+            out_item["ground_truth"] = str(action_id)
+            out_item["value_precision"] = precision
+            out_item["device_mapping"] = DEVICE_TO_ID
+
+            out_item.pop("downsampled_data", None)
+
+            records.append(out_item)
+
+            if args.max_records > 0 and len(records) >= args.max_records:
+                break
+
+    train_items, test_items = stratified_split_by_action(
+        records=records,
+        train_ratio=0.9,
+        seed=args.seed,
+    )
+
+    train_output_path.parent.mkdir(parents=True, exist_ok=True)
+    test_output_path.parent.mkdir(parents=True, exist_ok=True)
+    train_sample_output_path.parent.mkdir(parents=True, exist_ok=True)
+    test_sample_output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    with train_output_path.open("w", encoding="utf-8") as f:
+        for item in train_items:
+            f.write(json.dumps(item, ensure_ascii=False) + "\n")
+
+    with test_output_path.open("w", encoding="utf-8") as f:
+        for item in test_items:
+            f.write(json.dumps(item, ensure_ascii=False) + "\n")
+
+    with train_sample_output_path.open("w", encoding="utf-8") as f:
+        for item in train_items[: args.sample_size]:
+            f.write(json.dumps(item, ensure_ascii=False) + "\n")
+
+    with test_sample_output_path.open("w", encoding="utf-8") as f:
+        for item in test_items[: args.sample_size]:
+            f.write(json.dumps(item, ensure_ascii=False) + "\n")
+
+    def count_labels(rows: list[dict[str, Any]]) -> dict[str, int]:
+        stats: dict[str, int] = {}
+        for x in rows:
+            gt = x.get("ground_truth")
+            stats[gt] = stats.get(gt, 0) + 1
+        return stats
+
+    summary = {
+        "input": str(input_path),
+        "train_output": str(train_output_path),
+        "test_output": str(test_output_path),
+        "train_sample_output": str(train_sample_output_path),
+        "test_sample_output": str(test_sample_output_path),
+        "total": len(records),
+        "train_size": len(train_items),
+        "test_size": len(test_items),
+        "num_actions": len(action_space),
+        "action_ids": [x["action_id"] for x in action_space],
+        "train_label_stats": count_labels(train_items),
+        "test_label_stats": count_labels(test_items),
+        "seed": args.seed,
+    }
+    print(json.dumps(summary, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()

sample/video-timeseries/cuhk_x_har/xlsx_to_csv.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+"""Convert CUHK-X IMU workbooks and copy CSV streams into a local tree."""
+
+from __future__ import annotations
+
+import argparse
+import shutil
+from pathlib import Path
+
+import pandas as pd
+
+
+def convert(input_root: Path, output_root: Path) -> None:
+    """Keep the original workbook conversion and preserve trial directories."""
+    if output_root.exists():
+        raise ValueError(f"Choose a new IMU output directory: {output_root}")
+    output_root.mkdir(parents=True)
+    paths = sorted(input_root.rglob("*"))
+    for path in paths:
+        if path.is_file() and path.suffix.lower() == ".csv":
+            target = output_root / path.relative_to(input_root)
+            target.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(path, target)
+    converted = 0
+    for path in paths:
+        if (
+            not path.is_file()
+            or path.suffix.lower() not in {".xlsx", ".xls"}
+            or path.name.startswith("~$")
+        ):
+            continue
+        target = (output_root / path.relative_to(input_root)).with_suffix(".csv")
+        if target.exists():
+            continue
+        target.parent.mkdir(parents=True, exist_ok=True)
+        pd.read_excel(path).to_csv(target, index=False, encoding="utf-8-sig")
+        converted += 1
+    print(f"Converted {converted} workbooks into {output_root}")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--input-root", type=Path, required=True)
+    parser.add_argument("--output-root", type=Path, required=True)
+    args = parser.parse_args()
+    convert(args.input_root.resolve(), args.output_root.resolve())
+
+
+if __name__ == "__main__":
+    main()