Sync submission checker docs

PLAN.md

@@ -113,6 +113,7 @@ All times are `America/Los_Angeles` / PDT unless noted.
 - 2026-06-14 01:27: addressed the submission-readiness review by adding hero-name parsing, making Draft Lab demoable, adding tests, preparing a dataset card, declaring Apache-2.0 licensing, and aligning the Modal dependency version.
 - 2026-06-14 02:36: continued demo-readiness hardening by adding role-aware recommendation filtering, Bayesian win-rate shrinkage for low samples, pre-game item timing labels, and a repeatable public Space API check script.
 - 2026-06-14 02:41: replaced the generic generated adapter README with a DOTA2Tuned-specific model card covering intended behavior, evidence discipline, usage, evaluation notes, limitations, and public links.
+- 2026-06-14 02:57: added a final submission-readiness checker that verifies public URLs, Space runtime, Hub model/dataset cards, git cleanliness, and all public Gradio API endpoints while listing the human-only video/social/submission steps separately.
 
 ## Adapter Eval Notes
 

SUBMISSION.md

@@ -80,6 +80,7 @@ uv run python -c "from app import demo; print(type(demo).__name__, len(demo.bloc
 uv run dota2tuned modal-smoke
 uv run dota2tuned modal-ask "Suggest one mid hero against Phantom Assassin and Witch Doctor. Include one caveat." --context "Use only grounded advice. Mention that sample sizes and patch context matter." --max-new-tokens 160
 uv run python scripts/check_public_space.py
+uv run python scripts/check_submission_ready.py
 curl -L -sS -o /dev/null -w '%{http_code}\n' https://build-small-hackathon-dota2tuned.hf.space
 curl -sS -o /dev/null -w '%{http_code}\n' https://dracufeuer--dota2tuned-ui.modal.run
 git status --short --branch

scripts/check_submission_ready.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+from urllib.error import HTTPError, URLError
+from urllib.request import Request, urlopen
+
+from check_public_space import DEFAULT_SPACE, run_checks
+from huggingface_hub import HfApi
+
+DEFAULT_MODEL_REPO = "build-small-hackathon/dota2tuned-qwen3-4b-2507-lora"
+DEFAULT_DATASET_REPO = "build-small-hackathon/dota2tuned-data"
+DEFAULT_MODAL_URL = "https://dracufeuer--dota2tuned-ui.modal.run"
+DEFAULT_GITHUB_REPO = "https://github.com/1ncompleteness/DOTA2Tuned"
+
+MANUAL_ITEMS = [
+    "Record short demo video.",
+    "Publish social post.",
+    "Submit Space link, demo video link, and social post link by June 15, 2026.",
+]
+
+
+def _http_status(url: str, *, timeout: int = 30) -> dict[str, Any]:
+    request = Request(url, headers={"User-Agent": "DOTA2Tuned submission checker"})
+    try:
+        with urlopen(request, timeout=timeout) as response:
+            return {"ok": 200 <= response.status < 400, "status": response.status}
+    except HTTPError as exc:
+        return {"ok": False, "status": exc.code, "error": str(exc)}
+    except URLError as exc:
+        return {"ok": False, "status": None, "error": str(exc.reason)}
+
+
+def _git_status() -> dict[str, Any]:
+    result = subprocess.run(
+        ["git", "status", "--short", "--branch"],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    lines = result.stdout.strip().splitlines()
+    changed = [line for line in lines[1:] if line.strip()]
+    return {
+        "ok": result.returncode == 0 and not changed,
+        "returncode": result.returncode,
+        "status": lines,
+    }
+
+
+def _repo_has_file(api: HfApi, repo_id: str, repo_type: str, filename: str) -> dict[str, Any]:
+    try:
+        if repo_type == "model":
+            info = api.model_info(repo_id)
+        elif repo_type == "dataset":
+            info = api.dataset_info(repo_id)
+        else:
+            raise ValueError(f"unsupported repo_type: {repo_type}")
+        files = {sibling.rfilename for sibling in info.siblings}
+        return {"ok": filename in files, "file": filename, "repo": repo_id}
+    except Exception as exc:  # pragma: no cover - network smoke script
+        return {"ok": False, "file": filename, "repo": repo_id, "error": repr(exc)}
+
+
+def _space_runtime(api: HfApi, space_id: str) -> dict[str, Any]:
+    try:
+        info = api.space_info(space_id)
+        runtime = getattr(info, "runtime", None)
+        stage = getattr(runtime, "stage", str(runtime))
+        return {"ok": stage == "RUNNING", "stage": stage, "space": space_id}
+    except Exception as exc:  # pragma: no cover - network smoke script
+        return {"ok": False, "space": space_id, "error": repr(exc)}
+
+
+def run_submission_checks(args: argparse.Namespace) -> dict[str, Any]:
+    token = os.getenv("HF_TOKEN")
+    api = HfApi(token=token)
+    space_id = args.space_repo
+    checks: dict[str, Any] = {
+        "git_clean": _git_status(),
+        "space_http": _http_status(args.space_url),
+        "modal_http": _http_status(args.modal_url),
+        "github_http": _http_status(args.github_repo),
+        "space_runtime": _space_runtime(api, space_id),
+        "model_card": _repo_has_file(api, args.model_repo, "model", "README.md"),
+        "dataset_card": _repo_has_file(api, args.dataset_repo, "dataset", "README.md"),
+    }
+    if not args.skip_public_api:
+        public_api = run_checks(args.space_url)
+        checks["public_space_api"] = {
+            "ok": all(item["status"] == "ok" for item in public_api["checks"]),
+            "checks": public_api["checks"],
+        }
+    return {
+        "generated_at": datetime.now(UTC).isoformat(),
+        "machine_checks": checks,
+        "manual_remaining": MANUAL_ITEMS,
+        "links": {
+            "space": args.space_url,
+            "github": args.github_repo,
+            "model": f"https://huggingface.co/{args.model_repo}",
+            "dataset": f"https://huggingface.co/datasets/{args.dataset_repo}",
+            "modal": args.modal_url,
+        },
+    }
+
+
+def _machine_ok(payload: dict[str, Any]) -> bool:
+    return all(check.get("ok") is True for check in payload["machine_checks"].values())
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Run final DOTA2Tuned submission checks.")
+    parser.add_argument("--space-url", default=DEFAULT_SPACE)
+    parser.add_argument("--space-repo", default="build-small-hackathon/dota2tuned")
+    parser.add_argument("--model-repo", default=DEFAULT_MODEL_REPO)
+    parser.add_argument("--dataset-repo", default=DEFAULT_DATASET_REPO)
+    parser.add_argument("--modal-url", default=DEFAULT_MODAL_URL)
+    parser.add_argument("--github-repo", default=DEFAULT_GITHUB_REPO)
+    parser.add_argument(
+        "--output",
+        default="submission_evidence/final_submission_check.json",
+        help="Path for JSON evidence output.",
+    )
+    parser.add_argument(
+        "--skip-public-api",
+        action="store_true",
+        help="Skip Gradio endpoint checks when only public artifact status is needed.",
+    )
+    args = parser.parse_args()
+
+    payload = run_submission_checks(args)
+    output_path = Path(args.output)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(json.dumps(payload, indent=2), encoding="utf-8")
+
+    print("Machine checks:")
+    for name, check in payload["machine_checks"].items():
+        detail = check.get("stage") or check.get("status") or check.get("file") or ""
+        print(f"- {name}: {'ok' if check.get('ok') else 'fail'} {detail}")
+    print("\nManual remaining:")
+    for item in payload["manual_remaining"]:
+        print(f"- {item}")
+    print(f"\nWrote {output_path}")
+
+    if not _machine_ok(payload):
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()