Rebuild: b2b6920d (publish_results + verified publish)

kit_manifest.json

@@ -1,5 +1,5 @@
 {
-  "built_from_commit": "6c480a5f6224f7598c6c0b6388bcadc8f16502a5",
+  "built_from_commit": "b2b6920d14d9f9a4c5dda98f3ca69e1ebbb96fa2",
   "capabilities": [
     "rht_int4_convert.layer_filter",
     "eval_quantized.dtype",
@@ -28,7 +28,7 @@
     "scripts/lalamo_forward.py": "e4429221ecb6127faae9a5770bcc16d4e72d7c5ab7a7e2171477266be820745a",
     "scripts/kaggle_usage.py": "e1c4c1a902d716e09a9b8fce9a0019b152a758f2390dd34c678fc44c7aef48b1",
     "scripts/eval_generation.py": "bc240aef06c6ede583c3334fd0483ca9153ca07a52e22ef53c85c0b4fb90f7d2",
-    "scripts/pull_results.py": "e5873cfda71dcebcf86e1ecfaacefc9bf01a142521d06c065654eaea7d07de5c",
+    "scripts/pull_results.py": "ad51bdd36f7ebed06ec2b7c107b00009e219a645dd148bd568737ec95cc0bfaa",
     "scripts/corpus_guard.py": "5f226a81988acaebd80b8b81dfb4207ed8b661e52067b0260deec6ee48e9af6a",
     "scripts/dedup_lines.py": "d7caa00dc29f0ba48bc1bdac675e2ed5d81f0514d5d9df17a8f5b2017e6ea8d4",
     "scripts/dedup_calibration.py": "62ecc3c3921d307048c9e3547026634b616110115baf561f74dfb74c91e89b7d",
@@ -37,9 +37,10 @@
     "scripts/preflight.py": "5c2bcbe3693c8abf645fbf3f8160d96fdc1695daf09dc4961464ca8a23698e6e",
     "scripts/env_fingerprint.py": "651db85ad3cdf28bc46e97010986109df60785eb6646507ee38b0fa75dce57d5",
     "scripts/kaggle_slots.py": "e3baafe52347e74158c5b82fe6a2849f72a201d8ce60c0bbbf0871e47c75ae79",
+    "scripts/publish_results.py": "bc371280cc9f2fc45b2fee7d63422fb7e51b1f5bb0e14015f58de0f3ecec48ee",
     "scripts/tiny_sharding_probe.py": "29eb58f2689242b919616f6aab6ff753e0de031b16371137975b4d645e836fae",
     "scripts/audit_public_corpus.py": "84f1ec805a74004e71f63a70a8ed19967cb3fad9966f254798e655ab95e53ab0",
-    "scripts/build_kit.py": "1f8c3519fe8ffe29963b80f81d066de554b30f2294f993dee737b62e6bbb2541",
+    "scripts/build_kit.py": "4cc1112537655634691650f56a8015da7a18bfc9b4e6895b55baa9e96be3bd4b",
     "scripts/bootstrap_kaggle.py": "1633e3edbb80976c337444e3e4544e2b5210b2d8d1821e3a2717c1099c00843e",
     "data/calibration_en_wikitext2_dedup.txt": "18a79f4f938cc25747a90a12b120c7131e7f4ac55b58dfc691795ea61d4b5e9a",
     "data/calibration_ja_wikipedia_dedup.txt": "b45e3f3f00f2137be280a75c1fa9c9883a7e69d289257c4388fc701f33fee0d1",

scripts/build_kit.py

@@ -61,6 +61,7 @@ KIT_SCRIPTS = [
     "preflight.py",
     "env_fingerprint.py",
     "kaggle_slots.py",
+    "publish_results.py",
     # sharding / audit
     "tiny_sharding_probe.py",
     "audit_public_corpus.py",

scripts/publish_results.py

@@ -0,0 +1,154 @@
+#!/usr/bin/env python3
+"""Publish lane results to the shared HF results dataset.
+
+Results used to go to ``kentasatomuse/uzu-results``, which the owner account
+cannot read, so every handoff needed a manual export. They now go to one private
+dataset: ``yamahei21/uzu-results``.
+
+The upload carries provenance because a result without it cannot be compared:
+
+    <namespace>/environment.json     lalamo commit + RHT code hashes
+    <namespace>/<lane>/manifest.json run_lane manifest (already has the fingerprint)
+
+Uploads are refused when a manifest reports ``problems`` (a broken lane must not
+look like data) or when no manifest exists at all.
+
+Usage:
+    python scripts/publish_results.py --out out --as muse
+    python scripts/publish_results.py --out out --as muse --dry-run
+    python scripts/publish_results.py --out out --as muse --allow-problems
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any
+
+DEFAULT_REPO = "yamahei21/uzu-results"
+
+
+def load_manifests(root: Path) -> list[tuple[Path, dict[str, Any]]]:
+    found = []
+    for path in sorted(root.rglob("manifest.json")):
+        try:
+            payload = json.loads(path.read_text(encoding="utf-8"))
+        except (OSError, ValueError) as error:
+            print(f"skip unreadable {path}: {error}", file=sys.stderr)
+            continue
+        if isinstance(payload, dict):
+            found.append((path, payload))
+    return found
+
+
+def collect_issues(root: Path) -> tuple[list[str], list[str]]:
+    """Return (errors, warnings).
+
+    Errors block the upload: a lane that reported problems is not data, and an
+    empty tree usually means the run wrote somewhere else.
+    """
+    errors: list[str] = []
+    warnings: list[str] = []
+    manifests = load_manifests(root)
+    if not manifests:
+        errors.append(f"no manifest.json under {root}")
+        return errors, warnings
+
+    for path, manifest in manifests:
+        lane = manifest.get("lane") or path.parent.name
+        problems = manifest.get("problems") or []
+        if problems:
+            errors.append(f"{lane}: {len(problems)} problem(s), first: {problems[0]}")
+        fingerprint = manifest.get("environment_fingerprint") or {}
+        if not fingerprint:
+            warnings.append(f"{lane}: no environment_fingerprint (older kit?)")
+        elif fingerprint.get("lalamo_hash_complete") == "false":
+            warnings.append(f"{lane}: lalamo fingerprints incomplete; do not compare with owner")
+    return errors, warnings
+
+
+def result_files(root: Path) -> list[str]:
+    """Relative paths that are worth uploading (skip caches and temp output)."""
+    skipped = {".git", "__pycache__", ".ipynb_checkpoints"}
+    files = []
+    for path in sorted(root.rglob("*")):
+        if not path.is_file():
+            continue
+        relative = path.relative_to(root)
+        if any(part in skipped for part in relative.parts):
+            continue
+        files.append(str(relative))
+    return files
+
+
+def write_environment(root: Path) -> Path:
+    """Record which code produced these numbers, next to the numbers."""
+    sys.path.insert(0, str(Path(__file__).resolve().parent))
+    try:
+        from env_fingerprint import fingerprint
+    except Exception as error:  # noqa: BLE001 - provenance is best effort
+        print(f"warning: cannot compute fingerprint: {error}", file=sys.stderr)
+        return root
+    path = root / "environment.json"
+    path.write_text(json.dumps(fingerprint(), indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    return path
+
+
+def upload(repo: str, root: Path, namespace: str) -> None:
+    command = [
+        "hf",
+        "upload",
+        repo,
+        str(root),
+        namespace,
+        "--repo-type",
+        "dataset",
+        "--commit-message",
+        f"results: {namespace}",
+    ]
+    print("$ " + " ".join(command), flush=True)
+    result = subprocess.run(command, check=False)
+    if result.returncode != 0:
+        raise SystemExit(f"hf upload failed ({result.returncode})")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--out", type=Path, required=True, help="lane output directory")
+    parser.add_argument("--repo", default=DEFAULT_REPO)
+    parser.add_argument("--as", dest="namespace", required=True, help="subdirectory, e.g. muse or owner")
+    parser.add_argument("--dry-run", action="store_true")
+    parser.add_argument("--allow-problems", action="store_true")
+    args = parser.parse_args()
+
+    if not args.out.exists():
+        raise SystemExit(f"nothing at {args.out}")
+
+    errors, warnings = collect_issues(args.out)
+    for warning in warnings:
+        print(f"warning: {warning}")
+    if errors and not args.allow_problems:
+        print("REFUSING TO PUBLISH")
+        for error in errors:
+            print(f"  - {error}")
+        raise SystemExit(1)
+    for error in errors:
+        print(f"overridden: {error}")
+
+    files = result_files(args.out)
+    print(f"{len(files)} file(s) under {args.out}")
+    if args.dry_run:
+        print(f"dry-run: would upload to {args.repo}/{args.namespace}")
+        return
+
+    environment = write_environment(args.out)
+    print(f"wrote {environment}")
+    upload(args.repo, args.out, args.namespace)
+    print(f"PUBLISHED {args.repo}/{args.namespace}")
+
+
+if __name__ == "__main__":
+    main()

scripts/pull_results.py

@@ -1,14 +1,14 @@
 #!/usr/bin/env python3
 """Pull a results repository and summarise what landed.
 
-The Kaggle operator uploads ``<lane>/manifest.json`` + per-condition JSON to
-``<user>/uzu-results``. This downloads it and prints what is complete, what is
+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 kentasatomuse/uzu-results --out results/kentasatomuse
-    python scripts/pull_results.py --out results/kentasatomuse --skip-download
+    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
 """
 
@@ -82,7 +82,7 @@ def download(repo: str, out: Path, revision: str | None) -> None:
 
 def main() -> None:
     parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
-    parser.add_argument("--repo", default=None, help="HF dataset repo, e.g. <user>/uzu-results")
+    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")