| |
| """Independent, offline checks for the Franka/FT OXT export. |
| |
| This verifies preservation and declared numeric conversions, not physical sensor |
| calibration, canonical gripper alignment, image content, or source-file hashes. |
| It does not import the exporter or open an SVO/live camera. RGB chunks are sampled |
| at each episode's first/last row unless --scan-rgb-all is requested. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| from datetime import datetime, timezone |
| import json |
| from pathlib import Path |
| import sys |
| from typing import Any |
|
|
| import h5py |
| import numpy as np |
| from scipy.spatial.transform import Rotation |
|
|
|
|
| TASKS = ("wipe_board", "push_button", "insert_pen", "hang_tape") |
| CAMERAS = {"camera_main": "36087771", "right_wrist_camera": "16478870"} |
| STANDARD_SHAPES = { |
| "timestamps": (), "timestamp_unix_ns": (), "source_control_row": (), |
| "right_arm_joints": (7,), |
| "right_hand_joints": (1,), "right_hand_joints_idx": (1,), |
| "sub_task_instruction": (), "action_joint_position": (7,), |
| "action_eef_pose": (6,), "action_eef_pose_with_ft_offset": (6,), |
| "state_eef_pose_with_ft_offset": (6,), "command_dispatched": (), |
| "right_tactile_data_wrist_torque": (1, 3), |
| "right_tactile_area_wrist_torque": (1,), |
| "right_tactile_sensor_wrist_torque": (), |
| "right_tactile_type_wrist_torque": (), |
| "ft_wrench": (6,), "supplementary_tactile": (6,), |
| } |
| POSE_SOURCES = { |
| "state_eef_pose_with_ft_offset": "observation/robot_state/cartesian_position_with_ft_offset", |
| "action_eef_pose": "action/cartesian_position", |
| "action_eef_pose_with_ft_offset": "action/cartesian_position_with_ft_offset", |
| } |
|
|
|
|
| def text_value(value: Any) -> str: |
| return value.decode("utf-8") if isinstance(value, bytes) else str(value) |
|
|
|
|
| def episode_name_matches(original_name: str, exported_name: str) -> bool: |
| """Allow only the exact native name or its documented ':' -> '-' variant.""" |
| return exported_name == original_name or exported_name == original_name.replace(":", "-") |
|
|
|
|
| def native_key(path: str) -> str: |
| return "native__" + path.replace("/", "__") |
|
|
|
|
| def strings(values: Any) -> np.ndarray: |
| arr = np.asarray(values) |
| return np.asarray([text_value(v) for v in arr.reshape(-1)]).reshape(arr.shape) |
|
|
|
|
| def exactly_equal(actual: np.ndarray, expected: np.ndarray) -> bool: |
| if actual.shape != expected.shape: |
| return False |
| if expected.dtype.kind in "OSU": |
| return bool(np.array_equal(strings(actual), strings(expected))) |
| return bool(np.array_equal(actual, expected, equal_nan=True)) |
|
|
|
|
| class Checks: |
| def __init__(self) -> None: |
| self.errors: list[str] = [] |
| self.count = 0 |
|
|
| def require(self, condition: Any, message: str) -> bool: |
| self.count += 1 |
| ok = bool(condition) |
| if not ok: |
| self.errors.append(message) |
| return ok |
|
|
| def equal(self, actual: Any, expected: Any, label: str) -> None: |
| self.require(exactly_equal(np.asarray(actual), np.asarray(expected)), label + ": value mismatch") |
|
|
|
|
| def pose_check(actual: np.ndarray, source: np.ndarray, checks: Checks, label: str) -> None: |
| if not checks.require(actual.shape == source.shape and actual.shape[-1:] == (6,), label + ": pose shape mismatch"): |
| return |
| if not checks.require(np.isfinite(actual).all() and np.isfinite(source).all(), label + ": nonfinite pose"): |
| return |
| checks.require(np.allclose(actual[:, :3], source[:, :3], atol=1e-10, rtol=0), label + ": position changed") |
| expected_rotation = Rotation.from_euler("xyz", source[:, 3:]).as_matrix() |
| exported_rotation = Rotation.from_rotvec(actual[:, 3:]).as_matrix() |
| checks.require(np.allclose(exported_rotation, expected_rotation, atol=1e-10, rtol=0), label + ": Euler-to-rotvec rotation mismatch") |
| roundtrip = Rotation.from_rotvec(Rotation.from_matrix(exported_rotation).as_rotvec()).as_matrix() |
| checks.require(np.allclose(roundtrip, expected_rotation, atol=1e-10, rtol=0), label + ": rotation roundtrip mismatch") |
|
|
|
|
| def gripper_check(actual: np.ndarray, source_closure: np.ndarray, checks: Checks) -> None: |
| """Independently verify slot 28 opening against untouched native closure.""" |
| checks.equal(actual, (1 - source_closure).reshape(-1, 1), |
| "normalized gripper opening must equal 1 - native closure") |
| checks.require(np.isfinite(actual).all() and np.all((actual >= 0) & (actual <= 1)), |
| "normalized gripper opening must be finite and within [0, 1]") |
|
|
|
|
| def offset_check(original: np.ndarray, derived: np.ndarray, extension: float, checks: Checks, label: str) -> None: |
| expected = original[:, :3] + Rotation.from_euler("xyz", original[:, 3:]).apply([0.0, 0.0, extension]) |
| checks.require(np.allclose(derived[:, :3], expected, atol=1e-10, rtol=0), label + ": local +Z offset formula mismatch") |
| checks.equal(derived[:, 3:], original[:, 3:], label + ": offset must retain original orientation") |
|
|
|
|
| def scan_rgb_rows(rgb: Any, span: slice, checks: Checks, label: str) -> int: |
| """Read every RGB row in batches, independently of Zarr's chunk length.""" |
| tested = 0 |
| for pos in range(span.start, span.stop, 32): |
| stop = min(pos + 32, span.stop) |
| image_rows = np.asarray(rgb[pos:stop]) |
| checks.require(image_rows.dtype == np.uint8 and image_rows.shape == (stop - pos, 360, 640, 3), |
| label + ": decoded RGB batch malformed") |
| tested += len(image_rows) |
| return tested |
|
|
|
|
| def find_audit(root: Path, explicit: Path | None) -> Path | None: |
| if explicit is not None: |
| return explicit |
| for path in (root / "metadata/selected_sources_audit.json", |
| root / "provenance/selected_sources_audit.json", |
| root / "selected_sources_audit.json", |
| root.parent / "oxt_export_work/selected_sources_audit.json"): |
| if path.is_file(): |
| return path |
| return None |
|
|
|
|
| def validate_episode(data: Any, span: slice, package_root: Path, relative_native: str, |
| episode_id: str, episode_name: str, audit: dict | None, |
| scan_rgb_all: bool) -> dict: |
| checks = Checks() |
| result: dict[str, Any] = {"episode_id": episode_id, "episode_name": episode_name, |
| "native_path": relative_native, "errors": checks.errors} |
| rel = Path(relative_native) |
| if not checks.require(not rel.is_absolute() and ".." not in rel.parts and rel.parts[:1] == ("native",), "native path must be a relative path under native/"): |
| return result |
| source_dir = package_root / rel |
| with h5py.File(source_dir / "trajectory.h5", "r") as source, h5py.File(source_dir / "ft_sensor.h5", "r") as ft: |
| rows = np.asarray(data["source_control_row"][span]) |
| raw_T = int(source["action/joint_position"].shape[0]) |
| result.update(control_rows_exported=int(len(rows)), control_rows_native=raw_T, |
| control_rows_omitted=raw_T - len(rows)) |
| if not checks.require(rows.ndim == 1 and rows.dtype.kind in "iu" and rows.size > 0 |
| and np.all(rows >= 0) and np.all(rows < raw_T) |
| and np.all(np.diff(rows.astype(np.int64)) > 0), "source_control_row must be increasing valid integer indices"): |
| return result |
| rows = rows.astype(np.int64) |
| checks.require(bool(source.attrs.get("complete", False)), "native trajectory incomplete") |
| checks.require(bool(source.attrs.get("success", False)), "native episode is not operator success") |
| checks.require(not text_value(source.attrs.get("collection_error", "")), "native trajectory collection_error is nonempty") |
| checks.require(text_value(source.attrs.get("episode_id", "")) == episode_id, "native episode_id mismatch") |
| original_name = text_value(source.attrs.get("time", "")) |
| result["original_episode_name"] = original_name |
| result["episode_name_normalization"] = ( |
| "unchanged" if episode_name == original_name else "colon_to_hyphen_portable_variant" |
| if episode_name_matches(original_name, episode_name) else "invalid" |
| ) |
| checks.require(episode_name_matches(original_name, episode_name), |
| "native episode_name mismatch: expected exact original or colon-to-hyphen portable variant") |
| checks.require(bool(ft.attrs.get("complete", False)), "native FT stream incomplete") |
|
|
| |
| |
| row_paths: list[str] = [] |
| source.visititems(lambda name, obj: row_paths.append(name) |
| if isinstance(obj, h5py.Dataset) and obj.ndim > 0 and obj.shape[0] == raw_T else None) |
| result["native_row_datasets"] = len(row_paths) |
| for path in row_paths: |
| key = native_key(path) |
| if not checks.require(key in data, "missing native field " + key): |
| continue |
| expected = source[path][rows] |
| actual = np.asarray(data[key][span]) |
| checks.equal(actual, expected, key) |
| if expected.dtype.kind not in "OSU": |
| checks.require(actual.dtype == expected.dtype, key + ": numeric dtype changed") |
| if actual.dtype.kind in "fc": |
| checks.require(np.isfinite(actual).all(), key + ": contains nonfinite numeric values") |
| exported_native = {key for key in data.array_keys() if key.startswith("native__")} |
| checks.require(exported_native == {native_key(path) for path in row_paths}, "native field set differs from source row dataset set") |
|
|
| def raw(path: str) -> np.ndarray: |
| return np.asarray(source[path][rows]) |
|
|
| def out(key: str) -> np.ndarray: |
| return np.asarray(data[key][span]) |
|
|
| checks.equal(out("right_arm_joints"), raw("observation/robot_state/joint_positions"), "standard arm state") |
| gripper_check(out("right_hand_joints"), raw("observation/robot_state/gripper_position"), checks) |
| checks.equal(out("action_joint_position"), raw("action/joint_position"), "actual joint targets") |
| for key, path in POSE_SOURCES.items(): |
| pose_check(out(key), raw(path), checks, key) |
|
|
| capture = json.loads(text_value(source.attrs.get("capture_metadata_json", "{}"))) |
| |
| |
| config = json.loads(text_value(ft.attrs.get("config_json", "{}"))) |
| mounting = capture.get("mounting") or config.get("mounting", {}) |
| extension = mounting.get("axial_extension_m") |
| if checks.require(isinstance(extension, (int, float)) and not isinstance(extension, bool) |
| and np.isfinite(extension) and abs(extension - 0.063) < 1e-12, |
| "recorded mounting extension must be 0.063 m"): |
| checks.require(mounting.get("axis") == "eef_local_+z", "mounting offset axis is not eef_local_+z") |
| for prefix in ("action", "observation/robot_state"): |
| offset_check(raw(prefix + "/cartesian_position"), raw(prefix + "/cartesian_position_with_ft_offset"), |
| float(extension), checks, prefix) |
|
|
| unix_ns = raw("observation/timestamp/control/step_start_unix_ns") |
| start_ns = int(source["observation/timestamp/control/step_start_unix_ns"][0]) |
| checks.equal(out("timestamp_unix_ns"), unix_ns, "exact host timestamp") |
| expected_times = (unix_ns - start_ns).astype(np.float64) / 1e9 |
| checks.require(np.allclose(out("timestamps"), expected_times, atol=1e-12, rtol=0), "relative timestamps differ from native host step_start") |
| checks.require(np.all(np.diff(out("timestamps")) > 0), "relative timestamps not strictly increasing") |
| checks.require(np.all(np.diff(unix_ns) > 0), "host timestamps not strictly increasing") |
| dispatched = raw("action/command_dispatched") |
| skip = raw("observation/timestamp/skip_action") |
| checks.equal(out("command_dispatched"), dispatched, "command dispatch extension") |
| checks.equal(dispatched, ~skip, "command_dispatched must be inverse of skip_action") |
| result["command_dispatched"] = int(np.count_nonzero(dispatched)) |
| result["skipped_actions"] = int(np.count_nonzero(skip)) |
|
|
| samples = ft["samples"] |
| F = int(samples["wrench"].shape[0]) |
| result["ft_samples_native"] = F |
| checks.require(F > 0 and samples["wrench"].shape == (F, 6), "full FT wrench shape invalid") |
| for key, obj in samples.items(): |
| checks.require(obj.shape[0] == F, "FT sidecar length mismatch: " + key) |
| checks.equal(samples["sample_index"][:], np.arange(F), "full FT sequence indices") |
| checks.require(np.isfinite(samples["wrench"][:]).all(), "full FT stream contains nonfinite wrench") |
| receive_ns = samples["receive_monotonic_ns"][:] |
| request_ns = samples["request_monotonic_ns"][:] |
| checks.require(np.all(np.diff(receive_ns) > 0), "full FT receive clock not strictly increasing") |
| checks.require(np.all(request_ns <= receive_ns), "FT request occurs after receive") |
| for attr in ("samples_received", "samples_written"): |
| checks.require(int(ft.attrs.get(attr, -1)) == F, "FT " + attr + " differs from saved stream length") |
| indices = raw("observation/ft_sensor/sample_index") |
| if checks.require(indices.dtype.kind in "iu" and np.all(indices >= 0) and np.all(indices < F) |
| and np.all(np.diff(indices) >= 0), "FT snapshot indices invalid"): |
| for key in ("sample_index", "wrench", "packet_no", "packet_delta", "packet_discontinuity", |
| "request_monotonic_ns", "request_unix_ns", "receive_monotonic_ns", "receive_unix_ns"): |
| |
| checks.equal(raw("observation/ft_sensor/" + key), samples[key][:][indices], "FT snapshot " + key) |
| checks.require(np.all(raw("observation/ft_sensor/valid")), "invalid FT snapshot exported") |
| snapshot = raw("observation/ft_sensor/snapshot_monotonic_ns") |
| received = raw("observation/ft_sensor/receive_monotonic_ns") |
| checks.require(np.all(received <= snapshot), "FT snapshot uses future received sample") |
| checks.require(np.all(snapshot <= raw("observation/timestamp/robot_state/read_start_monotonic_ns")), "FT snapshot follows robot read start") |
| checks.require(np.allclose(raw("observation/ft_sensor/age_s"), (snapshot - received) / 1e9, atol=1e-12, rtol=0), "FT age does not match host monotonic clocks") |
| wrench = raw("observation/ft_sensor/wrench") |
| checks.equal(out("ft_wrench"), wrench, "full six-axis aligned FT") |
| checks.equal(out("supplementary_tactile"), wrench, "supplementary six-axis FT") |
| checks.equal(out("right_tactile_data_wrist_torque"), wrench[:, None, 3:], "standard wrist torque must be Mx/My/Mz only") |
|
|
| camera_report = {} |
| camera_audit = {c["serial"]: c for c in (audit or {}).get("replay_cameras", [])} |
| for role, serial in CAMERAS.items(): |
| variants = ((role + "_frame_index", "camera_frame_index__" + serial), |
| (role + "_timestamp_ns", "camera_timestamp_unix_ns__" + serial)) |
| values = [] |
| for alternatives in variants: |
| present = [key for key in alternatives if key in data] |
| if not checks.require(bool(present), "missing camera provenance: " + "/".join(alternatives)): |
| values.append(None) |
| continue |
| value = out(present[0]) |
| checks.require(value.shape == (len(rows),) and value.dtype.kind in "iu", present[0] + ": expected integer vector") |
| for other in present[1:]: |
| checks.equal(value, out(other), "camera alias " + other) |
| values.append(value) |
| frame_indices, frame_times = values |
| if frame_indices is not None: |
| checks.require(np.all(frame_indices >= 0) and np.all(np.diff(frame_indices) > 0), role + ": invalid/repeated frame index") |
| if frame_times is not None: |
| checks.require(np.all(np.diff(frame_times) > 0), role + ": camera timestamps not strictly increasing") |
| checks.equal(frame_times // 1_000_000, raw("observation/timestamp/cameras/" + serial + "_frame_received"), role + ": SDK timestamp must match original H5 milliseconds") |
| known = camera_audit.get(serial) |
| if known is not None and frame_indices is not None: |
| N = int(known["decoded_frames"]) |
| checks.require(np.all(frame_indices < N), role + ": frame index exceeds audited SVO count") |
| |
| if N == raw_T - 1 and int(known.get("svo_timestamps_matched_to_trajectory", -1)) == N: |
| checks.equal(rows, np.arange(N), role + ": not all audited real-image control rows retained") |
| checks.equal(frame_indices, np.arange(N), role + ": real-image frame index mapping differs from audited prefix") |
| if frame_times is not None: |
| checks.require(int(frame_times[0]) == int(known["first_image_unix_ns"]), role + ": first exact SDK timestamp differs from audit") |
| checks.require(int(frame_times[-1]) == int(known["last_image_unix_ns"]), role + ": last exact SDK timestamp differs from audit") |
| rgb = data[role + "_rgb"] |
| tested = 0 |
| if scan_rgb_all: |
| tested = scan_rgb_rows(rgb, span, checks, role) |
| else: |
| for pos in sorted({span.start, span.stop - 1}): |
| frame = np.asarray(rgb[pos]) |
| checks.require(frame.shape == (360, 640, 3) and frame.dtype == np.uint8, role + ": sampled RGB frame malformed") |
| tested += 1 |
| camera_report[serial] = {"role": role, "rows": len(rows), "rgb_rows_read": tested, |
| "source_count_evidence": known is not None} |
| result["cameras"] = camera_report |
| if audit is not None: |
| checks.require(int(audit["control_steps"]) == raw_T, "source audit native control count mismatch") |
| checks.require(int(audit["ft_samples"]) == F, "source audit full FT count mismatch") |
| result["checks"] = checks.count |
| result["passed"] = not checks.errors |
| return result |
|
|
|
|
| def validate_export(root: Path, source_audit: Path | None = None, scan_rgb_all: bool = False) -> dict: |
| import zarr |
|
|
| root = root.resolve() |
| checks = Checks() |
| audit_path = find_audit(root, source_audit) |
| audit_doc = json.loads(audit_path.read_text()) if audit_path else None |
| audit_by_id = {e["episode_id"]: e for e in (audit_doc or {}).get("episodes", [])} |
| result: dict[str, Any] = { |
| "schema": "franka-ft-oxt-validation-v1", "dataset_root": str(root), |
| "generated_at_utc": datetime.now(timezone.utc).isoformat(), |
| "source_audit": str(audit_path) if audit_path else None, |
| "errors": checks.errors, "tasks": {}, |
| "scope": {"native_row_arrays": "all retained rows and all original row datasets compared exactly", |
| "ft_stream": "all saved samples counted and checked; all aligned snapshots compared", |
| "rgb": "all chunks read" if scan_rgb_all else "first and last retained frame of each episode read", |
| "svo_decoding": "not repeated; existing source audit count/timestamp evidence used", |
| "hash_verification": "separate process; not performed here", |
| "physical_calibration": "not validated", |
| "oxt_canonical_wrist_or_tcp_alignment": "not established; standard right_wrist_pose omitted, right_arm_joints provided; native flange observations retained as native__ fields", |
| "gripper_slot_28": "normalized opening = 1 - native closure; 0=closed, 1=open; dimensionless"}, |
| "limitations": ["This report establishes preservation and numeric consistency, not physical accuracy or final OXT acceptance.", |
| "Native FT axes/origin and N/Nm unit confirmation remain as recorded; no TCP/base transform or software bias/gravity compensation is inferred.", |
| "Logged camera extrinsics are historical calibration estimates; validity after FT mounting is unconfirmed."], |
| } |
| if audit_doc is None: |
| result["limitations"].append("No source selection audit supplied; exact selected episode membership and SVO count evidence were not verified.") |
| found = {p.stem for p in (root / "zarr").glob("*.zarr")} |
| checks.require(found == set(TASKS), "expected exactly four task Zarr groups: " + ", ".join(TASKS)) |
| exported_ids: list[str] = [] |
| for task in TASKS: |
| task_result: dict[str, Any] = {"episodes": [], "errors": []} |
| result["tasks"][task] = task_result |
| local = Checks() |
| task_result["errors"] = local.errors |
| try: |
| group = zarr.open_group(str(root / "zarr" / (task + ".zarr")), mode="r") |
| local.require(int(group.metadata.zarr_format) == 2, "expected Zarr format 2") |
| data, meta = group["data"], group["meta"] |
| ends = np.asarray(meta["episode_ends"][:]) |
| if not local.require(ends.ndim == 1 and ends.dtype.kind in "iu" and len(ends) > 0 |
| and ends[0] > 0 and np.all(np.diff(ends.astype(np.int64)) > 0), "episode_ends must be positive increasing integer vector"): |
| continue |
| T = int(ends[-1]) |
| task_result["frames"] = T |
| for key in data.array_keys(): |
| local.require(data[key].ndim >= 1 and data[key].shape[0] == T, key + ": inconsistent first dimension") |
| for key, tail in STANDARD_SHAPES.items(): |
| local.require(key in data and data[key].shape == (T,) + tail, key + ": missing or wrong shape") |
| local.require("right_wrist_pose" not in data, |
| "right_wrist_pose must be omitted until a verified FTP-1 gripper-frame transform is available") |
| for role in CAMERAS: |
| key = role + "_rgb" |
| local.require(key in data and data[key].shape == (T, 360, 640, 3) and data[key].dtype == np.uint8, key + ": expected uint8(T,360,640,3)") |
| for key in ("episode_ids", "episode_names", "source_episode_paths"): |
| local.require(key in meta and meta[key].shape == ends.shape, "meta/" + key + ": missing or wrong shape") |
| if local.errors: |
| continue |
| local.require(np.all(data["right_hand_joints_idx"][:] == 28), "gripper slot must be 28") |
| local.require(data["right_hand_joints_idx"].dtype.kind in "iu", "gripper slot dtype must be integer") |
| local.require(np.all(data["right_tactile_area_wrist_torque"][:] == 15), "wrist torque area must be 15") |
| local.require(data["right_tactile_area_wrist_torque"].dtype.kind in "iu", "wrist torque area dtype must be integer") |
| local.require(data["timestamp_unix_ns"].dtype == np.dtype("int64"), "timestamp_unix_ns must preserve int64 precision") |
| local.require(data["command_dispatched"].dtype == np.dtype("bool"), "command_dispatched must retain boolean dtype") |
| local.require(np.all(strings(data["right_tactile_type_wrist_torque"][:]) == "state"), "wrist torque type must be state") |
| local.require(np.all(strings(data["right_tactile_sensor_wrist_torque"][:]) == "SRIM3813A1"), "unexpected wrist torque sensor identifier") |
| instructions = strings(data["sub_task_instruction"][:]) |
| local.require(bool(np.all(np.char.str_len(np.char.strip(instructions)) > 0)), "empty task instruction") |
| for key in STANDARD_SHAPES: |
| if data[key].dtype.kind in "fc": |
| local.require(np.isfinite(data[key][:]).all(), key + ": nonfinite standard values") |
| ids = strings(meta["episode_ids"][:]).tolist() |
| names = strings(meta["episode_names"][:]).tolist() |
| paths = strings(meta["source_episode_paths"][:]).tolist() |
| local.require(len(ids) == len(set(ids)), "duplicate episode IDs within task") |
| local.require(len(paths) == len(set(paths)), "duplicate native episode paths within task") |
| start = 0 |
| for index, end in enumerate(ends): |
| episode_id = ids[index] |
| exported_ids.append(episode_id) |
| known = audit_by_id.get(episode_id) |
| if audit_doc is not None: |
| local.require(known is not None, "episode absent from source audit: " + episode_id) |
| if known is not None: |
| expected_task = "insert_pen" if known["task_slug"] == "insert" else known["task_slug"] |
| local.require(expected_task == task, "episode assigned to wrong task: " + episode_id) |
| try: |
| ep = validate_episode(data, slice(start, int(end)), root, paths[index], episode_id, |
| names[index], known, scan_rgb_all) |
| except Exception as exc: |
| ep = {"episode_id": episode_id, "episode_name": names[index], "passed": False, |
| "errors": [f"{type(exc).__name__}: {exc}"]} |
| task_result["episodes"].append(ep) |
| start = int(end) |
| task_result["checks"] = local.count |
| except Exception as exc: |
| local.errors.append(f"{type(exc).__name__}: {exc}") |
| finally: |
| task_result["passed"] = not local.errors and bool(task_result["episodes"]) and all(e.get("passed", False) for e in task_result["episodes"]) |
| checks.require(len(exported_ids) == len(set(exported_ids)), "duplicate episode IDs across tasks") |
| if audit_doc is not None: |
| checks.require(set(exported_ids) == set(audit_by_id), "exported episode set differs from frozen source audit") |
| episodes = [e for task in result["tasks"].values() for e in task["episodes"]] |
| result["summary"] = { |
| "tasks": len(result["tasks"]), "episodes": len(episodes), |
| "standard_frames": sum(t.get("frames", 0) for t in result["tasks"].values()), |
| "native_control_rows": sum(e.get("control_rows_native", 0) for e in episodes), |
| "omitted_standard_control_rows": sum(e.get("control_rows_omitted", 0) for e in episodes), |
| "native_ft_samples": sum(e.get("ft_samples_native", 0) for e in episodes), |
| "failed_episodes": sum(not e.get("passed", False) for e in episodes), |
| } |
| result["passed"] = not checks.errors and all(t["passed"] for t in result["tasks"].values()) |
| return result |
|
|
|
|
| def main(argv: list[str] | None = None) -> int: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--dataset-root", type=Path, required=True) |
| parser.add_argument("--report", type=Path, required=True) |
| parser.add_argument("--source-audit", type=Path) |
| parser.add_argument("--scan-rgb-all", action="store_true", help="Read all exported RGB chunks instead of per-episode endpoints") |
| args = parser.parse_args(argv) |
| try: |
| report = validate_export(args.dataset_root, args.source_audit, args.scan_rgb_all) |
| except Exception as exc: |
| report = {"schema": "franka-ft-oxt-validation-v1", "passed": False, |
| "errors": [f"{type(exc).__name__}: {exc}"]} |
| args.report.parent.mkdir(parents=True, exist_ok=True) |
| temporary = args.report.with_name(args.report.name + ".partial") |
| temporary.write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n") |
| temporary.replace(args.report) |
| print(json.dumps({"passed": report["passed"], "report": str(args.report), "summary": report.get("summary"), |
| "errors": report["errors"]}, ensure_ascii=False)) |
| return 0 if report["passed"] else 1 |
|
|
|
|
| if __name__ == "__main__": |
| sys.exit(main()) |
|
|
