sync.py

"""Publishing tasks from the agent repository's ``data/tasks`` into this dataset.

For every task directory with a plan the agent's schema accepts:

* ``tasks/<name>/`` gets the manifest and exactly the files the manifest names, nothing
  else (no results, no scorer cache, no plan);
* ``truth/<name>/`` gets the plan and, when there is one, the recipe;
* ``tasks.jsonl`` gets the task's row: what it is, how big, and the hashes of its inputs
  and its truth;
* the card's leaderboard is written again from the agent's benchmark summaries
  (``cataflow_agent.benchmark.leaderboard``, shared with ``cataflow-bench-runs``).

A task published before is compared by hash: unchanged tasks are left alone, changed ones
are refused unless ``--force`` is given, since a run that cites the task by hash must keep
finding it. A file the manifest names that is missing fails the task; a file lying in the
source that the manifest does not name is reported and not published.

    uv run python sync.py [--source ../agent/data/tasks] [--summaries ../agent/benchmarks/results]
                          [--only PATTERN]... [--force] [--dry-run]
"""

from __future__ import annotations

import argparse
import fnmatch
import hashlib
import json
import shutil
import sys
from collections.abc import Iterable
from dataclasses import dataclass, field
from pathlib import Path
from typing import Any

from cataflow_agent.benchmark import leaderboard
from cataflow_generator.plan import TaskPlan
from pydantic import ValidationError

MANIFEST = "task.json"
PLAN = "plan.json"
RECIPE = "recipe.json"
TASKS_DIR = "tasks"
TRUTH_DIR = "truth"
INDEX = "tasks.jsonl"
FILE_KEYS = ("files", "referenceImages")
"""The manifest keys whose values name files, wherever they sit."""
NOT_INPUTS = {PLAN, RECIPE, "oracle.json", "results", "images", "__pycache__"}
"""What lies in a source task directory besides the inputs: truth, verdicts, run leftovers."""
DEFAULT_SOURCE = Path("../agent/data/tasks")
DEFAULT_SUMMARIES = Path("../agent/benchmarks/results")
DEFAULT_RESULTS = Path("../agent/results")


@dataclass
class Outcome:
    name: str
    state: str
    """``new``, ``unchanged``, ``changed``, ``refused``, ``skipped``, ``failed``."""
    detail: str = ""
    row: dict[str, Any] | None = None
    unreferenced: list[str] = field(default_factory=list)


def referenced_files(manifest: Any) -> list[str]:
    """Every file the manifest names, under any ``files`` or ``referenceImages`` key at any
    depth: sorted, each once."""
    found: set[str] = set()

    def walk(node: Any) -> None:
        if isinstance(node, dict):
            for key, value in node.items():
                if key in FILE_KEYS and isinstance(value, list):
                    found.update(v for v in value if isinstance(v, str))
                walk(value)
        elif isinstance(node, list):
            for value in node:
                walk(value)

    walk(manifest)
    return sorted(found)


def hash_files(root: Path, files: Iterable[str]) -> str:
    """One hash over the named files: their paths and their bytes, in path order."""
    digest = hashlib.sha256()
    for name in sorted(set(files)):
        digest.update(name.encode("utf-8"))
        digest.update(b"\0")
        digest.update(hashlib.sha256((root / name).read_bytes()).hexdigest().encode("ascii"))
        digest.update(b"\n")
    return digest.hexdigest()


def describe(plan: TaskPlan, inputs: list[str], root: Path, truth: list[str]) -> dict[str, Any]:
    """The task's row in the index."""
    batches = plan.batches
    return {
        "name": plan.name,
        "store": plan.store,
        "split": plan.split,
        "generator_version": plan.generator_version,
        "seed": plan.seed,
        "batches": len(batches),
        "cards": sum(len(b.cards) for b in batches),
        "documents": sum(len(b.documents) for b in batches),
        "expected_products": sum(len(b.expected) for b in batches),
        "hidden_answers": sum(len(b.hidden_answers) for b in batches),
        "difficulty": max((b.difficulty for b in batches), default=0),
        "answer_languages": sorted({b.answer_language for b in batches if b.answer_language}),
        "scenarios": sorted({s for b in batches for s in b.scenarios}),
        "files": len(inputs),
        "bytes": sum((root / f).stat().st_size for f in inputs),
        "content_sha256": hash_files(root, inputs),
        "truth_sha256": hash_files(root, truth),
    }


def unreferenced_files(source: Path, inputs: set[str]) -> list[str]:
    """Files in the source that are neither inputs nor known non-inputs: something the
    manifest forgot, or a leftover of a run written into the task's root."""
    found: list[str] = []
    for path in sorted(source.rglob("*")):
        if not path.is_file():
            continue
        parts = path.relative_to(source).parts
        if parts[0] in NOT_INPUTS or parts[0] == MANIFEST:
            continue
        name = "/".join(parts)
        if name not in inputs:
            found.append(name)
    return found


def inspect(source: Path, previous: dict[str, Any] | None) -> Outcome:
    """What publishing this source directory would do, without doing it."""
    name = source.name
    if not (source / PLAN).is_file() or not (source / MANIFEST).is_file():
        return Outcome(name, "skipped", "no plan.json or task.json")
    try:
        plan = TaskPlan.model_validate_json((source / PLAN).read_text(encoding="utf-8"))
    except ValidationError as exc:
        first = exc.errors()[0]
        where = ".".join(str(p) for p in first["loc"])
        return Outcome(name, "skipped", f"plan does not validate: {where}: {first['msg']}")
    if plan.name != name:
        return Outcome(name, "failed", f"plan is named {plan.name!r}, the directory {name!r}")
    manifest = json.loads((source / MANIFEST).read_text(encoding="utf-8"))
    inputs = referenced_files(manifest)
    missing = [f for f in inputs if not (source / f).is_file()]
    if missing:
        return Outcome(name, "failed", f"the manifest names files that are missing: {missing}")
    truth = [PLAN] + ([RECIPE] if (source / RECIPE).is_file() else [])
    row = describe(plan, [MANIFEST, *inputs], source, truth)
    outcome = Outcome(name, "new", row=row, unreferenced=unreferenced_files(source, set(inputs)))
    if previous is not None:
        same = (
            previous.get("content_sha256") == row["content_sha256"]
            and previous.get("truth_sha256") == row["truth_sha256"]
        )
        outcome.state = "unchanged" if same else "changed"
    return outcome


def publish(source: Path, target: Path, outcome: Outcome) -> None:
    """Writes the task under ``tasks/`` and its truth under ``truth/``, replacing what was
    there."""
    assert outcome.row is not None
    task_dir = target / TASKS_DIR / outcome.name
    truth_dir = target / TRUTH_DIR / outcome.name
    for place in (task_dir, truth_dir):
        if place.exists():
            shutil.rmtree(place)
    manifest = json.loads((source / MANIFEST).read_text(encoding="utf-8"))
    for name in [MANIFEST, *referenced_files(manifest)]:
        _copy(source / name, task_dir / name)
    for name in (PLAN, RECIPE):
        if (source / name).is_file():
            _copy(source / name, truth_dir / name)


def read_index(target: Path) -> dict[str, dict[str, Any]]:
    path = target / INDEX
    if not path.is_file():
        return {}
    rows = [json.loads(line) for line in path.read_text(encoding="utf-8").splitlines() if line]
    return {row["name"]: row for row in rows}


def write_index(target: Path, rows: dict[str, dict[str, Any]]) -> None:
    lines = [json.dumps(rows[name], ensure_ascii=False) for name in sorted(rows)]
    (target / INDEX).write_text("\n".join(lines) + "\n", encoding="utf-8")


def sync(
    source_root: Path,
    target: Path,
    *,
    only: list[str] | None = None,
    force: bool = False,
    dry_run: bool = False,
) -> list[Outcome]:
    """Publishes every matching task; the outcomes, one per source directory."""
    index = read_index(target)
    outcomes: list[Outcome] = []
    for source in sorted(p for p in source_root.iterdir() if p.is_dir()):
        if only and not any(fnmatch.fnmatch(source.name, pattern) for pattern in only):
            continue
        outcome = inspect(source, index.get(source.name))
        if outcome.state == "changed" and not force:
            outcome.state = "refused"
            outcome.detail = "inputs or truth changed since it was published; --force replaces it"
        published = (target / TASKS_DIR / outcome.name / MANIFEST).is_file()
        if outcome.state == "unchanged" and not published:
            outcome.state = "new"
            outcome.detail = "listed but not on disk"
        if outcome.state in ("new", "changed") and not dry_run:
            publish(source, target, outcome)
            assert outcome.row is not None
            index[outcome.name] = outcome.row
        outcomes.append(outcome)
    if not dry_run and any(o.state in ("new", "changed") for o in outcomes):
        write_index(target, index)
    return outcomes


def report(outcomes: list[Outcome]) -> None:
    for o in outcomes:
        line = f"{o.state:10} {o.name}"
        if o.detail:
            line += f"  {o.detail}"
        if o.row and o.state in ("new", "changed", "unchanged"):
            line += f"  ({o.row['files']} files, {o.row['bytes'] / 1e6:.1f} MB)"
        print(line)
        for name in o.unreferenced:
            print(f"{'':10} {o.name}: not in the manifest, not published: {name}")
    counts: dict[str, int] = {}
    for o in outcomes:
        counts[o.state] = counts.get(o.state, 0) + 1
    print(", ".join(f"{n} {state}" for state, n in sorted(counts.items())))


def main(argv: list[str] | None = None) -> int:
    parser = argparse.ArgumentParser(prog="cataflow-bench sync")
    parser.add_argument("--source", type=Path, default=DEFAULT_SOURCE, help="the agent's tasks")
    parser.add_argument(
        "--results",
        type=Path,
        default=DEFAULT_RESULTS,
        help="the agent's runs (results/<label>/<task>/), for the leaderboard's declarations",
    )
    parser.add_argument("--target", type=Path, default=Path(__file__).parent, help="this dataset")
    parser.add_argument("--only", action="append", default=[], help="task name patterns")
    parser.add_argument(
        "--summaries",
        type=Path,
        default=DEFAULT_SUMMARIES,
        help="the agent's benchmark summaries, for the card's leaderboard",
    )
    parser.add_argument("--force", action="store_true", help="replace tasks whose inputs changed")
    parser.add_argument("--dry-run", action="store_true", help="report, write nothing")
    args = parser.parse_args(argv)
    if not args.source.is_dir():
        print(f"no such source: {args.source}", file=sys.stderr)
        return 2
    outcomes = sync(
        args.source, args.target, only=args.only, force=args.force, dry_run=args.dry_run
    )
    report(outcomes)
    found = leaderboard.benchmarks(args.summaries)
    if not args.dry_run:
        section = leaderboard.leaderboard(
            args.summaries, read_index(args.target), results_root=args.results
        )
        changed = leaderboard.write(args.target / "README.md", section)
        state = "updated" if changed else "unchanged"
        print(f"leaderboard: {len(found)} benchmark(s); README {state}")
    else:
        print(f"leaderboard: {len(found)} benchmark(s) would be written to the README")
    return 1 if any(o.state in ("refused", "failed") for o in outcomes) else 0


def _copy(src: Path, dst: Path) -> None:
    dst.parent.mkdir(parents=True, exist_ok=True)
    shutil.copyfile(src, dst)


if __name__ == "__main__":
    sys.exit(main())