| |
| """Resolve a clip frame to source timing, scene and optional recorded controls.""" |
| import argparse |
| import json |
| from pathlib import Path |
| import sqlite3 |
|
|
|
|
| def resolve_source(root, value): |
| if value.startswith('source/'): |
| value = value[len('source/'):] |
| path = (root / value).resolve() |
| path.relative_to(root.resolve()) |
| return path |
|
|
|
|
| def rows(path): |
| with path.open(encoding='utf-8-sig') as stream: |
| for line in stream: |
| if line.strip(): |
| yield json.loads(line) |
|
|
|
|
| def inspect(index, source_root, alignment_path, side, position, records=False): |
| alignment = json.loads(alignment_path.read_text()) |
| aligned = alignment[side][position] |
| conn = sqlite3.connect(index.resolve().as_uri() + '?mode=ro', uri=True) |
| conn.row_factory = sqlite3.Row |
| with conn: |
| result = conn.execute('SELECT * FROM frames WHERE frame_id=?', |
| (aligned['frame_id'],)).fetchone() |
| if result is None: |
| raise ValueError(f'Unknown frame_id {aligned["frame_id"]}') |
| frame = dict(result) |
| segment = dict(conn.execute('SELECT * FROM segments WHERE segment_id=?', |
| (frame['segment_id'],)).fetchone()) |
| conn.close() |
| output_dir = resolve_source(source_root, segment['output_directory']) |
| episode_root = output_dir.parents[3] |
| episode_root.relative_to(source_root.resolve()) |
| output = {'side': side, 'clip_frame': position, |
| 'clip_grid_ns': alignment['grid_ns'][position], |
| 'source_alignment': aligned, 'source_frame': frame, 'segment': segment, |
| 'episode_root': str(episode_root), |
| 'scene_path': str(output_dir / frame['scene_index']) if frame.get('scene_index') else None} |
| frame_path = output_dir / 'frames.jsonl' |
| details = next((r for r in rows(frame_path) |
| if r['proxy_frame_index'] == frame['proxy_frame_index']), None) |
| if details is None: |
| raise ValueError('Published per-frame metadata is missing') |
| output['render_frame_metadata'] = details |
| if records: |
| domain = frame['server_clock_domain'] |
| clock_domain = frame['client_clock_domain'] |
| world = next((r for r in rows(episode_root / '.spool/world_state.jsonl') |
| if r.get('sample_seq') == frame['world_capture_tick'] |
| and r.get('server_clock_domain') == domain), None) |
| output['world_record'] = world |
| client_path = episode_root / '.spool/agents' / segment['agent_id'] / 'client.jsonl' |
| matching = [] |
| method = None |
| for record in rows(client_path): |
| if record.get('server_clock_domain') != domain: |
| continue |
| if clock_domain and record.get('client_clock_domain') != clock_domain: |
| continue |
| if details.get('render_frame_id') is not None: |
| matches = record.get('render_frame_id') == details['render_frame_id'] |
| method = 'same_render_frame_id_and_clock_domains' |
| elif frame.get('client_sample_seq') is not None: |
| matches = record.get('client_sample_seq') == frame['client_sample_seq'] |
| method = 'same_client_sample_seq_and_clock_domains' |
| else: |
| matches = record.get('sample_seq_estimate') == details.get('camera_capture_tick') |
| method = 'same_camera_capture_tick_and_clock_domains' |
| if matches: |
| matching.append(record) |
| output['client_match_method'] = method |
| output['client_records'] = matching |
| output['client_match_count'] = len(matching) |
| output['note'] = ('Raw observations only. Interpolated cameras and smoothing may use ' |
| 'adjacent observations; these records alone do not recreate that filter.') |
| return output |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument('--index', type=Path, required=True) |
| parser.add_argument('--source-root', type=Path, required=True, |
| help='Directory where map and episode metadata archives were extracted') |
| parser.add_argument('--alignment', type=Path, required=True) |
| parser.add_argument('--side', choices=['left', 'right'], default='left') |
| parser.add_argument('--frame', type=int, default=0) |
| parser.add_argument('--records', action='store_true', |
| help='Scan episode raw streams for world state and matching client observations') |
| parser.add_argument('--output', type=Path, help='Write JSON to a new file instead of stdout') |
| args = parser.parse_args() |
| output = inspect(args.index, args.source_root, args.alignment, args.side, args.frame, args.records) |
| text = json.dumps(output, ensure_ascii=False, indent=2) + '\n' |
| if args.output: |
| with args.output.open('x', encoding='utf-8') as stream: |
| stream.write(text) |
| else: |
| print(text, end='') |
|
|
|
|
| if __name__ == '__main__': |
| main() |
|
|
