| |
|
|
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import os |
| import re |
| from collections import OrderedDict |
| from pathlib import Path |
| from typing import Any |
|
|
| import numpy as np |
|
|
|
|
| PROJECT_ROOT = Path(__file__).resolve().parents[1] |
| FRAME_SUFFIX_RE = re.compile(r"^(?P<case>.+)_f(?P<frame>\d+)$") |
|
|
|
|
| def _display_path(path: Path) -> str: |
| try: |
| return os.path.relpath(path.resolve(), PROJECT_ROOT) |
| except Exception: |
| return str(path) |
|
|
|
|
| def _load_records(path: Path) -> list[dict[str, Any]]: |
| if not path.exists(): |
| raise FileNotFoundError(f"Missing input manifest: {path}") |
|
|
| if path.suffix.lower() == ".jsonl": |
| records: list[dict[str, Any]] = [] |
| for line_no, line in enumerate(path.read_text(encoding="utf-8").splitlines(), start=1): |
| raw = line.strip() |
| if not raw: |
| continue |
| obj = json.loads(raw) |
| if not isinstance(obj, dict): |
| raise ValueError(f"Expected JSON object at {path}:{line_no}") |
| records.append(obj) |
| return records |
|
|
| payload = json.loads(path.read_text(encoding="utf-8")) |
| if isinstance(payload, list): |
| if not all(isinstance(item, dict) for item in payload): |
| raise ValueError(f"Expected a list of JSON objects in {path}") |
| return list(payload) |
| if isinstance(payload, dict): |
| samples = payload.get("samples") |
| if isinstance(samples, list) and all(isinstance(item, dict) for item in samples): |
| return list(samples) |
| return [payload] |
| raise ValueError(f"Unsupported JSON payload in {path}") |
|
|
|
|
| def _sample_id(row: dict[str, Any]) -> str: |
| sample_id = row.get("sample_id") or row.get("id") |
| if not sample_id: |
| raise ValueError("Missing sample_id/id") |
| return str(sample_id) |
|
|
|
|
| def _case_and_frame(row: dict[str, Any]) -> tuple[str, int | None]: |
| if row.get("case_id"): |
| case_id = str(row["case_id"]) |
| else: |
| sample_id = _sample_id(row) |
| match = FRAME_SUFFIX_RE.match(sample_id) |
| case_id = match.group("case") if match else sample_id |
|
|
| frame_value = row.get("frame") |
| if isinstance(frame_value, (int, np.integer)): |
| return case_id, int(frame_value) |
| if isinstance(frame_value, str) and frame_value.strip().isdigit(): |
| return case_id, int(frame_value.strip()) |
|
|
| sample_id = _sample_id(row) |
| match = FRAME_SUFFIX_RE.match(sample_id) |
| if match: |
| return case_id, int(match.group("frame")) |
| return case_id, None |
|
|
|
|
| def _sort_key(row: dict[str, Any]) -> tuple[int, int, str]: |
| _, frame = _case_and_frame(row) |
| sample_id = _sample_id(row) |
| if frame is None: |
| return (1, 10**9, sample_id) |
| return (0, frame, sample_id) |
|
|
|
|
| def _even_indices(total: int, count: int) -> list[int]: |
| if total <= 0 or count <= 0: |
| return [] |
| if count >= total: |
| return list(range(total)) |
| return np.linspace(0, total - 1, num=count, dtype=int).tolist() |
|
|
|
|
| def _augment_row( |
| row: dict[str, Any], |
| *, |
| benchmark_track: str, |
| case_id: str, |
| selected_frames: list[int], |
| selected_sample_ids: list[str], |
| source_sample_ids: list[str], |
| source_frames: list[int | None], |
| track_rank: int, |
| source_manifest: str, |
| ) -> dict[str, Any]: |
| out = dict(row) |
| out["case_id"] = case_id |
| out["benchmark_track"] = benchmark_track |
| out["track_rank"] = track_rank |
| out["selected_frames"] = selected_frames |
| out["selected_sample_ids"] = selected_sample_ids |
| out["source_sample_ids"] = source_sample_ids |
| out["source_frames"] = source_frames |
| out["source_sample_count"] = len(source_sample_ids) |
| out["source_manifest"] = source_manifest |
| if "frame" not in out or out["frame"] is None: |
| _, frame = _case_and_frame(row) |
| if frame is not None: |
| out["frame"] = frame |
| return out |
|
|
|
|
| def build_track_manifests( |
| input_paths: list[Path], |
| out_dir: Path, |
| *, |
| dynamic_frame_count: int = 7, |
| include_single_frame_dynamic: bool = True, |
| ) -> dict[str, Any]: |
| if dynamic_frame_count <= 0: |
| raise ValueError("dynamic_frame_count must be > 0") |
|
|
| out_dir.mkdir(parents=True, exist_ok=True) |
|
|
| rows_by_case: "OrderedDict[str, list[tuple[dict[str, Any], Path]]]" = OrderedDict() |
| seen_sample_ids: set[str] = set() |
| source_files: list[str] = [] |
|
|
| for path in input_paths: |
| source_files.append(_display_path(path)) |
| for row in _load_records(path): |
| sample_id = _sample_id(row) |
| if sample_id in seen_sample_ids: |
| continue |
| seen_sample_ids.add(sample_id) |
| case_id, _ = _case_and_frame(row) |
| rows_by_case.setdefault(case_id, []).append((row, path)) |
|
|
| static_rows: list[dict[str, Any]] = [] |
| dynamic_rows: list[dict[str, Any]] = [] |
| case_index: list[dict[str, Any]] = [] |
|
|
| for case_id, rows_and_sources in rows_by_case.items(): |
| rows_sorted = sorted(rows_and_sources, key=lambda item: _sort_key(item[0])) |
| rows = [row for row, _ in rows_sorted] |
| source_manifest = _display_path(rows_sorted[0][1]) if rows_sorted else "" |
| source_sample_ids = [_sample_id(row) for row in rows] |
| source_frames = [_case_and_frame(row)[1] for row in rows] |
|
|
| static_source = next((row for row in rows if _case_and_frame(row)[1] == 1), None) |
| if static_source is None: |
| static_source = rows[0] |
| static_frames = [_case_and_frame(static_source)[1]] |
| if static_frames[0] is None: |
| static_frames = [] |
| static_row = _augment_row( |
| static_source, |
| benchmark_track="static", |
| case_id=case_id, |
| selected_frames=static_frames, |
| selected_sample_ids=[_sample_id(static_source)], |
| source_sample_ids=source_sample_ids, |
| source_frames=source_frames, |
| track_rank=0, |
| source_manifest=source_manifest, |
| ) |
| static_rows.append(static_row) |
|
|
| dynamic_selected_rows: list[tuple[dict[str, Any], int]] = [] |
| if len(rows) == 1 and not include_single_frame_dynamic: |
| dynamic_selected_rows = [] |
| else: |
| selected_indices = _even_indices(len(rows), dynamic_frame_count) |
| dynamic_selected_rows = [(rows[idx], rank) for rank, idx in enumerate(selected_indices)] |
|
|
| dynamic_selected_frames = [] |
| dynamic_selected_ids = [] |
| for row, _ in dynamic_selected_rows: |
| _, frame = _case_and_frame(row) |
| if frame is not None: |
| dynamic_selected_frames.append(frame) |
| dynamic_selected_ids.append(_sample_id(row)) |
|
|
| for row, rank in dynamic_selected_rows: |
| dynamic_rows.append( |
| _augment_row( |
| row, |
| benchmark_track="dynamic", |
| case_id=case_id, |
| selected_frames=dynamic_selected_frames, |
| selected_sample_ids=dynamic_selected_ids, |
| source_sample_ids=source_sample_ids, |
| source_frames=source_frames, |
| track_rank=rank, |
| source_manifest=source_manifest, |
| ) |
| ) |
|
|
| case_index.append( |
| { |
| "case_id": case_id, |
| "source_sample_ids": source_sample_ids, |
| "source_frames": source_frames, |
| "source_sample_count": len(source_sample_ids), |
| "static_sample_id": _sample_id(static_source), |
| "static_frame": static_frames[0] if static_frames else None, |
| "dynamic_sample_ids": dynamic_selected_ids, |
| "dynamic_frames": dynamic_selected_frames, |
| "dynamic_sample_count": len(dynamic_selected_ids), |
| } |
| ) |
|
|
| static_path = out_dir / "static.jsonl" |
| dynamic_path = out_dir / "dynamic.jsonl" |
| case_index_path = out_dir / "case_index.json" |
| summary_path = out_dir / "track_summary.json" |
|
|
| with static_path.open("w", encoding="utf-8") as f: |
| for row in static_rows: |
| f.write(json.dumps(row, ensure_ascii=False) + "\n") |
|
|
| with dynamic_path.open("w", encoding="utf-8") as f: |
| for row in dynamic_rows: |
| f.write(json.dumps(row, ensure_ascii=False) + "\n") |
|
|
| case_index_path.write_text(json.dumps(case_index, indent=2, ensure_ascii=False) + "\n", encoding="utf-8") |
|
|
| summary = { |
| "source_files": source_files, |
| "case_count": len(rows_by_case), |
| "static_row_count": len(static_rows), |
| "dynamic_row_count": len(dynamic_rows), |
| "dynamic_frame_count": dynamic_frame_count, |
| "include_single_frame_dynamic": include_single_frame_dynamic, |
| "static_manifest": _display_path(static_path), |
| "dynamic_manifest": _display_path(dynamic_path), |
| "case_index": _display_path(case_index_path), |
| } |
| summary_path.write_text(json.dumps(summary, indent=2, ensure_ascii=False) + "\n", encoding="utf-8") |
| return { |
| "summary": summary, |
| "case_index": case_index, |
| "static_rows": static_rows, |
| "dynamic_rows": dynamic_rows, |
| } |
|
|
|
|
| def build_parser() -> argparse.ArgumentParser: |
| parser = argparse.ArgumentParser(description="Split manifests into static and dynamic tracks") |
| parser.add_argument( |
| "--inputs", |
| nargs="+", |
| required=True, |
| help="Input JSON or JSONL manifests", |
| ) |
| parser.add_argument("--out_dir", required=True, help="Output directory for track manifests") |
| parser.add_argument("--dynamic_frame_count", type=int, default=7, help="Frames to keep per dynamic case") |
| parser.add_argument( |
| "--include_single_frame_dynamic", |
| action=argparse.BooleanOptionalAction, |
| default=True, |
| help="Keep singleton cases in the dynamic track", |
| ) |
| return parser |
|
|
|
|
| def main() -> None: |
| args = build_parser().parse_args() |
| input_paths = [Path(p) for p in args.inputs] |
| out_dir = Path(args.out_dir) |
| result = build_track_manifests( |
| input_paths, |
| out_dir, |
| dynamic_frame_count=args.dynamic_frame_count, |
| include_single_frame_dynamic=args.include_single_frame_dynamic, |
| ) |
| print(json.dumps(result["summary"], indent=2, ensure_ascii=False)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
