#!/usr/bin/env python3 """Export a frozen, curated DROID+FT selection to local OXT-layout Zarr v2. No network or robot access. Native inputs are copied, never modified. Requires oxt_array_mapping.py and an offline ZED SDK interpreter for SVO decoding. Each episode is committed only after both cameras and every array are written; an interrupted episode is safely overwritten on resume. """ from __future__ import annotations import argparse import asyncio from collections import Counter from concurrent.futures import ThreadPoolExecutor import hashlib import fcntl import json import os from pathlib import Path import shutil import subprocess import sys import tempfile import time import cv2 import h5py import numpy as np from numcodecs import Blosc import zarr from zarr.storage import LocalStore from oxt_array_mapping import align_camera_rows, build_arrays VERSION = "1.0.1" TASKS = { "wipe_board": "Wipe the board.", "push_button": "Push the button.", "insert_pen": "Insert the pen.", "hang_tape": "Hang the tape.", } CAMERAS = {"36087771": "camera_main", "16478870": "right_wrist_camera"} class AtomicLocalStore(LocalStore): """Atomic per-key replacement protects committed shared chunks on resume. Requires one exporter writer per output directory. This protects against a terminated process, not loss of the entire filesystem or machine power. """ async def _set(self, key, value, exclusive=False): if not self._is_open: await self._open() self._check_writable() path = self.root / key def put(): path.parent.mkdir(parents=True, exist_ok=True) descriptor, name = tempfile.mkstemp(prefix=".oxt-write-", dir=path.parent) temporary = Path(name) try: with os.fdopen(descriptor, "wb") as stream: stream.write(value.to_bytes()) if exclusive: os.link(temporary, path) temporary.unlink() else: temporary.replace(path) finally: temporary.unlink(missing_ok=True) await asyncio.to_thread(put) def atomic_json(path, value): path = Path(path) path.parent.mkdir(parents=True, exist_ok=True) temporary = path.with_name(path.name + ".partial") with temporary.open("w", encoding="utf-8") as stream: json.dump(value, stream, indent=2, ensure_ascii=False, allow_nan=False) stream.write("\n") stream.flush() os.fsync(stream.fileno()) temporary.replace(path) def sha256(path): digest = hashlib.sha256() with Path(path).open("rb") as stream: for block in iter(lambda: stream.read(4 * 1024 * 1024), b""): digest.update(block) return digest.hexdigest() def json_value(value): if isinstance(value, bytes): return value.decode("utf-8") if isinstance(value, np.ndarray): return [json_value(v) for v in value.tolist()] if isinstance(value, np.generic): return json_value(value.item()) if isinstance(value, (list, tuple)): return [json_value(v) for v in value] if isinstance(value, dict): return {str(k): json_value(v) for k, v in value.items()} return value def task_slug(episode): slug = episode["task_slug"] return "insert_pen" if slug == "insert" else slug def episode_name(episode): return Path(episode["source_episode"]).name.replace(":", "-") def source_fingerprint(episode): source = Path(episode["source_episode"]) for relative, expected in episode["files_before"].items(): stat = (source / relative).stat() if (stat.st_size, stat.st_mtime_ns) != (expected["size"], expected["mtime_ns"]): raise RuntimeError(f"Audited source changed: {source / relative}") def copy_native(episode, destination): """Copy all audited source files, verify bytes, and retain original H5 attrs.""" source_fingerprint(episode) source = Path(episode["source_episode"]) destination.mkdir(parents=True, exist_ok=True) file_records = {} for relative in sorted(episode["files_before"]): src, dst = source / relative, destination / relative dst.parent.mkdir(parents=True, exist_ok=True) source_hash = sha256(src) expected_hash = episode["source_h5_sha256"].get(relative) if expected_hash and source_hash != expected_hash: raise RuntimeError(f"Audited source hash changed: {src}") if not dst.exists() or dst.stat().st_size != src.stat().st_size or sha256(dst) != source_hash: partial = dst.with_name(dst.name + ".partial") shutil.copy2(src, partial) if sha256(partial) != source_hash: raise RuntimeError(f"Copy hash mismatch: {dst}") partial.replace(dst) file_records[relative] = {"bytes": dst.stat().st_size, "sha256": source_hash} source_fingerprint(episode) return file_records def string_widths(episodes): """Preflight fixed Unicode widths across the entire task to prevent truncation.""" widths = {} for episode in episodes: with h5py.File(Path(episode["source_episode"]) / "trajectory.h5", "r") as handle: def visit(name, node): if isinstance(node, h5py.Dataset) and node.dtype.kind in "OSU": values = node.asstr()[:] if node.dtype.kind in "OS" else node[:] width = max((len(str(v)) for v in values.ravel()), default=1) key = "native__" + name.replace("/", "__") widths[key] = max(widths.get(key, 1), width) handle.visititems(visit) return widths def decode_camera(args, source, cache, log_path): if cache.exists(): meta = json.loads((cache / "metadata.json").read_text()) stat = source.stat() if (meta.get("complete") and meta.get("image_format") == "png" and meta["source_size"] == stat.st_size and meta["source_mtime_ns"] == stat.st_mtime_ns and meta["width"] == args.width and meta["height"] == args.height): return meta raise RuntimeError(f"Incompatible decode cache: {cache}") command = [args.zed_python, str(Path(__file__).with_name("svo_decode.py")), "--input", str(source), "--output", str(cache), "--width", str(args.width), "--height", str(args.height), "--image-format", "png"] log_path.parent.mkdir(parents=True, exist_ok=True) for attempt in range(3): with log_path.open("a", encoding="utf-8") as stream: stream.write(f"\nDecode attempt {attempt + 1}\n") stream.flush() result = subprocess.run(command, stdout=stream, stderr=subprocess.STDOUT) if result.returncode == 0: return json.loads((cache / "metadata.json").read_text()) if cache.exists(): raise RuntimeError(f"Failed decoder left output: {cache}; inspect {log_path}") raise RuntimeError(f"SVO decode failed three times: {source}; inspect {log_path}") def create_array(group, key, sample, capacity, widths): dtype = sample.dtype if dtype.kind == "U": dtype = np.dtype(f"U{max(dtype.itemsize // 4, widths.get(key, 1))}") chunks = (min(256, capacity),) + sample.shape[1:] return group.create_array(key, shape=(capacity,) + sample.shape[1:], dtype=dtype, chunks=chunks, filters=[], compressor=Blosc(cname="zstd", clevel=3, shuffle=Blosc.SHUFFLE)) def write_rows(group, arrays, start, capacity, widths): for key, values in arrays.items(): if values.dtype.kind == "O": raise TypeError(f"Object array cannot be exported losslessly: {key}") target = group[key] if key in group else create_array(group, key, values, capacity, widths) if target.shape[1:] != values.shape[1:]: raise ValueError(f"Shape changed for {key}") if values.dtype.kind == "U" and values.dtype.itemsize > target.dtype.itemsize: raise ValueError(f"String truncation prevented for {key}") target[start:start + len(values)] = values def resized_left_intrinsics(metadata, width, height): """Require actual SDK rectified calibration, never substitute stale hand-eye.""" calib = metadata.get("calibration", {}) left = calib.get("rectified", {}).get("left", {}) matrix = left.get("K") if matrix is None: raise ValueError("Decoder did not provide rectified output K for LEFT view") matrix = np.asarray(matrix, dtype=np.float64) if matrix.shape != (3, 3) or not np.all(np.isfinite(matrix)) or matrix[0, 0] <= 0: raise ValueError("Invalid SDK output intrinsics") return matrix def write_images(group, role, cache, indices, start, capacity, width, height): key = role + "_rgb" if key not in group: group.create_array(key, shape=(capacity, height, width, 3), dtype="u1", chunks=(1, height, width, 3), compressor=Blosc(cname="zstd", clevel=3, shuffle=Blosc.NOSHUFFLE)) target = group[key] for first in range(0, len(indices), 16): batch = [] for frame_index in indices[first:first + 16]: path = cache / f"frame{frame_index:06d}.png" bgr = cv2.imread(str(path), cv2.IMREAD_COLOR) if bgr is None or bgr.shape != (height, width, 3) or bgr.dtype != np.uint8: raise RuntimeError(f"Invalid decoded frame: {path}") batch.append(cv2.cvtColor(bgr, cv2.COLOR_BGR2RGB)) pixels = np.stack(batch) target[start + first:start + first + len(batch)] = pixels # Compare actual storage roundtrip at boundaries and regular intervals. for offset, rgb in enumerate(batch): number = first + offset if number == 0 or number == len(indices) - 1 or number % 100 == 0: if not np.array_equal(target[start + number], rgb): raise RuntimeError(f"Zarr RGB roundtrip failed: {role} frame {indices[number]}") def update_meta(root, records, final=False): meta = root.require_group("meta") values = { "episode_ends": np.asarray([r["end"] for r in records], dtype=np.int64), "episode_ids": np.asarray([r["episode_id"] for r in records], dtype="U36"), "episode_names": np.asarray([r["episode_name"] for r in records], dtype="U128"), "source_episode_paths": np.asarray([r["native_path"] for r in records], dtype="U256"), } for key, value in values.items(): if key in meta: del meta[key] array = meta.create_array(key, shape=value.shape, dtype=value.dtype, chunks=(max(1, len(value)),), filters=[]) array[:] = value root.attrs["complete"] = final root.attrs["committed_episodes"] = len(records) def export(args): audit_path = Path(args.audit).resolve(strict=True) audit = json.loads(audit_path.read_text()) if audit["errors"] or audit["summary"]["errors"]: raise ValueError("Source audit contains errors") if len(audit["episodes"]) != 125 or len(set(e["episode_id"] for e in audit["episodes"])) != 125: raise ValueError("Expected frozen 125 unique curated episodes") output, work = Path(args.output).resolve(), Path(args.work).resolve() output.mkdir(parents=True, exist_ok=True) work.mkdir(parents=True, exist_ok=True) for name in ("native", "zarr", "metadata/episodes", "qc", "tools", "archives"): (output / name).mkdir(parents=True, exist_ok=True) audit_hash = sha256(audit_path) journal_path = work / "export_journal.json" config = {"version": VERSION, "source_audit_sha256": audit_hash, "output": str(output), "width": args.width, "height": args.height} if not journal_path.exists() and any((output / "zarr").glob("*.zarr")): raise ValueError("Existing Zarr output requires its original resume journal") journal = json.loads(journal_path.read_text()) if journal_path.exists() else {"config": config, "episodes": []} if journal["config"] != config: raise ValueError("Resume configuration differs from journal") for temporary in (output / "zarr").rglob(".oxt-write-*"): if temporary.is_file(): temporary.unlink() atomic_json(journal_path, journal) shutil.copy2(audit_path, output / "metadata/selected_sources_audit.json") semantics = audit_path.with_name("source_field_semantics.json") if semantics.exists(): shutil.copy2(semantics, output / "metadata/source_field_semantics.json") processed = 0 started = time.monotonic() for slug, instruction in TASKS.items(): episodes = [e for e in audit["episodes"] if task_slug(e) == slug] capacity = sum(e["control_steps"] for e in episodes) records = [e for e in journal["episodes"] if e["task"] == slug] completed = {e["episode_id"] for e in records} path = output / "zarr" / (slug + ".zarr") root = zarr.open_group(store=AtomicLocalStore(path), mode="a", zarr_format=2) data = root.require_group("data") root.attrs.update({"dataset": "IDEAL-FT", "task": instruction, "exporter_version": VERSION, "zarr_format": 2, "image_size_hw": [args.height, args.width], "pose_format": "xyz_m_rotvec_rad", "pose_reference": "native panda_link8 flange", "canonical_gripper_alignment": "right_wrist_pose omitted; calibrated FTP-1 gripper transform unavailable", "right_hand_joints_semantics": "slot 28: normalized opening = 1 - native closure; 0=closed, 1=open; dimensionless", "ft_compensation": "device calibrated; no added gravity/bias compensation", "camera_extrinsic_validity": "recorded old calibration; post-installation validity unconfirmed", "sampling": "Original control rows with exact recorded images from both cameras; no interpolation", "complete": False}) widths = string_widths(episodes) for episode in episodes: if episode["episode_id"] in completed: continue name = episode_name(episode) print(f"[{len(journal['episodes']) + 1}/125] {slug}/{name}", flush=True) source = Path(episode["source_episode"]) native_relative = Path("native") / slug / name native_files = copy_native(episode, output / native_relative) cache_root = work / "decode" / slug / name camera_meta, timestamps = {}, {} with ThreadPoolExecutor(max_workers=2) as executor: futures = {serial: executor.submit( decode_camera, args, source / "recordings/SVO" / (serial + ".svo"), cache_root / serial, work / "logs" / slug / name / (serial + ".log")) for serial in CAMERAS} # Only offline decoder processes run concurrently. All Zarr and # journal mutations remain on this single parent thread. for serial, future in futures.items(): camera_meta[serial] = future.result() for serial in CAMERAS: with np.load(cache_root / serial / "timestamps.npz") as record: timestamps[serial] = record["timestamp_ns"].copy() rows, frame_indices, alignment = align_camera_rows(output / native_relative / "trajectory.h5", timestamps) selected_times = {serial: timestamps[serial][frame_indices[serial]] for serial in CAMERAS} arrays, mapping = build_arrays(output / native_relative / "trajectory.h5", rows, instruction, camera_indices=frame_indices, camera_timestamp_ns=selected_times) for serial, role in CAMERAS.items(): k = resized_left_intrinsics(camera_meta[serial], args.width, args.height) arrays[role + "_intrinsics"] = np.repeat(k[None], len(rows), axis=0) start = records[-1]["end"] if records else 0 end = start + len(rows) if end > capacity: raise RuntimeError("More selected rows than source control rows") # Resume after task finalization can safely grow back to capacity. for key in data.array_keys(): a = data[key] if a.shape[0] != capacity: a.resize((capacity,) + a.shape[1:]) write_rows(data, arrays, start, capacity, widths) for serial, role in CAMERAS.items(): write_images(data, role, cache_root / serial, frame_indices[serial], start, capacity, args.width, args.height) record = {"task": slug, "episode_id": episode["episode_id"], "episode_name": name, "native_path": str(native_relative), "start": start, "end": end, "source_control_steps": episode["control_steps"], "exported_steps": len(rows), "ft_samples": episode["ft_samples"], "files": native_files, "source_date": source.parent.name, "source_directory_name": source.name, "source_control_rows_omitted": sorted(set(range(episode["control_steps"])) - set(rows.tolist())), "task_selection_basis": episode["selection_basis"], "metadata_path": str(Path("metadata/episodes") / slug / (name + ".json"))} native_attrs = {} for fname in ("trajectory.h5", "ft_sensor.h5"): with h5py.File(output / native_relative / fname, "r") as handle: native_attrs[fname] = {k: json_value(v) for k, v in handle.attrs.items()} atomic_json(output / record["metadata_path"], {"episode": record, "alignment": alignment, "mapping": mapping, "cameras": camera_meta, "native_h5_attributes": native_attrs}) if not (output / "metadata/field_mapping.json").exists(): atomic_json(output / "metadata/field_mapping.json", mapping) records.append(record) update_meta(root, records) journal["episodes"].append(record) atomic_json(journal_path, journal) shutil.rmtree(cache_root) processed += 1 print(f" committed {len(rows)} rows; native {episode['control_steps']} controls, " f"{episode['ft_samples']} FT samples; elapsed {time.monotonic() - started:.1f}s", flush=True) if args.max_new_episodes and processed >= args.max_new_episodes: print("Pilot limit reached; resume without --max-new-episodes for all tasks.", flush=True) return if len(records) != len(episodes): raise RuntimeError("Task episode accounting mismatch") total_rows = records[-1]["end"] for key in data.array_keys(): array = data[key] array.resize((total_rows,) + array.shape[1:]) update_meta(root, records, final=True) print(f"Completed {slug}: {len(records)} episodes, {total_rows} synchronized rows", flush=True) counts = Counter(r["task"] for r in journal["episodes"]) manifest = {"schema": "franka-ft-oxt-local-v1", "complete": True, "upload_status": "not uploaded", "source_audit_sha256": audit_hash, "tasks": dict(counts), "episodes": journal["episodes"], "total_episodes": len(journal["episodes"]), "control_steps_native": sum(r["source_control_steps"] for r in journal["episodes"]), "control_steps_zarr": sum(r["exported_steps"] for r in journal["episodes"]), "ft_samples_native": sum(r["ft_samples"] for r in journal["episodes"]), "geometry_status": "Native flange and FT sensor frames preserved; canonical/TCP calibration pending", "created_utc": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())} atomic_json(output / "metadata/export_manifest.json", manifest) print(json.dumps({k: v for k, v in manifest.items() if k != "episodes"}, indent=2), flush=True) def main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--audit", required=True) parser.add_argument("--output", required=True) parser.add_argument("--work", required=True, help="SSD staging and resume journal (outside output)") parser.add_argument("--zed-python", default="/home/yygx/anaconda3/envs/zed/bin/python") parser.add_argument("--width", type=int, default=640) parser.add_argument("--height", type=int, default=360) parser.add_argument("--max-new-episodes", type=int, default=0, help="Optional pilot limit; zero means all") args = parser.parse_args() if args.width <= 0 or args.height <= 0: parser.error("image dimensions must be positive") work = Path(args.work).resolve() work.mkdir(parents=True, exist_ok=True) with (work / "export.lock").open("a") as lock: try: fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB) except BlockingIOError as error: raise RuntimeError("Another exporter is using this work directory") from error export(args) if __name__ == "__main__": main()