| |
|
|
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import hashlib |
| import json |
| from pathlib import Path |
|
|
|
|
| SCENE_EXTENSIONS = (".blend", ".glb", ".gltf") |
|
|
|
|
| def find_scene(sample_dir: Path) -> Path | None: |
| for extension in SCENE_EXTENSIONS: |
| path = sample_dir / f"scene{extension}" |
| if path.is_file(): |
| return path |
| return None |
|
|
|
|
| def load_manifest(path: Path) -> list[dict]: |
| rows: list[dict] = [] |
| seen: set[str] = set() |
| for line_number, line in enumerate(path.read_text(encoding="utf-8").splitlines(), 1): |
| if not line.strip(): |
| continue |
| row = json.loads(line) |
| sample_id = row.get("id") or row.get("sample_id") |
| if not sample_id: |
| raise ValueError(f"missing id at {path}:{line_number}") |
| sample_id = str(sample_id) |
| if sample_id in seen: |
| raise ValueError(f"duplicate sample id at {path}:{line_number}: {sample_id}") |
| seen.add(sample_id) |
| row["id"] = sample_id |
| rows.append(row) |
| if not rows: |
| raise ValueError(f"manifest has no samples: {path}") |
| return rows |
|
|
|
|
| def sha256(path: Path) -> str: |
| digest = hashlib.sha256() |
| with path.open("rb") as stream: |
| for chunk in iter(lambda: stream.read(1024 * 1024), b""): |
| digest.update(chunk) |
| return digest.hexdigest() |
|
|
|
|
| def validate( |
| data_root: Path, |
| manifest_path: Path, |
| models: list[str], |
| *, |
| check_sha256: bool, |
| allow_missing_models: bool, |
| ) -> list[str]: |
| rows = load_manifest(manifest_path) |
| issues: list[str] = [] |
|
|
| for row in rows: |
| sample_id = row["id"] |
| gt_dir = data_root / "gt" / sample_id |
| gt_scene = find_scene(gt_dir) |
| if gt_scene is None: |
| issues.append(f"{sample_id}: missing GT scene.blend|scene.glb|scene.gltf") |
| continue |
|
|
| if check_sha256: |
| metadata_path = gt_dir / "metadata.json" |
| if not metadata_path.is_file(): |
| issues.append(f"{sample_id}: missing metadata.json for checksum validation") |
| else: |
| metadata = json.loads(metadata_path.read_text(encoding="utf-8")) |
| for filename, expected in metadata.get("files", {}).items(): |
| asset = gt_dir / filename |
| if not asset.is_file(): |
| issues.append(f"{sample_id}: missing checksummed file {filename}") |
| elif sha256(asset) != expected: |
| issues.append(f"{sample_id}: checksum mismatch for {filename}") |
|
|
| for model in models: |
| if find_scene(data_root / model / sample_id) is None: |
| message = f"{sample_id}: missing {model} scene.blend|scene.glb|scene.gltf" |
| if not allow_missing_models: |
| issues.append(message) |
|
|
| return issues |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument( |
| "--data_root", |
| required=True, |
| help="Dataset root containing gt/ and optional model submission directories.", |
| ) |
| parser.add_argument("--track_manifest", required=True) |
| parser.add_argument("--models", default="", help="Comma-separated submission directories under data_root") |
| parser.add_argument("--check_sha256", action="store_true") |
| parser.add_argument("--allow_missing_models", action="store_true") |
| return parser.parse_args() |
|
|
|
|
| def main() -> int: |
| args = parse_args() |
| data_root = Path(args.data_root).resolve() |
| manifest_path = Path(args.track_manifest).resolve() |
| models = [model.strip() for model in args.models.split(",") if model.strip()] |
|
|
| try: |
| issues = validate( |
| data_root, |
| manifest_path, |
| models, |
| check_sha256=args.check_sha256, |
| allow_missing_models=args.allow_missing_models, |
| ) |
| except (OSError, ValueError, json.JSONDecodeError) as exc: |
| print(f"[FAIL] {exc}") |
| return 1 |
|
|
| if issues: |
| print(f"[FAIL] {len(issues)} issue(s)") |
| for issue in issues: |
| print(f" - {issue}") |
| return 1 |
|
|
| print(f"[OK] {manifest_path}") |
| print(f"[OK] models={models or ['GT only']} sha256={args.check_sha256}") |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
