#!/usr/bin/env python3 """Build a validated radar-first table joined with two depth frames. The exact join key is recording_id + subject + activity + frame_index. Every radar row must match exactly two depth rows, and every depth row must match at least one radar row. Original .mat and .npy files are never opened. """ from __future__ import annotations import argparse from collections import defaultdict from pathlib import Path import pyarrow as pa import pyarrow.parquet as pq JOIN_KEYS = ("recording_id", "subject", "activity", "frame_index") DEPTH_ITEM_FIELDS = ("relative_path", "sequence_name", "local_frame_index") DEPTH_COLUMNS = (*JOIN_KEYS, *DEPTH_ITEM_FIELDS) RADAR_COLUMNS = ( "relative_path", "recording_id", "sequence_name", "activity", "subject", "snaplength", "format", "win_size", "win_stride", "frame_index", "range_bin_index", "entrophy", ) OUTPUT_SCHEMA = pa.schema( [ pa.field("recording_id", pa.string()), pa.field("subject", pa.string()), pa.field("activity", pa.string()), pa.field("frame_index", pa.int64()), pa.field("radar_path", pa.string()), pa.field("radar_sequence_name", pa.string()), pa.field("radar_snaplength", pa.int64()), pa.field("radar_format", pa.string()), pa.field("radar_win_size", pa.int64()), pa.field("radar_win_stride", pa.int64()), pa.field("radar_range_bin_index", pa.int64()), pa.field("radar_entrophy", pa.float64()), pa.field("depth_paths", pa.list_(pa.string())), pa.field("depth_sequence_names", pa.list_(pa.string())), pa.field("depth_local_frame_indexes", pa.list_(pa.int64())), ] ) JoinKey = tuple[str, str, str, int] def _check_columns( parquet_file: pq.ParquetFile, required: tuple[str, ...], label: str ) -> None: missing = sorted(set(required) - set(parquet_file.schema_arrow.names)) if missing: raise ValueError(f"{label} Parquet is missing columns: {', '.join(missing)}") def _join_key(row: dict[str, object]) -> JoinKey: return ( str(row["recording_id"]), str(row["subject"]), str(row["activity"]), int(row["frame_index"]), ) def _group_and_validate_depth( depth_file: pq.ParquetFile, ) -> dict[JoinKey, list[dict[str, object]]]: """Group depth rows and require exactly two local frames for every key.""" grouped: dict[JoinKey, list[dict[str, object]]] = defaultdict(list) for batch in depth_file.iter_batches(columns=list(DEPTH_COLUMNS), batch_size=100_000): for row in batch.to_pylist(): grouped[_join_key(row)].append( {field: row[field] for field in DEPTH_ITEM_FIELDS} ) invalid = [] for key, items in grouped.items(): items.sort(key=lambda item: (item["local_frame_index"], item["relative_path"])) local_indexes = [item["local_frame_index"] for item in items] if len(items) != 2 or len(set(local_indexes)) != 2: invalid.append((key, len(items), local_indexes)) if invalid: key, count, local_indexes = invalid[0] raise ValueError( "Every frame key must contain exactly two distinct depth local frames; " f"first invalid key={key}, count={count}, local_indexes={local_indexes}. " f"Total invalid keys={len(invalid)}" ) return dict(grouped) def join_radar_and_depth( radar_parquet: str | Path, depth_parquet: str | Path, output_path: str | Path, ) -> int: """Write the radar-first table and return its validated row count.""" radar_path = Path(radar_parquet).expanduser().resolve() depth_path = Path(depth_parquet).expanduser().resolve() output = Path(output_path).expanduser().resolve() for path in (radar_path, depth_path): if not path.is_file(): raise FileNotFoundError(f"Parquet file does not exist: {path}") radar_file = pq.ParquetFile(radar_path) depth_file = pq.ParquetFile(depth_path) _check_columns(radar_file, RADAR_COLUMNS, "Radar") _check_columns(depth_file, DEPTH_COLUMNS, "Depth") depth_items_by_key = _group_and_validate_depth(depth_file) output.parent.mkdir(parents=True, exist_ok=True) temporary_output = output.with_name(f".{output.name}.tmp") temporary_output.unlink(missing_ok=True) matched_depth_keys: set[JoinKey] = set() written_rows = 0 writer = pq.ParquetWriter(temporary_output, OUTPUT_SCHEMA, compression="zstd") try: for batch in radar_file.iter_batches( columns=list(RADAR_COLUMNS), batch_size=100_000 ): output_rows = [] for row in batch.to_pylist(): key = _join_key(row) depth_items = depth_items_by_key.get(key) if depth_items is None: raise ValueError(f"Radar row has no matching depth frames: key={key}") matched_depth_keys.add(key) output_rows.append( { "recording_id": row["recording_id"], "subject": row["subject"], "activity": row["activity"], "frame_index": row["frame_index"], "radar_path": row["relative_path"], "radar_sequence_name": row["sequence_name"], "radar_snaplength": row["snaplength"], "radar_format": row["format"], "radar_win_size": row["win_size"], "radar_win_stride": row["win_stride"], "radar_range_bin_index": row["range_bin_index"], "radar_entrophy": row["entrophy"], "depth_paths": [item["relative_path"] for item in depth_items], "depth_sequence_names": [ item["sequence_name"] for item in depth_items ], "depth_local_frame_indexes": [ item["local_frame_index"] for item in depth_items ], } ) table = pa.Table.from_pylist(output_rows, schema=OUTPUT_SCHEMA) writer.write_table(table) written_rows += table.num_rows except Exception: writer.close() temporary_output.unlink(missing_ok=True) raise else: writer.close() unmatched_depth_keys = depth_items_by_key.keys() - matched_depth_keys if unmatched_depth_keys: temporary_output.unlink(missing_ok=True) example = next(iter(unmatched_depth_keys)) raise ValueError( f"Depth frames have no matching radar row: first key={example}. " f"Total unmatched depth keys={len(unmatched_depth_keys)}" ) expected_rows = radar_file.metadata.num_rows if written_rows != expected_rows: temporary_output.unlink(missing_ok=True) raise RuntimeError( f"Row-count validation failed: output={written_rows}, radar={expected_rows}" ) temporary_output.replace(output) return written_rows def main() -> None: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--radar", required=True, help="Radar index Parquet path") parser.add_argument("--depth", required=True, help="Depth index Parquet path") parser.add_argument("--output", required=True, help="Joined Parquet output path") args = parser.parse_args() row_count = join_radar_and_depth(args.radar, args.depth, args.output) print(f"Wrote {row_count} rows to {Path(args.output).resolve()}") print(f"Validation passed: output rows = radar index rows = {row_count}") print("Validation passed: every radar row has exactly two depth frames") print("Validation passed: every depth frame has a matching radar row") if __name__ == "__main__": main()