| |
| """Pull a results repository and summarise what landed. |
| |
| The Kaggle operator uploads ``<namespace>/<lane>/manifest.json`` + per-condition |
| JSON to ``yamahei21/uzu-results`` (private). This downloads it and prints what is complete, what is |
| missing, and whether any manifest reported problems, so nobody has to eyeball a |
| directory tree. |
| |
| Usage: |
| python scripts/pull_results.py --repo yamahei21/uzu-results --out results/shared |
| python scripts/pull_results.py --out results/shared --skip-download |
| python scripts/pull_results.py --repo ... --out ... --json results/summary.json |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import subprocess |
| import sys |
| from pathlib import Path |
| from typing import Any |
|
|
|
|
| def load_manifests(root: Path) -> list[dict[str, Any]]: |
| manifests = [] |
| for path in sorted(root.rglob("manifest.json")): |
| try: |
| payload = json.loads(path.read_text(encoding="utf-8")) |
| except json.JSONDecodeError: |
| print(f"skip unreadable {path}") |
| continue |
| payload["_path"] = str(path) |
| manifests.append(payload) |
| return manifests |
|
|
|
|
| def summarise(root: Path) -> dict[str, Any]: |
| manifests = load_manifests(root) |
| lanes = [] |
| total_conditions = 0 |
| problems: list[str] = [] |
| for manifest in manifests: |
| results = manifest.get("results", []) |
| lane = { |
| "lane": manifest.get("lane") or Path(manifest["_path"]).parent.name, |
| "conditions": len(results), |
| "complete": sum(1 for result in results if result.get("status") == "complete"), |
| "problems": manifest.get("problems", []), |
| "spec": manifest.get("spec"), |
| "updated": manifest.get("updated"), |
| "path": manifest["_path"], |
| } |
| total_conditions += lane["conditions"] |
| problems.extend(f"{lane['lane']}: {problem}" for problem in lane["problems"]) |
| lanes.append(lane) |
| return { |
| "lanes": lanes, |
| "lane_count": len(lanes), |
| "condition_count": total_conditions, |
| "problems": problems, |
| } |
|
|
|
|
| def format_table(summary: dict[str, Any]) -> str: |
| lines = ["| lane | conditions | complete | problems | updated |", "|---|---:|---:|---:|---|"] |
| for lane in summary["lanes"]: |
| lines.append( |
| f"| {lane['lane']} | {lane['conditions']} | {lane['complete']} " |
| f"| {len(lane['problems'])} | {lane.get('updated') or '-'} |" |
| ) |
| return "\n".join(lines) |
|
|
|
|
| def download(repo: str, out: Path, revision: str | None) -> None: |
| command = ["hf", "download", repo, "--repo-type", "dataset", "--local-dir", str(out)] |
| if revision: |
| command += ["--revision", revision] |
| print("$ " + " ".join(command), flush=True) |
| subprocess.run(command, check=False) |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) |
| parser.add_argument("--repo", default="yamahei21/uzu-results", help="HF dataset repo") |
| parser.add_argument("--revision", default=None) |
| parser.add_argument("--out", type=Path, required=True) |
| parser.add_argument("--skip-download", action="store_true") |
| parser.add_argument("--json", type=Path, default=None) |
| parser.add_argument("--strict", action="store_true", help="exit 1 when a manifest reports problems") |
| args = parser.parse_args() |
|
|
| if not args.skip_download: |
| if not args.repo: |
| parser.error("--repo is required unless --skip-download is set") |
| download(args.repo, args.out, args.revision) |
|
|
| if not args.out.exists(): |
| raise SystemExit(f"nothing at {args.out}") |
|
|
| summary = summarise(args.out) |
| print(json.dumps(summary, indent=2, ensure_ascii=False)[:1500]) |
| print() |
| print(format_table(summary)) |
| print(f"\nlanes: {summary['lane_count']} conditions: {summary['condition_count']}") |
| if summary["problems"]: |
| print("PROBLEMS") |
| for problem in summary["problems"]: |
| print(f" - {problem}") |
| if args.strict: |
| raise SystemExit(1) |
| if args.json: |
| args.json.parent.mkdir(parents=True, exist_ok=True) |
| args.json.write_text(json.dumps(summary, indent=2, ensure_ascii=False) + "\n", encoding="utf-8") |
| print(f"wrote {args.json}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
