Update app

app.py

@@ -63,6 +63,8 @@ def load_repo(safe: str) -> dict:
         d = json.load(f)
     d["ctx"] = np.load(DATA / f"{safe}.ctx.npy")
     d["tt_commits"] = [k for k, c in enumerate(d["commits"]) if c.get("time_travel")]
+    d["live_only"] = INDEX_BY_SAFE[safe].get("c2l_em") is None
+    d["jump_targets"] = d["tt_commits"] or [k for k, g in enumerate(d["qnas"]) if g]
     return d
 
 
@@ -187,6 +189,12 @@ def repo_header(safe: str) -> str:
     r = INDEX_BY_SAFE[safe]
     stars = f"★ {r['stars']:,} · " if r.get("stars") else ""
     desc = f"<div class='desc'>{esc(r.get('description'))}</div>" if r.get("description") else ""
+    if r.get("c2l_em") is None:
+        em = ("<div class='repo-em'>Live mode: cached GPU scores for this repository are still being computed. "
+              "Press <b>Adapt</b> and both models answer live on this Space.</div>")
+    else:
+        em = (f"<div class='repo-em'>Exact match across this repo's history: base model <b>{pct(r['base_em'])}</b>"
+              f" → Code2LoRA <b class='accent'>{pct(r['c2l_em'])}</b></div>")
     return f"""
 <div class="repo-card">
   <div class="repo-title"><a href="https://github.com/{esc(r['repo_id'])}" target="_blank">{esc(r['repo_id'])}</a>
@@ -194,8 +202,7 @@ def repo_header(safe: str) -> str:
   {desc}
   <div class="repo-stats">{stars}{r['n_commits']} commits · {short_date(r['first_date'])} → {short_date(r['last_date'])}
     · {r['n_qnas']:,} test assertions</div>
-  <div class="repo-em">Exact match across this repo's history:
-    base model <b>{pct(r['base_em'])}</b> → Code2LoRA <b class="accent">{pct(r['c2l_em'])}</b></div>
+  {em}
 </div>"""
 
 
@@ -236,18 +243,22 @@ def timeline_plot(safe: str, k: int) -> Figure:
 
     fig = Figure(figsize=(9, 2.4), dpi=110)
     ax = fig.add_subplot(111)
-    ax.plot(x, rolling("base_em"), color="#9aa3b5", lw=1.6, label="Base model")
-    ax.plot(x, rolling("c2l_em"), color="#4f5bd5", lw=2.2, label="Code2LoRA (adapter at each commit)")
-    for t in d["tt_commits"]:
-        ax.axvline(t + 1, color="#22c3a6", alpha=0.18, lw=1)
+    if d["live_only"]:
+        ax.bar(x, [len(g) for g in d["qnas"]], color="#c5cbf5", width=0.9, label="Test assertions added")
+        ax.set_ylabel("Assertions\nadded")
+    else:
+        ax.plot(x, rolling("base_em"), color="#9aa3b5", lw=1.6, label="Base model")
+        ax.plot(x, rolling("c2l_em"), color="#4f5bd5", lw=2.2, label="Code2LoRA (adapter at each commit)")
+        for t in d["tt_commits"]:
+            ax.axvline(t + 1, color="#22c3a6", alpha=0.18, lw=1)
+        ax.set_ylim(0, 100)
+        ax.set_ylabel("Exact match %\n(rolling)")
     ax.axvline(k + 1, color="#ff6b8b", lw=2)
-    ax.set_xlim(1, max(2, len(cs)))
-    ax.set_ylim(0, 100)
-    ax.set_ylabel("Exact match %\n(rolling)")
+    ax.set_xlim(0.5, max(2, len(cs)) + 0.5)
     ax.set_xlabel("Commit")
     for s in ("top", "right"):
         ax.spines[s].set_visible(False)
-    ax.legend(loc="lower right", fontsize=8, frameon=False)
+    ax.legend(loc="upper left" if d["live_only"] else "lower right", fontsize=8, frameon=False)
     fig.tight_layout()
     return fig
 
@@ -278,8 +289,13 @@ def assertion_panel(safe: str, k: int, i: Optional[int], adapted_k: Optional[int
     if i is None or i >= len(qs):
         return "", "<div class='hint'>Pick an assertion above.</div>"
     q = qs[i]
-    rows = [f"""<tr class="truth"><td class="who">Ground truth</td><td><code>{esc(q['target'])}</code></td><td></td>
-<td class="note">what the developer actually wrote</td></tr>""",
+    truth = f"""<tr class="truth"><td class="who">Ground truth</td><td><code>{esc(q['target'])}</code></td><td></td>
+<td class="note">what the developer actually wrote</td></tr>"""
+    if q.get("base_pred") is None:
+        hint = ("Both models are answering live below…" if adapted_k == k else
+                "Press <b>Adapt at this commit</b>: the adapter is generated and both models answer live.")
+        return context_tail(q["prompt"]), f"<table class='preds'>{truth}</table><div class='hint'>{hint}</div>"
+    rows = [truth,
             pred_row("Base model", "base", q["base_pred"], q["base_em"], "Qwen2.5-Coder-1.5B, no adapter")]
     if adapted_k == k:
         if q.get("prev_pred") is not None:
@@ -302,7 +318,7 @@ def assertion_panel(safe: str, k: int, i: Optional[int], adapted_k: Optional[int
 
 def default_commit(safe: str) -> int:
     d = load_repo(safe)
-    return d["tt_commits"][0] if d["tt_commits"] else len(d["commits"]) - 1
+    return d["jump_targets"][0] if d["jump_targets"] else len(d["commits"]) - 1
 
 
 def on_repo(safe: str):
@@ -311,7 +327,8 @@ def on_repo(safe: str):
     choices = assertion_choices(safe, k)
     first = choices[0][1] if choices else None
     ctx, preds = assertion_panel(safe, k, first, None)
-    return (repo_header(safe),
+    jump = "Jump to next commit with tests" if d["live_only"] else "Jump to next ✨ commit"
+    return (gr.Button(value=jump), repo_header(safe),
             gr.Slider(minimum=1, maximum=len(d["commits"]), value=k + 1, step=1),
             commit_card(safe, k, None), timeline_plot(safe, k),
             d["commits"][k].get("diff_preview") or "",
@@ -336,7 +353,7 @@ def step(safe: str, k1: int, delta: int) -> int:
 
 
 def next_star(safe: str, k1: int) -> int:
-    tt = load_repo(safe)["tt_commits"]
+    tt = load_repo(safe)["jump_targets"]
     k = int(k1) - 1
     later = [t for t in tt if t > k]
     return (later[0] if later else (tt[0] if tt else k)) + 1
@@ -400,6 +417,13 @@ def on_live(safe: str, k1: int, i: Optional[int], adapted: Optional[Tuple[str, i
                       q["target"]) + note
 
 
+def on_auto_live(safe: str, k1: int, i: Optional[int], adapted: Optional[Tuple[str, int]],
+                 progress=gr.Progress()):
+    if not load_repo(safe)["live_only"] or adapted != (safe, int(k1) - 1) or i is None:
+        return gr.update()
+    return on_live(safe, k1, i, adapted, progress)
+
+
 def on_prefill(safe: str, k1: int, i: Optional[int]) -> str:
     qs = load_repo(safe)["qnas"][int(k1) - 1]
     if i is None or i >= len(qs):
@@ -496,7 +520,7 @@ adapter gets an assertion right that the adapter from one commit earlier got wro
 """
 
 choices = [(repo_label(r), r["safe"]) for r in INDEX]
-start = max(INDEX, key=lambda r: (r["c2l_em"] - r["base_em"]))["safe"]
+start = max(INDEX, key=lambda r: ((r["c2l_em"] or 0) - (r["base_em"] or 0), r.get("stars") or 0))["safe"]
 
 with gr.Blocks(css=CSS, title="Code2LoRA timeline demo", theme=gr.themes.Soft(primary_hue="indigo")) as demo:
     adapted_state = gr.State(None)
@@ -542,7 +566,7 @@ with gr.Blocks(css=CSS, title="Code2LoRA timeline demo", theme=gr.themes.Soft(pr
                                f"{LIVE_MAX_INPUT:,} context tokens and takes roughly 10–40 s.*"
                                if DEVICE == "cpu" else ""))
 
-    repo_outputs = [repo_html, commit_slider, commit_html, plot, diff_code, pick, ctx_code, preds_html,
+    repo_outputs = [star_btn, repo_html, commit_slider, commit_html, plot, diff_code, pick, ctx_code, preds_html,
                     adapted_state, adapt_html, live_html]
     commit_outputs = [commit_html, plot, diff_code, pick, ctx_code, preds_html, live_html]
 
@@ -555,9 +579,12 @@ with gr.Blocks(css=CSS, title="Code2LoRA timeline demo", theme=gr.themes.Soft(pr
         on_commit, [repo_dd, commit_slider, adapted_state], commit_outputs)
     star_btn.click(next_star, [repo_dd, commit_slider], commit_slider).then(
         on_commit, [repo_dd, commit_slider, adapted_state], commit_outputs)
+    live_inputs = [repo_dd, commit_slider, pick, adapted_state]
     adapt_btn.click(on_adapt, [repo_dd, commit_slider, pick],
-                    [adapt_html, adapted_state, commit_html, ctx_code, preds_html], concurrency_limit=1)
-    pick.change(on_pick, [repo_dd, commit_slider, pick, adapted_state], [ctx_code, preds_html, live_html])
+                    [adapt_html, adapted_state, commit_html, ctx_code, preds_html], concurrency_limit=1).then(
+        on_auto_live, live_inputs, live_html, concurrency_limit=1)
+    pick.change(on_pick, live_inputs, [ctx_code, preds_html, live_html]).then(
+        on_auto_live, live_inputs, live_html, concurrency_limit=1)
     live_btn.click(on_live, [repo_dd, commit_slider, pick, adapted_state], live_html, concurrency_limit=1)
     prefill_btn.click(on_prefill, [repo_dd, commit_slider, pick], custom_in)
     custom_btn.click(on_custom, [repo_dd, commit_slider, custom_in, max_new, adapted_state], custom_out,

tools/build_prototype_data.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python3
+"""Build a live-only Space data directory on CPU, without the GPU cache.
+
+GRU contexts and prompts are real; predictions are left empty, so the app
+answers every assertion live. Replaced by build_space_data.py output once the
+precompute job is done.
+
+    python hf_space_demo/tools/build_prototype_data.py --out-dir DATA --repos pypa/pipx msiemens/tinydb
+"""
+
+from __future__ import annotations
+
+import argparse
+import gzip
+import json
+import sys
+from collections import defaultdict
+from pathlib import Path
+
+import numpy as np
+import pyarrow.parquet as pq
+import torch
+from huggingface_hub import hf_hub_download
+from transformers import AutoTokenizer
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE.parent))
+sys.path.insert(0, str(HERE))
+
+from build_space_data import github_meta  # noqa: E402
+from c2l.core import CommitGRU  # noqa: E402
+
+COMMITS = "/scratch/lhotsko/REPO_DATASET/commit_parquet_hf_v2/commits/cr_test.parquet"
+QNAS = "/scratch/lhotsko/REPO_DATASET/code2lora_snapshots_hf/qna/cr_test.parquet"
+
+
+def load_gru() -> CommitGRU:
+    state = torch.load(hf_hub_download("code2lora/code2lora-gru", "code2lora_gru.pt"),
+                       map_location="cpu", weights_only=False, mmap=True)
+    gc = state.get("gru_config") or {}
+    gru = CommitGRU(int(gc.get("diff_input_dim", 2048)), int(gc.get("repo_state_dim", 2048)),
+                    int(gc.get("hidden_dim", 2048)))
+    gru.load_state_dict(state["gru_state"])
+    return gru.eval()
+
+
+@torch.no_grad()
+def build_repo(repo: str, out: Path, gru: CommitGRU, tok, max_input: int = 4096) -> dict:
+    safe = repo.replace("/", "__")
+    ct = pq.read_table(COMMITS, filters=[("repo_id", "=", repo)]).to_pylist()
+    ct.sort(key=lambda r: r["commit_index"])
+    by_sha = defaultdict(list)
+    for q in pq.read_table(QNAS, columns=["repo_id", "commit_sha", "test_file", "lineno", "test_function",
+                                          "prefix", "target"], filters=[("repo_id", "=", repo)]).to_pylist():
+        by_sha[q["commit_sha"]].append(q)
+
+    h = gru.init_hidden(torch.tensor(ct[0]["repo_state_embedding"]).unsqueeze(0))
+    ctx = []
+    for r in ct:
+        h = gru.step(torch.tensor(r["diff_embedding"]).unsqueeze(0), h)
+        ctx.append(gru.context(h).float())
+    np.save(out / f"{safe}.ctx.npy", torch.cat(ctx).numpy().astype(np.float32))
+
+    bos = tok.bos_token_id if tok.bos_token_id is not None else tok.eos_token_id
+    commits, qnas = [], []
+    for k, r in enumerate(ct):
+        group = []
+        for q in by_sha[r["commit_sha"]][:8]:
+            ids = ([bos] + tok.encode(q["prefix"], add_special_tokens=False))[-max_input:]
+            had_bos = ids[0] == bos
+            group.append({"k": k, "test_file": q["test_file"], "lineno": int(q["lineno"] or 0),
+                          "test_function": q["test_function"] or "",
+                          "prompt": tok.decode(ids[1:] if had_bos else ids), "had_bos": had_bos,
+                          "n_prompt_tokens": len(ids), "target": q["target"],
+                          "base_pred": None, "base_em": None, "c2l_pred": None, "c2l_em": None})
+        qnas.append(group)
+        commits.append({"sha": r["commit_sha"], "commit_index": r["commit_index"],
+                        "timestamp": r["commit_timestamp"], "n_new_assertions": r["n_new_assertions"],
+                        "diff_preview": (r["production_code_diff"] or "")[:6000],
+                        "n_qnas": len(group), "base_em": None, "c2l_em": None, "time_travel": False})
+    with gzip.open(out / f"{safe}.json.gz", "wt", encoding="utf-8") as f:
+        json.dump({"repo_id": repo, "commits": commits, "qnas": qnas,
+                   "max_input_tokens": max_input, "max_new_tokens": 64}, f)
+    print(f"[{repo}] {len(commits)} commits, {sum(map(len, qnas))} qnas", flush=True)
+    return {"repo_id": repo, "safe": safe, "n_commits": len(commits), "n_qnas": sum(map(len, qnas)),
+            "base_em": None, "c2l_em": None, "n_time_travel": 0,
+            "first_date": commits[0]["timestamp"], "last_date": commits[-1]["timestamp"],
+            **github_meta(repo)}
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--out-dir", required=True)
+    ap.add_argument("--repos", nargs="+", required=True)
+    args = ap.parse_args()
+    out = Path(args.out_dir)
+    out.mkdir(parents=True, exist_ok=True)
+    gru = load_gru()
+    tok = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-Coder-1.5B")
+    index = [build_repo(r, out, gru, tok) for r in args.repos]
+    (out / "index.json").write_text(json.dumps(index, indent=1))
+    print(f"wrote {len(index)} repos to {out}")
+
+
+if __name__ == "__main__":
+    main()

tools/precompute.py

@@ -104,6 +104,8 @@ def main() -> None:
     ap.add_argument("--batch-size", type=int, default=8)
     ap.add_argument("--qnas-per-commit-limit", type=int, default=8)
     ap.add_argument("--repos", nargs="*", default=None)
+    ap.add_argument("--min-commits", type=int, default=10)
+    ap.add_argument("--max-commits", type=int, default=400)
     args = ap.parse_args()
 
     out_dir = Path(args.out_dir)
@@ -111,7 +113,8 @@ def main() -> None:
     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 
     rows_by_repo = load_commit_rows_for_gru(Path(COMMITS))
-    repos = sorted(rows_by_repo)
+    repos = sorted(r for r, rows in rows_by_repo.items()
+                   if args.min_commits <= len(rows) <= args.max_commits)
     if args.repos:
         repos = [r for r in repos if r in set(args.repos)]
     repos = [r for i, r in enumerate(repos) if i % args.num_shards == args.shard_i]

tools/precompute.sbatch

@@ -1,10 +1,10 @@
 #!/bin/bash
-# Precompute the Code2LoRA timeline Space cache (cr_test, all 51 repos).
-#   sbatch --array=0-7 hf_space_demo/tools/precompute.sbatch
+# Precompute the Code2LoRA timeline Space cache (cr_test repos with 10-400 commits).
+#   sbatch hf_space_demo/tools/precompute.sbatch
 #SBATCH --job-name=c2l_space_cache
-#SBATCH --output=slurm_logs/c2l_space_cache_%A_%a.out
-#SBATCH --error=slurm_logs/c2l_space_cache_%A_%a.err
-#SBATCH --time=03:00:00
+#SBATCH --output=slurm_logs/c2l_space_cache_%j.out
+#SBATCH --error=slurm_logs/c2l_space_cache_%j.err
+#SBATCH --time=12:00:00
 #SBATCH --gres=gpu:h100:1
 #SBATCH --cpus-per-task=8
 #SBATCH --mem=80G
@@ -24,4 +24,4 @@ export HF_HUB_OFFLINE=1
 
 python hf_space_demo/tools/precompute.py \
   --out-dir /home/lhotsko/projects/def-yuntian/lhotsko/c2l_space/cache \
-  --shard-i "${SLURM_ARRAY_TASK_ID:-0}" --num-shards 8
+  --shard-i 0 --num-shards 1

tools/publish.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python3
+"""Push the app and a built data directory to the Space, replacing old data.
+
+    python hf_space_demo/tools/publish.py --data-dir hf_space_demo/data [--public]
+"""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from huggingface_hub import HfApi
+
+HERE = Path(__file__).resolve().parents[1]
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--data-dir", required=True)
+    ap.add_argument("--space", default="code2lora/code2lora-gru-demo")
+    ap.add_argument("--public", action="store_true")
+    args = ap.parse_args()
+
+    data = Path(args.data_dir)
+    if not (data / "index.json").exists():
+        raise SystemExit(f"{data}/index.json not found; run build_space_data.py first")
+
+    api = HfApi()
+    api.upload_folder(repo_id=args.space, repo_type="space", folder_path=str(HERE),
+                      ignore_patterns=["data/*", "**/__pycache__/*", "*.pyc"],
+                      commit_message="Update app")
+    api.upload_folder(repo_id=args.space, repo_type="space", folder_path=str(data),
+                      path_in_repo="data", delete_patterns=["*"],
+                      commit_message="Precomputed GRU states and cached predictions")
+    if args.public:
+        api.update_repo_settings(args.space, repo_type="space", private=False)
+    print(f"https://huggingface.co/spaces/{args.space}", api.get_space_runtime(args.space).stage)
+
+
+if __name__ == "__main__":
+    main()