| """Build the FINAL Phase 3 results page. Every number comes from results/phase3/final_numbers.json (written by final_report.py from the raw |
| per-item records), plus the per-item records themselves (progress table) and Phase 2's p2_metrics.json (reference accuracies of |
| Stock / CoDA-1.7B / Qwen3-0.6B in Figure 2). Prose is rendered from results/phase3/REPORT.md and code/phase3/README.md, so the page and the |
| report cannot disagree. |
| |
| Usage (repo root): |
| /venv/p2/bin/python -I logs/phase3/extrap/final_report.py |
| /venv/p2/bin/python -I logs/phase3/extrap/build_final.py results/phase3/final_numbers.json results/phase3/REPORT.md logs/phase3/extrap/phase3_redraft.html |
| """ |
| import glob, html, json, os, re, sys, datetime as dt |
|
|
| NUM, REPORT, OUT = sys.argv[1:4] |
| N = json.load(open(NUM)); B = N["benchmarks"]; S = N["samples"] |
| P2 = json.load(open("logs/phase3/extrap/p2_metrics.json")) |
| RT = open(REPORT).read() |
| IST = dt.timezone(dt.timedelta(hours=5, minutes=30)) |
| e = html.escape |
| ORDER = ["humaneval", "mbpp", "gsm8k500", "ifeval541", "math500", "gpqa", "aime"] |
| NAMES = {"humaneval": "HumanEval", "mbpp": "MBPP", "gsm8k500": "GSM8K-500", "ifeval541": "IFEval-541", "math500": "MATH-500", |
| "gpqa": "GPQA-Diamond", "aime": "AIME"} |
| XSENT = ("EXTRAPOLATED — based on the extrapolation using the measured numbers on 4× GPUs for this dataset for this model, using reference " |
| "from the runs from this model (the base pipeline measured on the Phase 1 8× box).") |
| XT = "<b class=xt>extrapolated</b>"; XTA = "<b class=xt>extrapolated, drift-adjusted</b>"; MT = "<b class=mt>measured on the Phase 1 box</b>" |
|
|
|
|
| def n_exp(s): return P2[s]["S0_nopool"]["n"] |
| def f1(x): return f"{x:.1f}" |
| def f2(x): return f"{x:.2f}" |
| def f3(x): return f"{x:.3f}" |
| def sg(v, d=1): return ("−" if v < 0 else "+") + f"{abs(v):.{d}f}" |
| def dash(): return "·" |
| def wall(m): return f"{m:.1f} min" if m else dash() |
|
|
|
|
| |
| def inline(t): |
| codes = [] |
| def stash(m): codes.append(m.group(1)); return f"\x00{len(codes) - 1}\x00" |
| t = re.sub(r"`([^`]+)`", stash, t) |
| t = html.escape(t, quote=False) |
| t = re.sub(r"\*\*(.+?)\*\*", r"<b>\1</b>", t) |
| return re.sub(r"\x00(\d+)\x00", lambda m: "<code>" + html.escape(codes[int(m.group(1))], quote=False) + "</code>", t) |
|
|
|
|
| def md_blocks(lines): |
| out, para, i = [], [], 0 |
| def flush(): |
| if para: out.append(("p", " ".join(para))); para.clear() |
| while i < len(lines): |
| l = lines[i] |
| if l.startswith("```"): |
| flush(); j = i + 1; code = [] |
| while j < len(lines) and not lines[j].startswith("```"): code.append(lines[j]); j += 1 |
| out.append(("code", "\n".join(code))); i = j + 1; continue |
| if l.startswith("|") or l.startswith("#"): flush(); i += 1; continue |
| m = re.match(r"^(-|\d+\.)\s+(.*)$", l) |
| if m: |
| flush(); kind = "ol" if m.group(1)[0].isdigit() else "ul"; items = [m.group(2)]; i += 1 |
| while i < len(lines): |
| m2 = re.match(r"^(-|\d+\.)\s+(.*)$", lines[i]) |
| if m2: items.append(m2.group(2)); i += 1 |
| elif lines[i].startswith(" ") and lines[i].strip(): items[-1] += " " + lines[i].strip(); i += 1 |
| else: break |
| out.append((kind, items)); continue |
| if not l.strip(): flush(); i += 1; continue |
| para.append(l.strip()); i += 1 |
| flush(); return out |
|
|
|
|
| def md_html(blocks): |
| h = [] |
| for kind, v in blocks: |
| if kind == "p": h.append(f"<p>{inline(v)}</p>") |
| elif kind in ("ul", "ol"): h.append(f"<{kind}>" + "".join(f"<li>{inline(x)}</li>" for x in v) + f"</{kind}>") |
| elif kind == "code": h.append(f"<pre class=code><code>{html.escape(v)}</code></pre>") |
| return "".join(h) |
|
|
|
|
| def sections(text): |
| secs, cur = {}, None |
| for l in text.splitlines(): |
| m = re.match(r"^## (\d+)\. ", l) |
| if m: cur = int(m.group(1)); secs[cur] = [] |
| elif cur is not None: secs[cur].append(l) |
| return secs |
|
|
|
|
| RS = sections(RT) |
|
|
|
|
| def pick(sec, *prefixes): |
| """paragraphs of a REPORT section whose text starts with one of the prefixes (in the order given)""" |
| bl = md_blocks(RS.get(sec, [])); out = [] |
| for pf in prefixes: |
| hit = [b for b in bl if b[0] == "p" and b[1].startswith(pf)] |
| if hit: out.append(hit[0]) |
| else: print(f"WARNING: REPORT.md section {sec}: no paragraph starting with {pf!r}", file=sys.stderr) |
| return md_html(out) |
|
|
|
|
| |
| def recinfo(pat): |
| n, last = 0, None |
| for f in glob.glob(pat): |
| if f.endswith("running.jsonl"): continue |
| for l in open(f): |
| if not l.strip(): continue |
| try: r = json.loads(l) |
| except ValueError: continue |
| n += 1; u = r.get("utc") |
| if u and (last is None or u > last): last = u |
| return n, last |
| def ist(u): return dt.datetime.strptime(u, "%Y-%m-%dT%H:%M:%SZ").replace(tzinfo=dt.timezone.utc).astimezone(IST).strftime("%d %b %H:%M") if u else dash() |
| NOW = dt.datetime.now(dt.timezone.utc) |
| def alive(u): return bool(u) and (NOW - dt.datetime.strptime(u, "%Y-%m-%dT%H:%M:%SZ").replace(tzinfo=dt.timezone.utc)).total_seconds() < 20 * 60 |
| def chip(kind, txt): return f"<span class='chip {kind}'><i></i>{e(txt)}</span>" |
|
|
|
|
| def state_of(done_marker, n, total, last): |
| if os.path.exists(done_marker) and n >= total: return chip("done", "done") |
| if n == 0: return chip("stopped", "not run: stopped by the lead") |
| return chip("running", "running") if alive(last) else chip("stopped", f"stopped at {n}/{total}") |
|
|
|
|
| prog = [] |
| for s in ORDER: |
| total = n_exp(s); full = s in B |
| for a in ("rd1", "rd2", "base"): |
| if a == "base": |
| pat, mk = (f"logs/phase3/decode/judge/{s}/*.jsonl", f"logs/phase3/decode/judge/{s}/.complete") if full else (f"logs/phase3/decode/judge_sample/{s}/*.jsonl", None) |
| else: |
| pat, mk = f"logs/phase3/decode/{a}/{s}/*.jsonl", f"logs/phase3/decode/{a}/{s}/.complete" |
| n, last = recinfo(pat) |
| if a == "base" and not full: |
| st = chip("done", "done (first items only)") if n else chip("stopped", "not run"); tot = f"{n}/{total}" |
| else: |
| st = state_of(mk, n, total, last); tot = f"{n}/{total}" |
| if full: w = (B[s]["wall_base_min"] if a == "base" else B[s]["arms"][a]["wall_here_min"]) |
| else: w = None |
| label = "base pipeline" if a == "base" else a |
| prog.append(f"<tr><td class=l>{label}</td><td class=l>{NAMES[s]}</td><td>{tot}</td><td>{wall(w)}</td><td>{ist(last) if n else dash()}</td><td class=l>{st}</td></tr>") |
| PROGRESS = "".join(prog) |
|
|
| |
| complete, partial = [], [] |
| for s, b in B.items(): |
| n = n_exp(s) |
| if b["full_base_run"] and b["base_here"]["n"] == n and all(x["all_items"]["n"] == n for x in b["arms"].values()): complete.append(b["name"]) |
| else: |
| bits = [f"{a} {x['all_items']['n']}/{n}" for a, x in b["arms"].items() if x["all_items"]["n"] != n] |
| if not (b["full_base_run"] and b["base_here"]["n"] == n): bits.append(f"base pipeline {b['base_here']['n']}/{n}") |
| partial.append(f"{b['name']} ({', '.join(bits)})") |
| notrun = [v["name"] for v in S.values()] |
| is_final = not partial |
| banner = (f"<p class=banner><b>{'FINAL.' if is_final else 'NOT FINAL YET.'}</b> The project lead stopped the run after GSM8K-500. " |
| f"Finished on every item with all three setups (base pipeline, rd1, rd2): <b>{', '.join(complete) or 'none'}</b>. " |
| + (f"Still incomplete: {e('; '.join(partial))}. " if partial else "") |
| + f"Not run: rd1 and rd2 on <b>{', '.join(notrun)}</b> (the base pipeline was decoded on their first items only, Table 2).</p>") |
| gen = re.search(r"^Generated (.*?) by ", RT, re.M) |
| GENERATED = f"numbers computed {gen.group(1)}." if gen else "" |
| STATUSLINE = (f"<span>Updated <b>{NOW.astimezone(IST).strftime('%d %b %H:%M')} IST</b></span>" |
| f"<span><b>{'Final' if is_final else 'Not final'}</b>: stopped by the project lead after GSM8K-500</span>" |
| f"<span><b>{len(complete)}</b> of {len(ORDER)} benchmarks fully measured</span>") |
|
|
| sm = [] |
| for s, b in B.items(): |
| base = b["base_here"]; bits = [] |
| for a, x in b["arms"].items(): |
| m = x["all_items"] |
| bits.append(f"{a} {f3(x['speedup_raw'])}× (passes per block {f2(m['passes_blk'])}, expert loads per token {m['loads_tok']:.0f}, accuracy change vs base {sg(x['delta_acc_vs_base'][0])} pts)") |
| sm.append(f"<li><b>{b['name']}</b>: raw speedup over the base pipeline " + "; ".join(bits) + |
| f"; the base pipeline has passes per block {f2(base['passes_blk'])} and expert loads per token {base['loads_tok']:.0f}.</li>") |
| SUMMARY = ("<p class=caption><b>At a glance</b> (measured, raw, all from Table 1; the host-speed drift of section 3 is not removed from the speedups):</p>" |
| "<ul class=prose>" + "".join(sm) + "</ul>") |
|
|
| |
| mrows = [] |
| for s in ORDER: |
| if s not in B: continue |
| b = B[s]; base = b["base_here"]; n = n_exp(s); grp = [] |
| part = "" if (b["full_base_run"] and base["n"] == n) else f" <span class=pt>running {base['n']}/{n}</span>" |
| grp.append(f"<td class=l>base pipeline</td><td>{base['n']}{part}</td><td>{f1(base['acc'])}</td><td class=na>reference</td><td>{f2(base['passes_blk'])}</td><td>{base['loads_tok']:.0f}</td>" |
| f"<td>{f2(base['drafter_fwd_tok'])}</td><td>{f2(base['tok_s'])}</td><td>{f1(base['ms_tok'])}</td><td>{wall(b['wall_base_min'])}</td><td>1.00 <span class=ci>(reference)</span></td>") |
| for a, x in b["arms"].items(): |
| m = x["all_items"]; d = x["delta_acc_vs_base"] |
| pb = "" if x["paired_items"] == n else " <span class=pt>partial base</span>" |
| grp.append(f"<td class=l>{a}</td><td>{m['n']}</td><td>{f1(m['acc'])}</td><td>{sg(d[0])} <span class=ci>[{sg(d[1])}, {sg(d[2])}]</span></td><td>{f2(m['passes_blk'])}</td><td>{m['loads_tok']:.0f}</td>" |
| f"<td>{f2(m['drafter_fwd_tok'])}</td><td>{f2(m['tok_s'])}</td><td>{f1(m['ms_tok'])}</td><td>{wall(x['wall_here_min'])}</td>" |
| f"<td><b>{f3(x['speedup_raw'])}×</b> <span class=ci>({x['paired_items']} paired items){pb}</span></td>") |
| for i, g in enumerate(grp): |
| lead = f"<td class='l bench' rowspan=3>{b['name']}</td>" if i == 0 else "" |
| mrows.append(f"<tr class='{'first sep' if i == 0 else ''}{' last' if i == 2 else ''}'>{lead}{g}</tr>") |
| MTABLE = "".join(mrows) |
|
|
| |
| brows = [] |
| for s in ORDER: |
| if s in B: |
| b = B[s]; n = n_exp(s); i, t = b["base_identical_to_phase1"] |
| brows.append(f"<tr><td class=l>{b['name']}</td><td>{b['base_here']['n']}{'' if b['base_here']['n'] == n else f' of {n}'}</td><td>{i}/{t}</td><td>{f2(b['base_here']['tok_s'])}</td><td>{f3(b['box_ratio_base'])}</td></tr>") |
| else: |
| v = S[s] |
| brows.append(f"<tr><td class=l>{v['name']} <span class=pt>first items only</span></td><td>{v['items']}</td><td>{v['identical_to_phase1']}/{v['items']}</td><td>{f2(v['base_tps_here'])}</td><td>{f3(v['box_ratio'])}</td></tr>") |
| BASETABLE = "".join(brows) |
|
|
| |
| hrows, arows = [], [] |
| for s in ORDER: |
| if s not in B: continue |
| for a, x in B[s]["arms"].items(): |
| hrows.append(f"<tr><td class=l>{B[s]['name']}</td><td class=l>{a}</td><td>{f3(x['host_index_30b_prefill'])}</td><td>{f3(x['host_index_drafter_prefill'])}</td>" |
| f"<td>{f3(x['host_index_first_half'])}</td><td>{f3(x['host_index_second_half'])}</td></tr>") |
| arows.append(f"<tr><td class=l>{B[s]['name']}</td><td class=l>{a}</td><td><b>{f3(x['speedup_raw'])}×</b></td><td>{f3(x['host_index_30b_prefill'])}</td>" |
| f"<td class=ax>{f3(x['speedup_drift_adjusted'])}×<b class=adj>adjusted, NOT a measurement</b></td></tr>") |
| HTABLE, ADJTABLE = "".join(hrows), "".join(arows) |
|
|
| |
| xrows = [] |
| for s in ORDER: |
| if s not in B: continue |
| b = B[s] |
| for k, (a, x) in enumerate(b["arms"].items()): |
| lead = f"<td class='l bench' rowspan=2>{b['name']}</td>" if k == 0 else "" |
| xrows.append(f"<tr class='{'first sep' if k == 0 else 'last'}'>{lead}<td class=l>{a}</td>" |
| f"<td class='xc basecell'>{f1(b['base_phase1_box']['tok_s'])} <span class=ci>(stock {f1(b['stock_tps_phase1_box'])})</span>{MT}</td>" |
| f"<td class=xc><b>{f1(x['extrap_tps_raw'])}</b>{XT}</td><td class=xc>{f2(x['extrap_x_stock_raw'])}×{XT}</td>" |
| f"<td class=xc>{f1(x['extrap_tps_adjusted'])} <span class=ci>({f2(x['extrap_x_stock_adjusted'])}× stock)</span>{XTA}</td>" |
| f"<td class=xc>{f1(x['extrap_wall_8gpu_min'])} min{XT}</td></tr>") |
| XTABLE = "".join(xrows) |
| XNOTRUN = (f"<p class=caption>Not run, so nothing to extrapolate: rd1 and rd2 on {', '.join(notrun)}.</p>") |
|
|
| |
| FIG = [] |
| for s in ORDER: |
| nm = NAMES[s]; n = n_exp(s) |
| if s not in B: |
| FIG.append({"name": nm, "n": n, "pts": [], "live": False, "msg": "rd1 and rd2 not run (stopped after GSM8K-500)"}); continue |
| b = B[s]; base = b["base_here"]; pts = [] |
| pts.append({"label": "Stock 30B (Phase 2 records)", "tiny": "Stock", "shape": "diamond", "color": "--s-stock", "acc": P2[s]["stock"]["acc"], "err": None, |
| "note": "Phase 2 records, not measured here"}) |
| pts.append({"label": "Base pipeline (this box)", "tiny": "Base", "shape": "circle", "color": "--s-sdar", "sp": 1.0, "acc": base["acc"], "err": None, |
| "tps": base["tok_s"], "note": f"measured here, {base['n']} items; reference = 1x"}) |
| pts.append({"label": "CoDA-1.7B + judge (Phase 2 records)", "tiny": "CoDA", "shape": "square", "color": "--s-coda", "acc": P2[s]["F2_nopool"]["acc"], "err": None, |
| "note": "Phase 2 records, not measured here"}) |
| pts.append({"label": "Qwen3-0.6B + judge (Phase 2 records)", "tiny": "Qwen3", "shape": "triangle", "color": "--s-qwen", "acc": P2[s]["S1_nopool"]["acc"], "err": None, |
| "note": "Phase 2 records, not measured here"}) |
| for a, shape, col in (("rd1", "pent", "--s-rd1"), ("rd2", "star", "--s-rd2")): |
| x = b["arms"][a]; m = x["all_items"]; d = x["delta_acc_vs_base"] |
| pts.append({"label": a + (" (re-draft every pass)" if a == "rd1" else " (re-draft every 2 passes)"), "tiny": a, "shape": shape, "color": col, |
| "sp": x["speedup_raw"], "acc": m["acc"], "err": [m["acc"] + (d[1] - d[0]), m["acc"] + (d[2] - d[0])], "tps": m["tok_s"], |
| "note": f"raw, measured here on {x['paired_items']} paired items vs the base pipeline (host drift not removed); accuracy delta vs base {d[0]:+.1f} pts [{d[1]:+.1f}, {d[2]:+.1f}]"}) |
| FIG.append({"name": nm, "n": n, "pts": pts, "live": True}) |
|
|
| |
| SEC1 = md_html(md_blocks(RS[1])).replace("(section 6)", "(Table 2)") |
| _gf = re.search(r"`gpu_frac` ([0-9.]+)", RT) |
| if _gf: |
| SEC1 += (f"<p><b>Shared host.</b> The box is a shared, rented server: <code>gpu_frac</code> is {_gf.group(1)} (we rent part of the machine's GPUs; another tenant uses the rest). " |
| "Section 3 shows what that does to the measured speed.</p>") |
| rd = open("code/phase3/README.md").read().splitlines() |
| i0 = next(i for i, l in enumerate(rd) if l.startswith("## Method")); i1 = next(i for i in range(i0 + 1, len(rd)) if rd[i].startswith("## ")) |
| METHOD = md_html(md_blocks(rd[i0 + 1:i1])) |
| DRIFT1 = pick(3, "**Evidence the host is shared:**", "This is a shared, rented server", "**How it is measured:**") |
| DRIFT2 = pick(3, "**Reading:**") |
| DRIFT3 = pick(4, "**How to avoid this next time:**") |
| xs = pick(4, "Formula:") |
| XFORMULA = xs |
| SEC5 = md_html(md_blocks(RS[5])) |
| TIMING = ("<p><b>Timing in detail.</b> Per-item <code>seconds</code> is set in <code>decode_item</code> (<code>code/draftalign/da_decode.py</code>): " |
| "<code>torch.cuda.synchronize()</code>, then <code>time.perf_counter()</code>, then the whole decode, then <code>torch.cuda.synchronize()</code> and " |
| "<code>time.perf_counter()</code> again. The timed span contains prompt prefill, every judge, drafter, re-draft and KV-flush forward, and sampling; " |
| "it excludes tokenisation (<code>encode_prompt</code>), scoring, trace saving and writing the record (<code>code/draftalign/run_da_decode.py</code>). " |
| "The per-forward component times (<code>ms_by_kind</code>, <code>drafter_ms_by_kind</code>, <code>SeqCache._timed</code> in <code>code/draftalign/seqcache.py</code>) also synchronize " |
| "before and after each forward, identically in every setup. There are no busy-polling loops, CUDA-event polling or sleeps in the timed path. " |
| "Wall in Tables 0 and 1 is the run's start-to-done time from <code>logs/phase3/run.log</code>, model load included.</p>") |
| SEC7 = md_html(md_blocks(RS[7])) |
| SEC8 = md_html(md_blocks(RS[8])) |
| REBUILD = ("<p>Rebuild this page from the report numbers:</p><pre class=code><code>python logs/phase3/extrap/final_report.py\n" |
| "python logs/phase3/extrap/build_final.py results/phase3/final_numbers.json results/phase3/REPORT.md logs/phase3/extrap/phase3_redraft.html</code></pre>") |
|
|
| FM = [ |
| ("logs/phase3/run.log", "logs/phase3/run.log", "start / done / skip / pause lines of the whole run (UTC, time of day only)."), |
| ("logs/phase3/decode/rd1/<benchmark>/, decode/rd2/<benchmark>/", "logs/phase3/decode/rd1", "rd1 and rd2: one JSON record per item (<code>*.jsonl</code>, one file per shard), <code>.jsonl.done</code> shard markers, <code>.complete</code> when every shard finished."), |
| ("logs/phase3/decode/judge/<benchmark>/", "logs/phase3/decode/judge", "base pipeline (SDAR-1.7B drafter + trained 128M judge), full-set runs."), |
| ("logs/phase3/decode/judge_sample/<benchmark>/", "logs/phase3/decode/judge_sample", "base pipeline on the first items only (the benchmarks the run was stopped before)."), |
| ("logs/phase3/jobs/<setup>/<benchmark>/", "logs/phase3/jobs", "stdout of every shard process (<code>shardK.attemptN.log</code>)."), |
| ("logs/phase3/setup/", "logs/phase3/setup", "setup checks: <code>checks.json</code>, <code>tests.log</code>, <code>check_stock/</code>, <code>check_judge/</code> (identity checks against the Phase 1 records)."), |
| ("logs/phase3/analysis/, analysis.log, analysis_snapshot.log", "logs/phase3/analysis", "output of <code>code/phase3/analyze_p3.py</code> (<code>TABLE.md</code>, <code>metrics.json</code>)."), |
| ("logs/phase3/extrap/", "logs/phase3/extrap", "<code>final_report.py</code> (the report and <code>final_numbers.json</code>), <code>build_final.py</code> and <code>final_template.html</code> (this page), <code>extrap.py</code>, <code>status.py</code>, <code>unified.py</code>, <code>build_artifact.py</code> (the live page while the run was going), <code>p2_metrics.json</code> (Phase 2 page metrics), and the shell scripts that ordered the run."), |
| ("logs/phase3/backup.log, snapshot.log, switch.log", "logs/phase3/backup.log", "backup uploads, the periodic snapshot loop, and the run-order switches."), |
| ("logs/phase3/STOP", "logs/phase3/STOP", "empty marker file: the stop signal, checked by <code>run_p3.sh</code> before it starts the next benchmark."), |
| ("logs/phase3/STOPPED_setup_tests.md", "logs/phase3/STOPPED_setup_tests.md", "note from the first stop, at setup, before any decoding (two CPU tests failed on a missing <code>drafter</code> field in their fake arguments); the run was resumed afterwards."), |
| ("results/phase3/", "results/phase3", "<code>REPORT.md</code> and <code>final_numbers.json</code> (this page's source), <code>TABLE.md</code>, <code>metrics.json</code>, <code>EXTRAPOLATION_PHASE1_BOX.md</code>, <code>RESUME.md</code>, <code>setup_checks.json</code>."), |
| ("code/phase3/", "code/phase3", "<code>run_p3.sh</code> (the driver), <code>setup_p3.sh</code>, <code>analyze_p3.py</code>, <code>backup_p3.py</code>, <code>README.md</code> (method), <code>extrap/</code> (copies of the page and report scripts)."), |
| ("code/draftalign/", "code/draftalign", "the decoder: <code>run_da_decode.py</code> (runner), <code>da_decode.py</code> (decode loop, timing, records), <code>seqcache.py</code> (per-forward timers), <code>drafter.py</code>."), |
| ("weights/c1b_128M/ (Hugging Face dataset)", None, "the trained 128M judge LoRA adapter used by every setup (weights hash 35805974)."), |
| ("ref/phase2/S0_128M_nopool_by_set/ (Hugging Face dataset)", None, "the Phase 1 box's base-pipeline per-item records, used as the reference for token identity and for the Phase 1 box tokens per second."), |
| ] |
| filemap = [] |
| for disp, chk, desc in FM: |
| if chk is not None and not os.path.exists(chk): print(f"WARNING: file map path missing: {chk}", file=sys.stderr); continue |
| filemap.append(f"<tr><td class=l><code>{disp}</code></td><td class=l style='white-space:normal'>{desc}</td></tr>") |
| FILEMAP = "".join(filemap) |
|
|
| |
| tpl = open("logs/phase3/extrap/page_template.html").read() |
| head = tpl[:tpl.index('<main class="wrap">')] |
| tail = tpl[tpl.index('<script type="application/json" id="fig-data">'):] |
| extra = """<style> |
| .prose { display: grid; gap: 10px; max-width: 112ch; font-size: 0.95rem; line-height: 1.55; color: var(--ink-2); } |
| .prose p, .prose ul, .prose ol { margin: 0; } .prose ul, .prose ol { padding-left: 1.3em; display: grid; gap: 6px; } .prose b { color: var(--ink); font-weight: 600; } |
| code { font-family: var(--font-mono); font-size: 0.86em; background: color-mix(in srgb, var(--ink) 6%, transparent); padding: 0 0.25em; border-radius: 3px; overflow-wrap: anywhere; } |
| pre.code { margin: 0; font-family: var(--font-mono); font-size: 0.8rem; line-height: 1.5; background: var(--card); border: 1px solid var(--hair); border-radius: 6px; padding: 12px 14px; overflow-x: auto; } |
| pre.code code { background: none; padding: 0; } |
| .banner { margin: 0; padding: 12px 16px; border-left: 4px solid var(--accent); background: var(--card); font-family: var(--font-sans); font-size: 0.95rem; line-height: 1.5; color: var(--ink-2); max-width: 112ch; } |
| .banner b { color: var(--ink); } |
| section.msec { border-left: 4px solid var(--pick); padding-left: 16px; } |
| section.xsec { border-left: 4px solid var(--warn); padding-left: 16px; } |
| .chip.stopped { color: var(--warn); box-shadow: inset 0 0 0 1px var(--warn); } |
| b.adj { display: block; font-family: var(--font-sans); font-size: 0.6rem; font-weight: 700; letter-spacing: 0.05em; text-transform: uppercase; line-height: 1.25; color: var(--warn); white-space: nowrap; } |
| b.adjtxt { color: var(--warn); } |
| .xsent { font-size: 1.05rem; } .xsent b { color: var(--warn); } |
| table.sm td.ax { background: color-mix(in srgb, var(--warn) 7%, transparent); } |
| table.sm td.na { color: var(--muted); font-style: italic; } |
| table.sm td.l code { white-space: normal; } |
| </style> |
| """ |
| body = open("logs/phase3/extrap/final_template.html").read() |
| rep = {"{{STATUSLINE}}": STATUSLINE, "{{BANNER}}": banner, "{{SEC1}}": SEC1, "{{METHOD}}": METHOD, "{{PROGRESS}}": PROGRESS, "{{SUMMARY}}": SUMMARY, |
| "{{MTABLE}}": MTABLE, "{{BASETABLE}}": BASETABLE, "{{DRIFT1}}": DRIFT1, "{{HTABLE}}": HTABLE, "{{DRIFT2}}": DRIFT2, "{{ADJTABLE}}": ADJTABLE, |
| "{{DRIFT3}}": DRIFT3, "{{XSENT}}": e(XSENT), "{{XFORMULA}}": XFORMULA, "{{XTABLE}}": XTABLE, "{{XNOTRUN}}": XNOTRUN, "{{SEC5}}": SEC5, |
| "{{TIMING}}": TIMING, "{{SEC7}}": SEC7, "{{SEC8}}": SEC8, "{{REBUILD}}": REBUILD, "{{FILEMAP}}": FILEMAP, "{{GENERATED}}": e(GENERATED)} |
| for k, v in rep.items(): |
| assert k in body, k |
| body = body.replace(k, v) |
| tail = tail.replace("{{FIGDATA}}", json.dumps(FIG).replace("</", "<\\/")) |
| page = head + extra + body + tail |
| assert "{{" not in page.replace("{{FIGDATA}}", ""), re.findall(r"\{\{\w+\}\}", page) |
| open(OUT, "w").write(page) |
| print("wrote", OUT, "| final:", is_final, "| complete:", complete, "| partial:", partial) |
|
|
