training/run_fable_router_structural_campaign.py

"""Run all frozen Fable donor-bank structural smokes sequentially.

This is an interactive cloud-notebook convenience wrapper, not a scheduler and
not a training entry point.  Each bank executes in a fresh subprocess so CUDA
state is released between candidates.  Every child persists its own append-only
pass/fail evidence; the wrapper additionally uploads one campaign summary.
"""
from __future__ import annotations

import argparse
import json
import os
import subprocess
import sys
from datetime import datetime, timezone
from pathlib import Path
from typing import Any

from huggingface_hub import HfApi

from fable_router_common import read_json


DEFAULT_BANKS = (
    "kat-coder-v25-dev-q4km",
    "qwen36-35b-base-q4km",
    "ornith10-35b-q4km",
    "qwen35-35b-base-q4km",
)


def now() -> str:
    return datetime.now(timezone.utc).isoformat()


def run_bank(command: list[str]) -> tuple[int, list[str]]:
    lines: list[str] = []
    process = subprocess.Popen(
        command,
        stdout=subprocess.PIPE,
        stderr=subprocess.STDOUT,
        text=True,
        bufsize=1,
    )
    assert process.stdout is not None
    for raw in process.stdout:
        line = raw.rstrip("\n")
        lines.append(line)
        print(line, flush=True)
    return process.wait(), lines


def result_from_output(lines: list[str]) -> tuple[str | None, dict[str, Any] | None]:
    for line in reversed(lines):
        candidate = Path(line.strip())
        if candidate.name != "result.json" or not candidate.is_file():
            continue
        try:
            payload = json.loads(candidate.read_text(encoding="utf-8"))
        except (OSError, json.JSONDecodeError):
            return str(candidate), None
        return str(candidate), payload if isinstance(payload, dict) else None
    return None, None


def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--owner-execute", action="store_true")
    parser.add_argument("--config", type=Path, required=True)
    parser.add_argument("--platform", choices=("colab", "kaggle", "other"), default="other")
    parser.add_argument("--work-dir", type=Path, required=True)
    parser.add_argument("--runner", type=Path, required=True)
    parser.add_argument("--source-revision", required=True)
    parser.add_argument("--banks", nargs="+", default=list(DEFAULT_BANKS))
    parser.add_argument("--continue-on-failure", action="store_true")
    parser.add_argument(
        "--curriculum-path",
        type=Path,
        help="Verified local sft-train.jsonl override for credential-free cloud execution",
    )
    args = parser.parse_args()
    if not args.owner_execute:
        raise SystemExit("refusing GPU/model execution without --owner-execute")

    config = read_json(args.config.resolve())
    if config.get("trainingAuthorized") is not False or config.get("nonRouting") is not True:
        raise SystemExit("campaign requires an explicitly non-routing, training-disabled config")
    configured = set(config["banks"]["artifacts"])
    if len(args.banks) != len(set(args.banks)) or not set(args.banks).issubset(configured):
        raise SystemExit("campaign banks must be unique configured bank IDs")
    token = os.environ.get("HF_TOKEN")
    if not token and not args.curriculum_path:
        raise SystemExit("either HF_TOKEN or --curriculum-path is required")

    stamp = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
    output = args.work_dir.resolve() / f"fable-router-structural-campaign-{stamp}"
    output.mkdir(parents=True, exist_ok=False)
    summary: dict[str, Any] = {
        "schema": "AutonomaFableRouterStructuralCampaign.v1",
        "status": "running_nonrouting",
        "nonRouting": True,
        "trainingAuthorized": False,
        "startedAt": now(),
        "platform": args.platform,
        "sourceRevision": args.source_revision,
        "bankOrder": list(args.banks),
        "continueOnFailure": bool(args.continue_on_failure),
        "runs": [],
    }

    for index, bank in enumerate(args.banks, start=1):
        print(f"\n=== [{index}/{len(args.banks)}] {bank} ===", flush=True)
        started = now()
        command = [
            sys.executable,
            str(args.runner.resolve()),
            "--owner-execute",
            "--config", str(args.config.resolve()),
            "--bank", bank,
            "--platform", args.platform,
            "--work-dir", str(args.work_dir.resolve()),
        ]
        if args.curriculum_path:
            command.extend(["--curriculum-path", str(args.curriculum_path.resolve())])
        returncode, lines = run_bank(command)
        result_path, result = result_from_output(lines)
        row = {
            "bank": bank,
            "startedAt": started,
            "finishedAt": now(),
            "returnCode": returncode,
            "resultPath": result_path,
            "status": result.get("status") if result else "result_unreadable",
            "passed": bool(result and result.get("passed") is True and returncode == 0),
        }
        if result and isinstance(result.get("error"), dict):
            row["error"] = {
                "type": result["error"].get("type"),
                "message": result["error"].get("message"),
            }
        summary["runs"].append(row)
        (output / "result.json").write_text(json.dumps(summary, indent=2) + "\n", encoding="utf-8")
        if returncode and not args.continue_on_failure:
            break

    all_passed = len(summary["runs"]) == len(args.banks) and all(row["passed"] for row in summary["runs"])
    summary["passed"] = all_passed
    summary["status"] = (
        "campaign_passed_nonrouting" if all_passed else "campaign_completed_with_failures_nonrouting"
    )
    summary["finishedAt"] = now()
    result_path = output / "result.json"
    result_path.write_text(json.dumps(summary, indent=2) + "\n", encoding="utf-8")
    repo = config["smoke"]["resultRepo"]
    remote = f"campaigns/{output.name}/result.json"
    if token:
        HfApi(token=token).upload_file(
            path_or_fileobj=str(result_path),
            path_in_repo=remote,
            repo_id=repo,
            repo_type="dataset",
            commit_message=f"Persist non-routing structural campaign {output.name}",
        )
        summary["evidenceUpload"] = {"repo": repo, "private": True, "path": remote}
        result_path.write_text(json.dumps(summary, indent=2) + "\n", encoding="utf-8")
        HfApi(token=token).upload_file(
            path_or_fileobj=str(result_path),
            path_in_repo=remote,
            repo_id=repo,
            repo_type="dataset",
            commit_message=f"Finalize non-routing structural campaign {output.name}",
        )
    else:
        summary["evidenceUpload"] = {
            "status": "local_only_pending_authenticated_download",
            "privateRemoteCredentialUsed": False,
        }
        result_path.write_text(json.dumps(summary, indent=2) + "\n", encoding="utf-8")
    print(result_path, flush=True)
    return 0 if all_passed else 1


if __name__ == "__main__":
    raise SystemExit(main())