scripts/build.py

#!/usr/bin/env python3
"""Rebuild the localLLMrig open dataset from the public site API and the showdown file.

Usage:
  python3 scripts/build.py            # use the JSON snapshots in snapshot/
  python3 scripts/build.py --fetch    # refresh snapshot/ from https://localllmrig.com first

Only the Python standard library is used. Every speed number written by this
script is a formula ESTIMATE (estimated=true), except the showdown CPU numbers,
which are measurements of one run on a CPU-only cloud VM.
"""
import csv, json, statistics, sys, urllib.request
from datetime import date
from pathlib import Path

ROOT = Path(__file__).resolve().parent.parent
SNAP = ROOT / "snapshot"
DATA = ROOT / "data"
BASE = "https://localllmrig.com"
SNAP_DATE = "2026-10-17"

# Mirrors lib/formula.ts on localllmrig.com (priceAsOf 2026-10-14). Assumptions, not measurements.
FORMULA = {
    "quantBytesPerParam": {"Q4": 0.60, "Q5": 0.71, "Q8": 1.07, "FP16": 2.0},
    "overheadGb": 0.8,
    "gpuContextReserveGb": 0.6,
    "systemRamReserveGb": 8,
    "utilization": {"nvidia": 0.78, "amd": 0.4, "apple": 0.48, "mixed": 0.5},
    "multiGpuBandwidthFactor": 0.55,
    "cpuBandwidthUtilization": 0.45,
    "perTokenOverheadSec": 0.0002,
}
# Not exposed by /api/hardware; copied from data/hardware.ts on the site (gpus[].count, cpuBandwidthGbps).
GPU_COUNT = {"build-dual-3090": 2, "build-dual-4090": 2}
CPU_BW = {"build-3060": 51, "build-3090": 51, "build-dual-3090": 51,
          "build-4060ti": 90, "build-7900xtx": 90, "build-4090": 90, "build-5090": 90, "build-dual-4090": 90}
QUANT_NAME = {"Q4": "Q4_K_M", "Q5": "Q5 (~0.71 bytes/param)", "Q8": "Q8", "FP16": "FP16"}


def fetch(path, out):
    req = urllib.request.Request(BASE + path, headers={"User-Agent": "localllmrig-data-build"})
    out.write_bytes(urllib.request.urlopen(req, timeout=60).read())


def mac_reserve(gb):
    return 6 if gb <= 16 else 7 if gb <= 24 else 8 if gb <= 36 else 10 if gb <= 64 else 12


def gpu_count(h):
    if h["memoryKind"] == "unified":
        return 0
    return GPU_COUNT.get(h["id"], 1)


def usable_gb(h):
    if h["memoryKind"] == "unified":
        return max(0.0, h["memoryGb"] - mac_reserve(h["memoryGb"]))
    return max(0.0, h["memoryGb"] - FORMULA["gpuContextReserveGb"] * max(1, gpu_count(h)))


def offload_gb(h):
    if h["memoryKind"] == "unified" or h["systemRamGb"] <= 0:
        return usable_gb(h)
    return usable_gb(h) + max(0, h["systemRamGb"] - FORMULA["systemRamReserveGb"])


def fit_kind(h, total):
    if h.get("addressableMemoryKnown") is False:
        return "unscored"
    if total <= usable_gb(h):
        return "full"
    if h["memoryKind"] == "vram" and total <= offload_gb(h):
        return "offload"
    return "no"


def tok_s(h, weights, kv, fit):
    if h.get("bandwidthGbps") in (None, 0):
        return None
    multi = FORMULA["multiGpuBandwidthFactor"] if gpu_count(h) > 1 and h["memoryKind"] == "vram" else 1
    bw = max(h["bandwidthGbps"] * FORMULA["utilization"][h["vendor"]] * multi, 0.1)
    streamed = weights + kv
    if fit == "full":
        return 1 / (streamed / bw + FORMULA["perTokenOverheadSec"])
    usable = max(usable_gb(h), 0)
    gpu_s = min(streamed, usable)
    cpu_s = max(0, streamed - gpu_s)
    cpu_bw = max(CPU_BW.get(h["id"], 0) * FORMULA["cpuBandwidthUtilization"], 1)
    return 1 / (gpu_s / bw + cpu_s / cpu_bw + FORMULA["perTokenOverheadSec"])


def precise_kv(m, ctx, api_kv):
    """Full-attention KV cache in FP16. Used only when it rounds to the API value;
    otherwise (sliding-window or hybrid models) the API's rounded kvGb is kept."""
    kv = 2 * m["kvHeads"] * m["headDim"] * 2 * m["layers"] * ctx / 1e9
    return kv if round(kv, 2) == api_kv else api_kv


def write_csv(path, rows, fields):
    with open(path, "w", newline="", encoding="utf-8") as f:
        w = csv.DictWriter(f, fieldnames=fields, extrasaction="ignore")
        w.writeheader()
        for r in rows:
            w.writerow({k: ("" if r.get(k) is None else r.get(k)) for k in fields})


def main():
    models_file = SNAP / f"api-models-{SNAP_DATE}.json"
    hw_file = SNAP / f"api-hardware-{SNAP_DATE}.json"
    if "--fetch" in sys.argv:
        fetch("/api/models", models_file)
        fetch("/api/hardware", hw_file)
    mj = json.loads(models_file.read_text())
    hj = json.loads(hw_file.read_text())
    sd = json.loads((SNAP / "showdown-2026-10-17.json").read_text())
    DATA.mkdir(exist_ok=True)
    (DATA / "showdown").mkdir(exist_ok=True)
    ctx = mj["contextTokens"]

    # models
    mrows = []
    for m in mj["models"]:
        r = {k: m.get(k) for k in ["id", "name", "family", "paramsB", "activeParamsB", "paramsEstimated",
                                   "layers", "kvHeads", "headDim", "maxContext", "architectureSourceUrl"]}
        for q, v in m["memory"]["quants"].items():
            r[f"mem_{q}_total_gb_est"] = v["totalGb"]
        r["context_tokens"] = ctx
        r["page_url"] = f"{BASE}/models/{m['id']}?utm_source=github&utm_medium=dataset&utm_campaign=open_data"
        mrows.append(r)
    write_csv(DATA / "models.csv", mrows, list(mrows[0].keys()))

    # hardware + prices
    hrows = []
    for h in hj["hardware"]:
        p = h["price"]
        hrows.append({
            "id": h["id"], "name": h["name"], "kind": h["kind"], "vendor": h["vendor"],
            "memory_kind": h["memoryKind"], "memory_gb": h["memoryGb"],
            "addressable_memory_known": h.get("addressableMemoryKnown"),
            "usable_gb_assumed": round(usable_gb(h), 2) if h.get("addressableMemoryKnown") is not False else None,
            "gpu_count": gpu_count(h), "bandwidth_gbps": h.get("bandwidthGbps"),
            "bandwidth_source_url": h.get("bandwidthSourceUrl"), "system_ram_gb": h["systemRamGb"],
            "used_market": h["usedMarket"],
            "price_eur_incl_vat": p.get("amountEur"), "price_usd_fx_estimate": p.get("amountUsd"),
            "price_label": p.get("amountLabel"), "price_verified": p.get("verified"),
            "price_as_of": p.get("asOf"), "price_source_name": p.get("sourceName"),
            "price_source_url": p.get("sourceUrl"), "price_note": p.get("note"),
            "page_url": f"{BASE}/hardware/{h['id']}?utm_source=github&utm_medium=dataset&utm_campaign=open_data",
        })
    write_csv(DATA / "hardware.csv", hrows, list(hrows[0].keys()))

    # price per GB of memory, cards only, priced, verified source
    pv = []
    for h, r in zip(hj["hardware"], hrows):
        if h["kind"] != "card" or r["price_eur_incl_vat"] is None:
            continue
        pv.append({**r, "eur_per_gb_vram": round(r["price_eur_incl_vat"] / h["memoryGb"], 2)})
    pv.sort(key=lambda r: r["eur_per_gb_vram"])
    write_csv(DATA / "gpu-price-per-gb-vram.csv", pv,
              ["id", "name", "memory_gb", "price_eur_incl_vat", "eur_per_gb_vram", "price_label",
               "price_verified", "price_as_of", "price_source_name", "price_source_url"])

    # fit + estimated decode speed matrix
    erows = []
    for m in mj["models"]:
        for q, v in m["memory"]["quants"].items():
            weights = m["paramsB"] * FORMULA["quantBytesPerParam"][q]
            kv = precise_kv(m, ctx, v["kvGb"])
            total = weights + kv + FORMULA["overheadGb"]
            for h in hj["hardware"]:
                fit = fit_kind(h, total)
                est = tok_s(h, weights, kv, fit) if fit in ("full", "offload") else None
                erows.append({
                    "model_id": m["id"], "hardware_id": h["id"], "quant": q, "quant_name": QUANT_NAME[q],
                    "context_tokens": ctx, "need_gb_est": round(total, 2),
                    "usable_gb_assumed": round(usable_gb(h), 2) if fit != "unscored" else None,
                    "fit": fit, "est_decode_tok_s": round(est, 1) if est else None,
                    "estimated": True, "method": "localllmrig formula 2026-10-14 (bandwidth-bound decode)",
                })
    write_csv(DATA / "fit-estimates.csv", erows, list(erows[0].keys()))

    # community measurements (third party, labelled)
    crow = []
    for m in mj["models"]:
        cm = m.get("communityMeasurement")
        if not cm:
            continue
        for row in cm["rows"]:
            crow.append({"model_id": m["id"], "hardware": row["hardware"], "tok_s": row["tokensPerSec"],
                         "label": cm["label"], "source_name": cm["sourceName"], "source_url": cm["sourceUrl"],
                         "published": cm["published"], "note": cm["note"]})
    if crow:
        write_csv(DATA / "community-measurements.csv", crow, list(crow[0].keys()))

    # showdown
    srow, orow = [], []
    for m in sd["models"]:
        s = m["speed"]
        srow.append({"model_id": m["id"], "name": m["name"], "maker": m["maker"], "params_b": m["params_b"],
                     "license": m["license"], "license_url": m["license_url"], "gguf_file": m["gguf_file"],
                     "gguf_url": m["gguf_url"], "gguf_sha256": m["gguf_sha256"],
                     "gen_tok_s_median": s["gen_tok_per_s_median"], "gen_tok_s_min": s["gen_tok_per_s_min"],
                     "gen_tok_s_max": s["gen_tok_per_s_max"], "prompt_tok_s_median": s["prompt_tok_per_s_median"],
                     "truncated_outputs": sum(1 for o in m["outputs"] if o.get("truncated_at_cap")),
                     "speed_label": s["label"]})
        for o in m["outputs"]:
            orow.append({"model_id": m["id"], "prompt_id": o["prompt_id"], "finish_reason": o["finish_reason"],
                         "truncated_at_cap": o["truncated_at_cap"], "generated_tokens": o["generated_tokens"],
                         "prompt_tokens": o["prompt_tokens"], "gen_tok_s": o["gen_tok_per_s"],
                         "check": o.get("check"), "output": o["output"]})
    write_csv(DATA / "showdown" / "speeds-2026-10-17.csv", srow, list(srow[0].keys()))
    write_csv(DATA / "showdown" / "outputs-2026-10-17.csv", orow, list(orow[0].keys()))
    write_csv(DATA / "showdown" / "prompts-2026-10-17.csv", sd["prompts"], ["id", "category", "prompt", "reference_answer"])
    (DATA / "showdown" / "showdown-2026-10-17.json").write_text(json.dumps(sd, ensure_ascii=False, indent=1))

    bundle = {
        "name": "localLLMrig open data", "license": "CC-BY-4.0",
        "attribution": "Data: localLLMrig (https://localllmrig.com), CC BY 4.0",
        "snapshot_date": SNAP_DATE, "built": date.today().isoformat(),
        "estimatesAreNotMeasurements": True, "formula": FORMULA, "context_tokens": ctx,
        "models": mrows, "hardware": hrows, "gpu_price_per_gb_vram": pv,
        "fit_estimates": erows, "community_measurements": crow, "showdown_speeds": srow,
    }
    (DATA / "localllmrig-data.json").write_text(json.dumps(bundle, ensure_ascii=False, indent=1))
    print(f"models={len(mrows)} hardware={len(hrows)} price_rows={len(pv)} fit_rows={len(erows)} "
          f"community={len(crow)} showdown_models={len(srow)} outputs={len(orow)}")


if __name__ == "__main__":
    main()