Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261006T133650Z-fig1-nature-style-candidate/diffusion/dataset/server_1/manuscript/scripts/build_figure1_architecture_nature.py

@@ -0,0 +1,435 @@
+#!/usr/bin/env python3
+"""Nature-style Figure 1 overview (a-c), 2026-10-06; plan in editorial/fig1_nature_redesign_plan_20261006.md.
+
+Writes the editable master figures/fig01_architecture_nature.svg and renders .pdf/.png with cairosvg.
+Schematic only: tiles, clouds and mini-plots are drawn from a fixed seed and show no data. The corpus numbers in
+panel a are read from source_data/corpus/corpus_summary.json. Canvas 180 mm wide, 8 SVG units per mm, Arial.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+
+import cairosvg
+import numpy as np
+
+ROOT = Path(__file__).resolve().parents[1]
+OUT = ROOT / "figures" / "fig01_architecture_nature.svg"
+U = 8.0                      # SVG units per mm
+PT = 25.4 / 72 * U           # SVG units per typographic point
+W, H = 1440, 760
+FONT = "Arial, Helvetica, sans-serif"
+INK, SUB, LINE = "#222222", "#5A5A5A", "#8C8C8C"
+GOLD, GOLD_L = "#B8862B", "#E9D3A6"          # bulk / condition
+BLUE, BLUE_L = "#3F6E9E", "#C9D8E8"          # expression value
+TEAL = "#2E8B7A"                              # detection
+SLATE, SLATE_L = "#5B6E8F", "#E6EAF1"        # model
+PURPLE = "#8E6C9E"                            # adaptation
+GREY, GREY_L = "#9A9A9A", "#E4E4E4"           # noise, unmeasured
+CT = {"T cell": "#4C6E91", "Monocyte": "#5E8C6A", "B cell": "#C98A4B", "NK cell": "#8FB0CF"}
+rng = np.random.default_rng(20261006)
+parts: list[str] = []
+
+
+def t(x, y, s, size=6.5, weight="normal", color=INK, anchor="start", style="normal", extra=""):
+    parts.append(f'<text x="{x:.1f}" y="{y:.1f}" font-family="{FONT}" font-size="{size * PT:.1f}" '
+                 f'font-weight="{weight}" font-style="{style}" fill="{color}" text-anchor="{anchor}" {extra}>{s}</text>')
+
+
+def rect(x, y, w, h, fill="none", stroke="none", sw=1.0, rx=0, dash=None, op=1.0):
+    d = f' stroke-dasharray="{dash}"' if dash else ""
+    parts.append(f'<rect x="{x:.1f}" y="{y:.1f}" width="{w:.1f}" height="{h:.1f}" rx="{rx}" fill="{fill}" '
+                 f'stroke="{stroke}" stroke-width="{sw}"{d} opacity="{op}"/>')
+
+
+def line(x1, y1, x2, y2, color=LINE, sw=1.4, arrow=None, dash=None):
+    m = f' marker-end="url(#{arrow})"' if arrow else ""
+    d = f' stroke-dasharray="{dash}"' if dash else ""
+    parts.append(f'<line x1="{x1:.1f}" y1="{y1:.1f}" x2="{x2:.1f}" y2="{y2:.1f}" stroke="{color}" '
+                 f'stroke-width="{sw}"{d}{m}/>')
+
+
+def path(d, color=LINE, sw=1.4, arrow=None, dash=None, fill="none"):
+    m = f' marker-end="url(#{arrow})"' if arrow else ""
+    ds = f' stroke-dasharray="{dash}"' if dash else ""
+    parts.append(f'<path d="{d}" fill="{fill}" stroke="{color}" stroke-width="{sw}"{ds}{m}/>')
+
+
+def circle(x, y, r, fill, stroke="none", sw=1.0):
+    parts.append(f'<circle cx="{x:.1f}" cy="{y:.1f}" r="{r:.1f}" fill="{fill}" stroke="{stroke}" stroke-width="{sw}"/>')
+
+
+from PIL import ImageFont  # noqa: E402
+
+ARIAL = "/usr/share/fonts/truetype/msttcorefonts/Arial.ttf"
+
+
+def text_w(s, size):
+    return ImageFont.truetype(ARIAL, max(1, round(size * PT * 4))).getlength(s) / 4
+
+
+def ts(x, y, base, idx, size=6.5, anchor="start", color=INK, weight="normal"):
+    """text with a subscript placed from measured Arial widths (cairosvg misplaces tspans)"""
+    wb, wi = text_w(base, size), text_w(idx, size * 0.72)
+    x0 = x - (wb + wi) / 2 if anchor == "middle" else (x - wb - wi if anchor == "end" else x)
+    t(x0, y, base, size=size, color=color, weight=weight)
+    t(x0 + wb + 0.5, y + size * PT * 0.22, idx, size=size * 0.72, color=color, weight=weight)
+
+
+def letter(x, y, s):
+    t(x, y, s, size=9, weight="bold")
+
+
+def header(x, y, s):
+    t(x, y, s, size=7.5, weight="bold")
+
+
+def shade(base, v):
+    """mix white -> base by v in [0, 1]"""
+    b = [int(base[i:i + 2], 16) for i in (1, 3, 5)]
+    c = [round(255 + (bb - 255) * v) for bb in b]
+    return "#" + "".join(f"{x:02X}" for x in c)
+
+
+def hatch_rect(x, y, w, h):
+    rect(x, y, w, h, fill="url(#hatch)", stroke=GREY, sw=0.6)
+
+
+def cell_profile(x, y, vals, det, unmeasured, gw=12, bh=34, noise=0.0, tag=None):
+    """one cell over genes: value bars (blue) above detection dots (teal); unmeasured genes hatched"""
+    n = len(vals)
+    rect(x - 4, y - 4, n * gw + 8, bh + 26, fill="white", stroke="#C8C8C8", sw=0.8, rx=4)
+    for g in range(n):
+        gx = x + g * gw
+        if g in unmeasured:
+            hatch_rect(gx + 1, y, gw - 2, bh + 18)
+            continue
+        v = vals[g]
+        col = BLUE if noise < 0.5 else GREY
+        if noise > 0:
+            col = shade(GREY, 0.9) if noise >= 0.99 else (BLUE if noise < 0.4 else "#7F94AB")
+        if v > 0:
+            rect(gx + 2, y + bh - v * bh, gw - 4, v * bh, fill=col)
+        dcol = TEAL if noise < 0.99 else GREY
+        circle(gx + gw / 2, y + bh + 9, 3.6, dcol if det[g] else "white", stroke=dcol, sw=1.0)
+    if tag:
+        t(x + n * gw / 2, y - 10, tag, size=6.5, anchor="middle", color=INK)
+
+
+def arrow_defs():
+    parts.append('<defs>')
+    for name, col in (("a-ink", INK), ("a-grey", LINE), ("a-gold", GOLD), ("a-slate", SLATE), ("a-purple", PURPLE),
+                      ("a-teal", TEAL)):
+        parts.append(f'<marker id="{name}" viewBox="0 0 10 10" refX="8.5" refY="5" markerWidth="6.5" markerHeight="6.5" '
+                     f'orient="auto-start-reverse"><path d="M0,0 L10,5 L0,10 z" fill="{col}"/></marker>')
+    parts.append('<pattern id="hatch" width="5" height="5" patternUnits="userSpaceOnUse" patternTransform="rotate(45)">'
+                 f'<rect width="5" height="5" fill="{GREY_L}"/><line x1="0" y1="0" x2="0" y2="5" stroke="#B5B5B5" '
+                 'stroke-width="1.6"/></pattern>')
+    parts.append('</defs>')
+
+
+def panel_a(summ):
+    letter(6, 24, "a")
+    header(32, 24, "Pretraining on pseudobulk")
+    # corpus cloud
+    cx, cy = 92, 150
+    cols = list(CT.values())
+    pts = rng.normal(size=(70, 2))
+    pts = pts / np.maximum(1, np.hypot(*pts.T) / 1.9)[:, None] * [26, 21]  # keep inside the cloud
+    for i, (dx, dy) in enumerate(pts):
+        circle(cx + dx, cy + dy, 4.0, cols[i % 4])
+    t(cx, 76, "Blood scRNA-seq", size=6.5, anchor="middle")
+    t(cx, 222, f"{summ['cells'] / 1e6:.1f} M cells", size=7, weight="bold", anchor="middle")
+    t(cx, 240, f"{summ['datasets']} datasets", size=6.2, anchor="middle", color=SUB)
+    t(cx, 257, f"{summ['donors']:,} donors", size=6.2, anchor="middle", color=SUB)
+    # one sample: K cells x genes
+    x0, y0, cw, ch, nr, nc = 238, 98, 14, 12.5, 8, 10
+    unmeas = {3, 7}
+    line(160, 150, x0 - 10, 150, arrow="a-grey")
+    t((160 + x0 - 10) / 2, 140, "one sample", size=6, anchor="middle", color=SUB)
+    t(x0 + nc * cw / 2, 86, "K cells × genes", size=6.5, anchor="middle")
+    vals = rng.gamma(0.7, 0.5, size=(nr, nc)) * (rng.random((nr, nc)) > 0.45)
+    for r in range(nr):
+        for c in range(nc):
+            if c in unmeas:
+                hatch_rect(x0 + c * cw, y0 + r * ch, cw - 1.5, ch - 1.5)
+            else:
+                v = min(vals[r, c], 1.2) / 1.2
+                rect(x0 + c * cw, y0 + r * ch, cw - 1.5, ch - 1.5, fill=shade(BLUE, 0.08 + 0.85 * v))
+    hr = 4
+    rect(x0 - 2.5, y0 + hr * ch - 2.5, nc * cw + 2, ch + 2, stroke=INK, sw=1.6)
+    # sum -> bulk row, mask row
+    by = y0 + nr * ch + 24
+    path(f"M{x0 + nc * cw + 4},{y0 + nr * ch - 6} C{x0 + nc * cw + 22},{y0 + nr * ch + 4} "
+         f"{x0 + nc * cw + 22},{by - 2} {x0 + nc * cw + 6},{by + 5}", color=GOLD, sw=1.3, arrow="a-gold")
+    t(x0 + nc * cw + 26, y0 + nr * ch + 16, "Σ", size=8, color=GOLD, weight="bold")
+    bulk = vals.sum(0)
+    for c in range(nc):
+        if c in unmeas:
+            hatch_rect(x0 + c * cw, by, cw - 1.5, ch - 1.5)
+        else:
+            rect(x0 + c * cw, by, cw - 1.5, ch - 1.5, fill=shade(GOLD, 0.15 + 0.85 * bulk[c] / bulk.max()))
+    t(x0 - 8, by + 9, "bulk", size=6.5, color=GOLD, weight="bold", anchor="end")
+    my = by + ch + 5
+    for c in range(nc):
+        rect(x0 + c * cw, my, cw - 1.5, 5, fill=GREY_L if c in unmeas else "#6E6E6E")
+    t(x0 - 8, my + 6, "measured", size=6, color=SUB, anchor="end")
+    t(x0 + nc * cw / 2, my + 26, "K = 250–4,000 cells", size=6, anchor="middle", color=SUB)
+    # training pair: highlighted cell + its bulk -> model
+    px = x0 + nc * cw + 58
+    rect(px, 104, 98, 120, fill="#FAFAFA", stroke="#C8C8C8", sw=0.8, rx=6)
+    t(px + 49, 96, "training pair", size=6.3, anchor="middle")
+    t(px + 8, 124, "one cell", size=6, color=SUB)
+    for c in range(nc):
+        col = GREY_L if c in unmeas else shade(BLUE, 0.08 + 0.85 * min(vals[hr, c], 1.2) / 1.2)
+        rect(px + 8 + c * 8.2, 132, 7, 12, fill=col)
+    t(px + 49, 166, "+", size=8, anchor="middle", color=SUB)
+    t(px + 8, 186, "its own bulk", size=6, color=SUB)
+    for c in range(nc):
+        col = GREY_L if c in unmeas else shade(GOLD, 0.15 + 0.85 * bulk[c] / bulk.max())
+        rect(px + 8 + c * 8.2, 194, 7, 12, fill=col)
+    line(x0 + nc * cw + 2, y0 + hr * ch + ch / 2, px - 4, 138, color=INK, sw=1.1, arrow="a-ink")
+    t(20, 300, "Each cell is learned with the bulk of its own sample.", size=6.2, color=SUB)
+    t(20, 318, "The model never sees cell-type or disease labels.", size=6.2, color=SUB)
+    line(px + 100, 164, 548, 164, color=INK, sw=1.5, arrow="a-ink")
+
+
+def panel_b():
+    bx = 562
+    letter(bx, 24, "b")
+    header(bx + 26, 24, "Diffusion on each gene’s value and detection")
+    n, gw = 10, 13
+    unmeas = {3, 7}
+    v0 = np.clip(rng.gamma(1.0, 0.35, n), 0, 1) * (rng.random(n) > 0.3)
+    d0 = v0 > 0
+    xs = [bx + 34, bx + 244, bx + 454]
+    gwid = n * gw
+    labs = [("clean cell x", "0"), ("noisy cell x", "t"), ("noise x", "T")]
+    for i, x in enumerate(xs):
+        frac = (0.0, 0.5, 1.0)[i]
+        if i == 0:
+            vals, det = v0, d0
+        else:
+            vals = np.clip((1 - frac) * v0 + frac * rng.random(n) * 0.9, 0.05, 1)
+            det = rng.random(n) > 0.5 if frac >= 0.99 else d0 | (rng.random(n) > 0.7)
+        cell_profile(x, 104, vals, det, unmeas, gw=gw, noise=frac)
+        ts(x + gwid / 2, 90, *labs[i], size=6.5, anchor="middle")
+    line(xs[0], 64, xs[2] + gwid, 64, color=GREY, sw=1.3, arrow="a-grey")
+    t((xs[0] + xs[2] + gwid) / 2, 56, "add noise (training)", size=6, anchor="middle", color=GREY)
+    line(xs[2] + gwid, 178, xs[0], 178, color=SLATE, sw=1.6, arrow="a-slate")
+    t((xs[0] + xs[2] + gwid) / 2, 194, "remove noise step by step (generation)", size=6, anchor="middle", color=SLATE)
+    # glyph legend
+    lx = bx + 646
+    rect(lx, 98, 10, 14, fill=BLUE)
+    t(lx + 16, 110, "expression value", size=6)
+    circle(lx + 5, 126, 3.6, TEAL, stroke=TEAL)
+    t(lx + 16, 130, "detected", size=6)
+    circle(lx + 5, 142, 3.6, "white", stroke=TEAL)
+    t(lx + 16, 146, "not detected (zero)", size=6)
+    hatch_rect(lx, 154, 10, 12)
+    t(lx + 16, 164, "gene not measured", size=6)
+    # inputs
+    iy, ix, iw, ih = 236, bx + 4, 148, 22
+    inputs = [(("noisy cell x", "t"), GREY, None), ("previous estimate", SLATE, "4,3"), ("time step t", GREY, None)]
+    dx0, dy0, dwid, dh = bx + 178, 226, 284, 92
+    for k, (lab, col, dash) in enumerate(inputs):
+        yy = iy + k * 28
+        rect(ix, yy, iw, ih, fill="white", stroke=col, sw=1.0, rx=5, dash=dash)
+        if isinstance(lab, tuple):
+            ts(ix + iw / 2, yy + 15, *lab, size=6, anchor="middle")
+        else:
+            t(ix + iw / 2, yy + 15, lab, size=6, anchor="middle")
+        line(ix + iw, yy + ih / 2, dx0 - 4, dy0 + 26 + k * 20, color=col, sw=1.1, arrow="a-grey")
+    # denoiser
+    rect(dx0, dy0, dwid, dh, fill=SLATE_L, stroke=SLATE, sw=1.2, rx=10)
+    t(dx0 + dwid / 2, dy0 - 8, "Denoiser", size=7, anchor="middle", weight="bold", color=SLATE)
+    nb, bw = 7, 20
+    gap = (dwid - 60 - nb * bw) / (nb - 1)
+    bxs = [dx0 + 30 + k * (bw + gap) for k in range(nb)]
+    for k, xx in enumerate(bxs):
+        rect(xx, dy0 + 30, bw, 50, fill=shade(SLATE, 0.55), rx=3)
+    for a, b in ((0, 6), (1, 5), (2, 4)):
+        xa, xb = bxs[a] + bw / 2, bxs[b] + bw / 2
+        lift = 8 + 5 * (3 - (b - a) // 2)
+        path(f"M{xa},{dy0 + 30} C{xa},{dy0 + 30 - lift - 8} {xb},{dy0 + 30 - lift - 8} {xb},{dy0 + 30}",
+             color=SLATE, sw=1.0)
+    # bulk condition into every block
+    cyb = dy0 + dh + 30
+    rect(ix, cyb - 13, iw, 26, fill="white", stroke=GOLD, sw=1.3, rx=5)
+    t(ix + iw / 2, cyb + 4, "bulk condition", size=6.3, anchor="middle", color=GOLD, weight="bold")
+    line(ix + iw, cyb, bxs[-1] + bw / 2, cyb, color=GOLD, sw=1.6)
+    for xx in bxs:
+        line(xx + bw / 2, cyb, xx + bw / 2, dy0 + dh - 8, color=GOLD, sw=1.0, arrow="a-gold")
+    t(ix, cyb + 30, "bulk expression, depth and measured genes: fixed per sample, enters every block",
+      size=5.9, color=SUB)
+    # two heads
+    hx = dx0 + dwid + 40
+    vals = np.clip(v0 + 0.15, 0, 1)
+    probs = np.clip(np.where(d0, 0.75, 0.2) + rng.normal(0, 0.1, n), 0.05, 0.95)
+    line(dx0 + dwid, dy0 + 40, hx - 6, dy0 + 22, color=SLATE, sw=1.3, arrow="a-slate")
+    line(dx0 + dwid, dy0 + 56, hx - 6, dy0 + 82, color=SLATE, sw=1.3, arrow="a-slate")
+    for g in range(n):
+        gx = hx + g * 11
+        if g in unmeas:
+            hatch_rect(gx + 1, dy0 + 2, 9, 40)
+            hatch_rect(gx + 1, dy0 + 64, 9, 40)
+            continue
+        rect(gx + 1, dy0 + 42 - vals[g] * 40, 9, vals[g] * 40, fill=BLUE)
+        rect(gx + 1, dy0 + 104 - probs[g] * 40, 9, probs[g] * 40, fill=TEAL)
+    t(hx + 55, dy0 - 8, "value", size=6.3, anchor="middle", color=BLUE)
+    t(hx + 55, dy0 + 122, "detection probability", size=6.3, anchor="middle", color=TEAL)
+    # read-out
+    ox = hx + 150
+    drawn = rng.random(n) < probs
+    out = np.where(drawn, vals, 0)
+    path(f"M{hx + 112},{dy0 + 84} C{ox - 14},{dy0 + 84} {ox - 14},{dy0 + 62} {ox - 2},{dy0 + 62}",
+         color=TEAL, sw=1.3, arrow="a-teal")
+    path(f"M{hx + 112},{dy0 + 22} C{ox - 14},{dy0 + 22} {ox - 14},{dy0 + 44} {ox - 2},{dy0 + 44}",
+         color=BLUE, sw=1.3, arrow="a-ink")
+    t(ox + 55, dy0 - 8, "generated cell", size=6.3, anchor="middle", weight="bold")
+    for g in range(n):
+        gx = ox + g * 11
+        if g in unmeas:
+            hatch_rect(gx + 1, dy0 + 32, 9, 40)
+            continue
+        if out[g] > 0:
+            rect(gx + 1, dy0 + 72 - out[g] * 40, 9, out[g] * 40, fill=BLUE)
+        else:
+            t(gx + 5.5, dy0 + 70, "0", size=5.2, anchor="middle", color=SUB)
+    t(ox, dy0 + 94, "detection drawn from", size=5.9, color=SUB)
+    t(ox, dy0 + 109, "its probability; exact", size=5.9, color=SUB)
+    t(ox, dy0 + 124, "zeros elsewhere", size=5.9, color=SUB)
+
+
+def panel_c(top):
+    letter(6, top + 24, "c")
+    header(32, top + 24, "From a measured bulk to single cells")
+    y = top + 44
+    # blood tube and bulk profile
+    tx, ty = 58, y + 52
+    rect(tx, ty, 22, 70, fill="white", stroke=INK, sw=1.2, rx=9)
+    rect(tx + 1.5, ty + 30, 19, 38, fill="#B5544F", rx=8)
+    rect(tx - 3, ty - 6, 28, 10, fill="#6E6E6E", rx=2)
+    t(tx + 11, ty + 92, "blood sample,", size=6, anchor="middle", color=SUB)
+    t(tx + 11, ty + 107, "bulk RNA-seq", size=6, anchor="middle", color=SUB)
+    bx0, by0, nc, cw = 112, y + 84, 10, 11
+    unmeas = {2, 8}
+    line(tx + 26, ty + 40, bx0 - 6, by0 + 6, color=GREY, sw=1.2, arrow="a-grey")
+    bulk = rng.gamma(1.2, 1.0, nc)
+    for c in range(nc):
+        if c in unmeas:
+            hatch_rect(bx0 + c * cw, by0, cw - 1.5, 12)
+        else:
+            rect(bx0 + c * cw, by0, cw - 1.5, 12, fill=shade(GOLD, 0.2 + 0.8 * bulk[c] / bulk.max()))
+        rect(bx0 + c * cw, by0 + 17, cw - 1.5, 5, fill=GREY_L if c in unmeas else "#6E6E6E")
+    t(bx0 + nc * cw / 2, by0 - 10, "bulk profile", size=6.3, anchor="middle", color=GOLD, weight="bold")
+    # optional adaptation
+    ax0, ay0, aw, ah = 262, y + 6, 196, 84
+    rect(ax0, ay0, aw, ah, fill="white", stroke=PURPLE, sw=1.2, rx=8, dash="5,4")
+    t(ax0 + aw / 2, ay0 + 19, "Optional: adapt", size=6.3, anchor="middle", color=PURPLE, weight="bold")
+    t(ax0 + aw / 2, ay0 + 37, "a few paired bulk +", size=6, anchor="middle")
+    t(ax0 + aw / 2, ay0 + 52, "single-cell samples", size=6, anchor="middle")
+    t(ax0 + aw / 2, ay0 + 70, "low-rank update, minutes", size=6, anchor="middle", color=SUB)
+    # model with K noise draws
+    mx0, my0, mw, mh = 470, y + 110, 160, 74
+    rect(mx0, my0, mw, mh, fill=SLATE_L, stroke=SLATE, sw=1.2, rx=10)
+    for k in range(5):
+        rect(mx0 + 28 + k * 22, my0 + 32, 14, 32, fill=shade(SLATE, 0.55), rx=2)
+    t(mx0 + mw / 2, my0 + 20, "pretrained model", size=6.5, anchor="middle", color=SLATE, weight="bold")
+    nx = mx0 + 16
+    for k in range(3):
+        for g in range(8):
+            v = rng.random()
+            rect(nx + k * 44 + g * 4.4, y + 44 + (1 - v) * 18, 3.4, v * 18, fill=GREY)
+    t(nx + 134, y + 58, "…", size=7, color=SUB)
+    t(mx0 + mw / 2, y + 30, "K noise draws", size=6.3, anchor="middle", color=SUB)
+    line(mx0 + mw / 2, y + 68, mx0 + mw / 2, my0 - 4, color=GREY, sw=1.2, arrow="a-grey")
+    path(f"M{ax0 + aw / 2},{ay0 + ah + 2} C{ax0 + aw / 2},{my0 + 20} {mx0 - 40},{my0 + 22} {mx0 - 4},{my0 + 22}",
+         color=PURPLE, sw=1.2, dash="5,4", arrow="a-purple")
+    line(bx0 + nc * cw + 4, by0 + 8, mx0 - 4, my0 + 54, color=GOLD, sw=1.6, arrow="a-gold")
+    t(300, my0 + 84, "one shared condition", size=6, anchor="middle", color=GOLD)
+    # generated cells
+    gx0, gy0 = 776, my0 + 34
+    line(mx0 + mw + 4, my0 + mh / 2, gx0 - 84, gy0, color=SLATE, sw=1.6, arrow="a-slate")
+    centers = {"T": ("T cell", -28, -22, 26), "Mono": ("Monocyte", 44, 14, 16), "B": ("B cell", -6, 40, 9),
+               "NK": ("NK cell", -58, 18, 9)}
+    for short, (lab, ox, oy, n) in centers.items():
+        pts = rng.normal(size=(n, 2)) * [12, 9]
+        for dx, dy in pts:
+            circle(gx0 + ox + dx, gy0 + oy + dy, 3.5, CT[lab])
+    for short, (lx, ly) in {"T": (-28, -48), "Mono": (44, -10), "B": (24, 58), "NK": (-80, 46)}.items():
+        t(gx0 + lx, gy0 + ly, short, size=6, anchor="middle", color=SUB)
+    t(gx0, y + 30, "K generated cells", size=6.5, anchor="middle", weight="bold")
+    t(gx0, y + 46, "labelled after generation", size=6, anchor="middle", color=SUB)
+    fy = my0 + mh + 64
+    path(f"M{gx0},{gy0 + 62} C{gx0},{fy} {gx0 - 80},{fy} {gx0 - 200},{fy} L{bx0 + 120},{fy} "
+         f"C{bx0 + 60},{fy} {bx0 + 60},{fy - 20} {bx0 + 60},{by0 + 30}", color=GREY, sw=1.0, dash="4,4",
+         arrow="a-grey")
+    t((gx0 + bx0) / 2, fy + 18, "summed cells are compared with the bulk, not forced to match; no cell-type quotas",
+      size=5.9, anchor="middle", color=SUB)
+    # uses
+    ux, bw_, bh_ = 920, 158, 150
+    line(gx0 + 96, gy0, ux - 8, gy0, color=INK, sw=1.4, arrow="a-ink")
+    for i, ttl in enumerate(["Composition", "Cell-type effects", "Rare subsets"]):
+        px0 = ux + i * (bw_ + 18)
+        rect(px0, y + 40, bw_, bh_, fill="#FAFAFA", stroke="#D0D0D0", sw=0.8, rx=6)
+        t(px0 + bw_ / 2, y + 30, ttl, size=6.5, anchor="middle")
+    order = ["T cell", "NK cell", "B cell", "Monocyte"]
+    for s in range(4):
+        sh = rng.dirichlet([6, 1.5, 1.5, 3])
+        bot = y + 160
+        for k, lab in enumerate(order):
+            hgt = sh[k] * 104
+            rect(ux + 22 + s * 32, bot - hgt, 22, hgt, fill=CT[lab])
+            bot -= hgt
+    t(ux + bw_ / 2, y + 178, "samples", size=5.8, anchor="middle", color=SUB)
+    sx0, sy0 = ux + bw_ + 18 + 26, y + 160
+    line(sx0, sy0, sx0 + 118, sy0, color=LINE, sw=0.9)
+    line(sx0, sy0, sx0, sy0 - 108, color=LINE, sw=0.9)
+    line(sx0 + 6, sy0 - 6, sx0 + 110, sy0 - 102, color="#B0B0B0", sw=0.9, dash="3,3")
+    xx = rng.normal(0, 1, 26)
+    yy = 0.8 * xx + rng.normal(0, 0.45, 26)
+    for a, b in zip(xx, yy):
+        circle(sx0 + 58 + a * 20, sy0 - 54 - b * 20, 2.7, CT["Monocyte"])
+    t(sx0 + 58, sy0 + 14, "observed", size=5.8, anchor="middle", color=SUB)
+    t(sx0 - 10, sy0 - 54, "generated", size=5.8, anchor="middle", color=SUB,
+      extra=f'transform="rotate(-90 {sx0 - 10} {sy0 - 54})"')
+    cx0, cy0 = ux + 2 * (bw_ + 18) + bw_ / 2, y + 108
+    for dx, dy in rng.normal(size=(40, 2)) * [26, 18]:
+        circle(cx0 + dx, cy0 + dy, 2.9, shade(CT["Monocyte"], 0.45))
+    for dx, dy in rng.normal(size=(9, 2)) * [7, 6] + [24, -18]:
+        circle(cx0 + dx, cy0 + dy, 2.9, "#B5544F")
+    parts.append(f'<ellipse cx="{cx0 + 24}" cy="{cy0 - 18}" rx="21" ry="16" fill="none" stroke="#B5544F" '
+                 'stroke-width="1.1" stroke-dasharray="3,2"/>')
+    t(cx0, y + 164, "e.g. C1Q-high", size=5.8, anchor="middle", color=SUB)
+    t(cx0, y + 178, "monocytes", size=5.8, anchor="middle", color=SUB)
+
+
+def main() -> int:
+    summ = json.loads((ROOT / "source_data/corpus/corpus_summary.json").read_text())
+    parts.append(f'<?xml version="1.0" encoding="UTF-8"?>\n<svg xmlns="http://www.w3.org/2000/svg" '
+                 f'width="{W / U:g}mm" height="{H / U:g}mm" viewBox="0 0 {W} {H}" role="img">')
+    parts.append("<title>PBISC-Diffusion overview: pretraining, gene-space diffusion, generation from bulk</title>")
+    arrow_defs()
+    rect(0, 0, W, H, fill="white")
+    panel_a(summ)
+    panel_b()
+    line(10, 418, W - 10, 418, color="#E2E2E2", sw=1.0)
+    panel_c(424)
+    parts.append("</svg>")
+    OUT.write_text("\n".join(parts) + "\n", encoding="utf-8")
+    pdf, png = OUT.with_suffix(".pdf"), OUT.with_suffix(".png")
+    cairosvg.svg2pdf(url=str(OUT), write_to=str(pdf))
+    cairosvg.svg2png(url=str(OUT), write_to=str(png), output_width=2126)
+    rec = {"source_svg": str(OUT.relative_to(ROOT)), "canvas_mm": [W / U, H / U],
+           "outputs": {p.suffix: hashlib.sha256(p.read_bytes()).hexdigest() for p in (OUT, pdf, png)},
+           "data": "schematic; corpus numbers from source_data/corpus/corpus_summary.json",
+           "plan": "editorial/fig1_nature_redesign_plan_20261006.md"}
+    OUT.with_suffix(".provenance.json").write_text(json.dumps(rec, indent=1) + "\n")
+    print(json.dumps(rec, indent=1))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

paper-releases/pbisc-diffusion/updates/20261006T133650Z-fig1-nature-style-candidate/diffusion/dataset/server_1/manuscript/scripts/corpus/build_figure1_corpus.py

@@ -0,0 +1,416 @@
+#!/usr/bin/env python3
+"""Pretraining-corpus figures (2026-10-06; style after Nicheformer Fig. 2).
+
+Reads only source_data/corpus/ (written by scripts/corpus/build_corpus_tables.py); every number is computed here
+from those tables.
+  figures/fig01_corpus.*  Fig. 1 strip (panel c after the architecture a-b): assay shares, disease-family shares per
+                          assay and L1 cell-type shares; authored at 180 mm like fig01_architecture
+  figures/figS_corpus.*   Supplementary, panels a-d: overview (split, sample handling, assay, 12 conditions), the 22
+                          datasets, L1/L2 cell types, and the per-cell record
+Each output has a .provenance.json with input and output hashes.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import string
+from pathlib import Path
+
+import matplotlib
+
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt  # noqa: E402
+import numpy as np  # noqa: E402
+import pandas as pd  # noqa: E402
+from matplotlib.patches import FancyBboxPatch, Rectangle  # noqa: E402
+
+MS = Path(__file__).resolve().parents[2]
+SRC = MS / "source_data" / "corpus"
+FIG = MS / "figures"
+MM = 1 / 25.4
+INK, SUB, LIGHT = "#222222", "#5A5A5A", "#D3D3CB"
+plt.rcParams.update({"font.family": "DejaVu Sans", "font.size": 6.5, "axes.linewidth": 0.6,
+                     "xtick.major.width": 0.6, "ytick.major.width": 0.6, "xtick.major.size": 2,
+                     "ytick.major.size": 2, "pdf.fonttype": 42, "ps.fonttype": 42, "svg.fonttype": "none"})
+
+COND_COLOR = {"Healthy": "#A9B8CC", "SLE": "#7A4F6E", "RA": "#B5655E", "ACPA+ at risk of RA": "#DDA59B",
+              "JDM": "#A58BB0", "COVID-19": "#D08C3C", "Post-COVID-19": "#E8C68E", "Influenza": "#9C6B2A",
+              "MDS": "#3F7A73", "MDS/MPN": "#6FA39B", "Cytopenia": "#A9D0C8", "DRESS": "#5F5F5F"}
+L1_ORDER = ["T cell", "NK cell", "B cell", "Monocyte", "DC", "Progenitor cell", "Platelet", "Erythrocyte", "ILC",
+            "Other", "Unlabelled"]
+L1_COLOR = {"T cell": "#4C6E91", "NK cell": "#8FB0CF", "B cell": "#C98A4B", "Monocyte": "#5E8C6A",
+            "DC": "#A8C79C", "Progenitor cell": "#8E6C9E", "Platelet": "#D3B5D3", "Erythrocyte": "#B5655E",
+            "ILC": "#7FB3B0", "Other": "#9A9A9A", "Unlabelled": "#E2E2E2"}
+L1_MERGE = {"NKT cell": "Other", "Granulocyte": "Other", "Neutrophil": "Other", "Mast cell": "Other",
+            "__unknown__": "Unlabelled", "No label (overlay)": "Unlabelled"}
+SPLIT_COLOR = {"train": "#5B6E8F", "val": "#9AACC4", "test": "#C9D2DF"}
+HAND_COLOR = {"ex vivo": "#5B6E8F", "in vitro": "#C9D2DF"}
+
+
+def fmt_cells(n: float) -> str:
+    return f"{n / 1e6:.1f} M" if n >= 1e6 else f"{n / 1e3:.0f} k"
+
+
+def pct(x: float) -> str:
+    return f"{100 * x:.1f}%" if x >= 0.001 else "<0.1%"
+
+
+def letter(fig, x, y, s):
+    fig.text(x, y, s, fontsize=9, fontweight="bold", va="top", ha="left")
+
+
+def pie(fig, rect, vals: dict, colors: dict, title: str):
+    """small pie with its key to the right (shares of cells)"""
+    ax = fig.add_axes(rect)
+    keys = [k for k in colors if k in vals]
+    tot = sum(vals.values())
+    ax.pie([vals[k] for k in keys], colors=[colors[k] for k in keys], startangle=90, counterclock=False,
+           wedgeprops={"linewidth": 0.8, "edgecolor": "white"})
+    ax.set_aspect("equal")
+    x, y = rect[0] + rect[2] + 0.004, rect[1] + rect[3] * 0.62
+    fig.text(rect[0], rect[1] + rect[3] + 0.006, title, ha="left", va="bottom", fontsize=6.3)
+    for j, k in enumerate(keys):
+        fig.patches.append(Rectangle((x, y - j * 0.022 - 0.005), 0.008, 0.010, transform=fig.transFigure,
+                                     color=colors[k]))
+        fig.text(x + 0.012, y - j * 0.022, f"{k}  {pct(vals[k] / tot)}", fontsize=5.6, va="center")
+
+
+def strip(ax):
+    ax.set_yticks([])
+    ax.set_xticks([])
+    for sp in ax.spines.values():
+        sp.set_visible(False)
+
+
+L2_SHORT = {"Intermediate monocyte": "Int. monocyte", "Proliferating T cell": "Prolif. T cell",
+            "Proliferating NK cell": "Prolif. NK cell", "Transitional B cell": "Transitional B",
+            "Memory CD4 T cell": "Memory CD4 T", "Naive CD4 T cell": "Naive CD4 T", "Memory CD8 T cell": "Memory CD8 T",
+            "Naive CD8 T cell": "Naive CD8 T", "Naive B cell": "Naive B", "Memory B cell": "Memory B",
+            "Effector B cell": "Effector B", "CD56dim NK cell": "CD56dim NK", "CD56bright NK cell": "CD56bright NK",
+            "CD14 monocyte": "CD14 mono", "CD16 monocyte": "CD16 mono", "DN T cell": "DN T"}
+NAME_SUFFIX = {"B-cell enriched": " (sorted B cells)"}  # the HSPC dataset's name already says HSPC
+
+
+def load():
+    """corpus tables with consistency checks"""
+    summ = json.loads((SRC / "corpus_summary.json").read_text())
+    D = pd.read_csv(SRC / "corpus_datasets.csv")
+    G = pd.read_csv(SRC / "corpus_cellgroups.csv")
+    C = pd.read_csv(SRC / "corpus_celltypes.csv")
+    conds = summ["conditions_order"]
+    if set(G.condition) - set(conds) or set(conds) != set(COND_COLOR):
+        raise SystemExit("condition categories differ from the colour map")
+    C["l1"] = C.celltype_l1.map(lambda x: L1_MERGE.get(x, x))
+    if set(C.l1) - set(L1_ORDER):
+        raise SystemExit(f"unexpected L1 labels: {set(C.l1) - set(L1_ORDER)}")
+    total = summ["cells"]
+    if G.n_cells.sum() != total or C.n_cells.sum() != total or D.n_cells.sum() != total:
+        raise SystemExit("tables do not add up to the corpus total")
+    return summ, D, G, C, conds, total
+
+
+def draw_full(L):
+    """detailed version (Supplementary): overview, datasets, cell types, per-cell record"""
+    summ, D, G, C, conds, total = load()
+    W, H = 180, 200
+    fig = plt.figure(figsize=(W * MM, H * MM))
+
+    # ------------------------------------------------------------------ c: overview
+    y0 = 0.99
+    letter(fig, 0.0, y0, L[0])
+    fig.text(0.03, y0 - 0.002, f"Pretraining corpus – {total / 1e6:.1f} million cells from {summ['datasets']} "
+             f"datasets, {summ['donors']:,} donors and {summ['samples']:,} samples", fontsize=7, va="top")
+    pie(fig, [0.005, 0.835, 0.085, 0.085], summ["split_cells"], SPLIT_COLOR, "Split")
+    pie(fig, [0.005, 0.69, 0.085, 0.085], summ["handling_cells"], HAND_COLOR, "Sample handling")
+    A = G.groupby(["assay", "condition"]).n_cells.sum().unstack(fill_value=0)
+    small = A.sum(1) < 0.002 * total
+    other_lab = None
+    if small.any():
+        other_lab = "Other"
+        other_list = ", ".join(A.index[small])
+        A.loc[other_lab] = A[small].sum()
+        A = A[~small.reindex(A.index, fill_value=False)]
+    A = A.loc[A.drop(index=[other_lab] if other_lab else []).sum(1).sort_values(ascending=False).index.tolist()
+              + ([other_lab] if other_lab else [])]
+    share = A.sum(1) / total
+    n = len(A)
+    top, bot = 0.915, 0.69
+    ax_a = fig.add_axes([0.29, bot, 0.075, top - bot])
+    ax_a.barh(np.arange(n), share.values, 0.62, color=LIGHT)
+    ax_a.set_ylim(n - 0.5, -0.5)
+    ax_a.set_xlim(0, 1.0)
+    strip(ax_a)
+    fig.text(0.29, top + 0.012, "Assay", fontsize=6.3, va="bottom")
+    for i, (lab, sh) in enumerate(share.items()):
+        ax_a.text(-0.04, i, lab, ha="right", va="center", fontsize=5.8, transform=ax_a.get_yaxis_transform())
+        ax_a.text(sh + 0.03, i, pct(sh), va="center", fontsize=5.6, color=SUB)
+    ax_c = fig.add_axes([0.405, bot, 0.59, top - bot])
+    ax_c.set_xlim(0, 1)
+    ax_c.set_ylim(n - 0.5, -0.5)
+    for i, (lab, row) in enumerate(A.iterrows()):
+        left, tot = 0.0, row.sum()
+        for c in conds:
+            w = row.get(c, 0) / tot
+            if w <= 0:
+                continue
+            ax_c.barh(i, w, 0.62, left=left, color=COND_COLOR[c], edgecolor="white", linewidth=0.4)
+            if w > 0.12:
+                dark = c not in ("Healthy", "ACPA+ at risk of RA", "Post-COVID-19", "Cytopenia", "JDM")
+                ax_c.text(left + w / 2, i, c, ha="center", va="center", fontsize=5.5,
+                          color="white" if dark else INK)
+            left += w
+    strip(ax_c)
+    fig.text(0.405, top + 0.012, "Condition proportions", fontsize=6.3, va="bottom")
+    fig.text(0.405, top + 0.003, "0%", fontsize=5.4, color=SUB, va="bottom")
+    fig.text(0.995, top + 0.003, "100%", fontsize=5.4, color=SUB, va="bottom", ha="right")
+    fam = summ["condition_family"]
+    families = list(dict.fromkeys(fam[c] for c in conds))
+    width = {f: max([len(c) + 2 for c in conds if fam[c] == f] + [len(f) if f != "Healthy" else 0])
+             for f in families}
+    xs = 0.405 + np.cumsum([0] + [0.018 + 0.0068 * width[f] for f in families[:-1]])
+    for x, f in zip(xs, families):
+        if f != "Healthy":
+            fig.text(x, 0.672, f, fontsize=5.6, color=SUB, va="top")
+        for j, c in enumerate([c for c in conds if fam[c] == f]):
+            yy = 0.655 - j * 0.0125
+            fig.patches.append(Rectangle((x, yy - 0.004), 0.007, 0.008, transform=fig.transFigure, color=COND_COLOR[c]))
+            fig.text(x + 0.011, yy, c, fontsize=5.6, va="center")
+    if other_lab:
+        fig.text(0.29, 0.672, "Other:\n" + other_list.replace(", ", "\n"), fontsize=5.3, color=SUB, va="top",
+                 linespacing=1.15)
+
+    # ------------------------------------------------------------------ d: datasets
+    yd = 0.6
+    letter(fig, 0.0, yd, L[1])
+    fig.text(0.03, yd - 0.002, "Datasets", fontsize=7, va="top")
+    D = D.sort_values("n_cells", ascending=False).reset_index(drop=True)
+    nd = len(D)
+    dtop, dbot = 0.565, 0.345
+    drh = (dtop - dbot) / nd
+    hdr = dtop + 0.006
+    x_assay, x_bar0, x_bar1 = 0.262, 0.27, 0.43
+    ax_n = fig.add_axes([x_bar0, dbot, x_bar1 - x_bar0, dtop - dbot])
+    ax_n.barh(np.arange(nd), D.n_cells, 0.62, color="#B8B8AE")
+    ax_n.set_xscale("log")
+    ax_n.set_xlim(1e4, 1e8)
+    ax_n.set_ylim(nd - 0.5, -0.5)
+    ax_n.set_yticks([])
+    ax_n.set_xticks([1e4, 1e5, 1e6, 1e7], ["10k", "100k", "1M", "10M"])
+    ax_n.minorticks_off()
+    ax_n.tick_params(axis="x", labelsize=5.3, pad=1)
+    for sp in ("top", "right", "left"):
+        ax_n.spines[sp].set_visible(False)
+    fig.text(x_bar0, hdr, "Cells", fontsize=6.3, va="bottom")
+    fig.text(x_assay, hdr, "Assay", fontsize=6.3, va="bottom", ha="right")
+    fig.text(0.005, hdr, "Dataset", fontsize=6.3, va="bottom")
+    x_don, x_smp = 0.512, 0.567
+    fig.text(x_don, hdr, "Donors", fontsize=6.3, va="bottom", ha="right")
+    fig.text(x_smp, hdr, "Samples", fontsize=6.3, va="bottom", ha="right")
+    for i, r in D.iterrows():
+        y = dtop - (i + 0.5) * drh
+        fig.text(0.005, y, r.short_name + NAME_SUFFIX.get(r.enrichment, ""), fontsize=5.6, va="center")
+        fig.text(x_assay, y, r.assay, fontsize=5.3, va="center", ha="right", color=SUB)
+        ax_n.text(r.n_cells * 1.15, i, fmt_cells(r.n_cells), va="center", fontsize=5.3, color=SUB)
+        fig.text(x_don, y, f"{r.n_donors:,}", fontsize=5.6, va="center", ha="right")
+        fig.text(x_smp, y, f"{r.n_samples:,}", fontsize=5.6, va="center", ha="right")
+    cg = G.groupby(["dataset_prefix", "condition"]).n_cells.sum().unstack(fill_value=0)
+    ct = C.groupby(["dataset_prefix", "l1"]).n_cells.sum().unstack(fill_value=0)
+    for x0, w0, tab, order, cmap, title in ((0.585, 0.195, cg, conds, COND_COLOR, "Condition"),
+                                            (0.80, 0.195, ct, L1_ORDER, L1_COLOR, "Cell type (L1)")):
+        ax = fig.add_axes([x0, dbot, w0, dtop - dbot])
+        for i, r in D.iterrows():
+            row = tab.loc[r.dataset_prefix]
+            left, tot = 0.0, row.sum()
+            for k in order:
+                v = row.get(k, 0) / tot
+                if v > 0:
+                    ax.barh(i, v, 0.62, left=left, color=cmap[k], edgecolor="none")
+                    left += v
+        ax.set_xlim(0, 1)
+        ax.set_ylim(nd - 0.5, -0.5)
+        strip(ax)
+        fig.text(x0, hdr, title, fontsize=6.3, va="bottom")
+
+    # ------------------------------------------------------------------ e: cell types
+    ye = 0.29
+    letter(fig, 0.0, ye, L[2])
+    fig.text(0.03, ye - 0.002, "Cell types (source labels mapped to a shared two-level hierarchy)", fontsize=7, va="top")
+    l1 = C.groupby("l1").n_cells.sum().reindex(L1_ORDER).fillna(0)
+    ax_d = fig.add_axes([0.0, 0.085, 0.165, 0.165])
+    w, _ = ax_d.pie(l1.values, colors=[L1_COLOR[k] for k in l1.index], startangle=90, counterclock=False,
+                    wedgeprops={"width": 0.36, "linewidth": 0.6, "edgecolor": "white"})
+    ax_d.set_aspect("equal")
+    ax_d.text(0, 0, f"{total / 1e6:.1f} M\ncells", ha="center", va="center", fontsize=6.2)
+    for j, k in enumerate(L1_ORDER):
+        y = 0.245 - j * 0.0148
+        fig.patches.append(Rectangle((0.172, y - 0.004), 0.007, 0.008, transform=fig.transFigure, color=L1_COLOR[k]))
+        fig.text(0.183, y, k, fontsize=5.5, va="center")
+        fig.text(0.29, y, pct(l1[k] / total), fontsize=5.5, va="center", ha="right", color=SUB)
+    l2 = C[~C.l1.isin(["Other", "Unlabelled"]) & (C.celltype_l2 != "__unspecified__")]
+    l2 = l2[l2.celltype_l2 != l2.celltype_l1].groupby(["l1", "celltype_l2"]).n_cells.sum().reset_index()
+    l2["o"] = l2.l1.map({k: i for i, k in enumerate(L1_ORDER)})
+    l2 = l2.sort_values(["o", "n_cells"], ascending=[True, False]).reset_index(drop=True)
+    two = C[C.l1.isin(l2.l1.unique())]
+    resolved = l2.n_cells.sum() / two.n_cells.sum()
+    ax2 = fig.add_axes([0.355, 0.095, 0.425, 0.15])
+    ax2.bar(np.arange(len(l2)), l2.n_cells, 0.72, color=[L1_COLOR[k] for k in l2.l1], edgecolor="none")
+    ax2.set_yscale("log")
+    ax2.set_ylim(1e3, 2e7)
+    ax2.set_yticks([1e3, 1e4, 1e5, 1e6, 1e7], ["1k", "10k", "100k", "1M", "10M"])
+    ax2.minorticks_off()
+    ax2.set_xticks(np.arange(len(l2)), [L2_SHORT.get(x, x) for x in l2.celltype_l2], rotation=60, ha="right",
+                   rotation_mode="anchor", fontsize=5.3)
+    ax2.tick_params(axis="x", length=0, pad=1.5)
+    ax2.tick_params(axis="y", labelsize=5.3, pad=1)
+    ax2.set_xlim(-0.6, len(l2) - 0.4)
+    for sp in ("top", "right"):
+        ax2.spines[sp].set_visible(False)
+    ax2.set_ylabel("Cells", fontsize=5.8, labelpad=1)
+    fig.text(0.355, 0.262, f"{len(l2)} L2 subtypes, {fmt_cells(l2.n_cells.min())} to {fmt_cells(l2.n_cells.max())} "
+             f"cells each (L2 resolved for {pct(resolved)} of their L1 cells)", fontsize=5.8, va="bottom")
+
+    # ------------------------------------------------------------------ f: per-cell record
+    xf = 0.81
+    letter(fig, xf - 0.025, ye, L[3])
+    fig.text(xf + 0.005, ye - 0.002, "Per-cell record", fontsize=7, va="top")
+    G_GENES = 20097
+
+    def gbox(x, y, w, h, txt, fs=5.6):
+        fig.patches.append(Rectangle((x, y), w, h, transform=fig.transFigure, color="#D9D9D1"))
+        fig.text(x + w / 2, y + h / 2, txt, ha="center", va="center", fontsize=fs, linespacing=1.1)
+    gbox(xf, 0.228, 0.13, 0.024, f"var: {G_GENES:,} genes")
+    gbox(xf, 0.155, 0.13, 0.066, "Raw counts\n+ measured-gene\nmask", fs=5.6)
+    gbox(xf + 0.137, 0.155, 0.04, 0.066, "obs", fs=5.6)
+    fig.text(xf, 0.142, "Used for bulks and splits", fontsize=5.6, fontweight="bold", va="top")
+    fig.text(xf, 0.127, "sample (cells of one sample),\nplatform (recipe share),\ndataset + donor (split)",
+             fontsize=5.3, va="top", linespacing=1.15)
+    fig.text(xf, 0.083, "Never given to the model", fontsize=5.6, fontweight="bold", va="top")
+    fig.text(xf, 0.068, "condition, cell type (L1/L2)", fontsize=5.3, va="top")
+    fig.text(xf, 0.048, "Bulk = sum of K cells,\nK = 250–4,000", fontsize=5.3, va="top", color=SUB,
+             linespacing=1.15)
+
+    return fig, (W, H), {L[0]: "corpus overview", L[1]: "datasets", L[2]: "cell types", L[3]: "per-cell record"}
+
+
+FAMILY_COLOR = {"Healthy": "#A9B8CC", "Autoimmune": "#7A4F6E", "Infection": "#D08C3C", "Hematologic": "#3F7A73",
+                "Drug reaction": "#5F5F5F"}
+ASSAY_GROUP = {"10x 3' v3": "10x 3'", "10x 3' v2": "10x 3'", "10x 3' (hashed)": "10x 3'", "10x 5' v1": "10x 5'",
+               "10x 5' v2": "10x 5'", "10x Flex": "10x Flex", "Parse": "Parse", "ScaleBio": "ScaleBio"}
+L1_SHOW = ["T cell", "Monocyte", "B cell", "NK cell", "Progenitor cell", "DC"]
+
+
+def draw_compact(L, nature=False):
+    """Fig. 1 strip: assay shares, disease-family shares per assay, L1 cell-type shares.
+    nature=True: the variant under the Nature-style overview (panel d; a-c carry the corpus size, so the title names
+    the content only and is set bold like the a-c headers)"""
+    summ, D, G, C, conds, total = load()
+    fam = summ["condition_family"]
+    W, H = 180, 38
+    fig = plt.figure(figsize=(W * MM, H * MM))
+    fs, fsl = 7.2, 6.8
+    letter(fig, 0.0, 0.96, L[0])
+    if nature:
+        fig.text(0.03, 0.96, "Pretraining corpus: assays, conditions and cell types", fontsize=7.5, va="top",
+                 fontweight="bold")
+    else:
+        fig.text(0.03, 0.96, f"Pretraining corpus: {total / 1e6:.1f} million cells from {summ['datasets']} datasets, "
+                 f"{summ['donors']:,} donors and {summ['samples']:,} samples", fontsize=8.2, va="top")
+    G = G.assign(group=G.assay.map(lambda a: ASSAY_GROUP.get(a, "Other")), family=G.condition.map(fam))
+    A = G.groupby(["group", "family"]).n_cells.sum().unstack(fill_value=0)
+    order = A.drop(index=["Other"], errors="ignore").sum(1).sort_values(ascending=False).index.tolist()
+    A = A.loc[order + (["Other"] if "Other" in A.index else [])]
+    fams = [f for f in FAMILY_COLOR if f in A.columns]
+    share = A.sum(1) / total
+    n = len(A)
+    top, bot = 0.76, 0.32
+    ax_a = fig.add_axes([0.105, bot, 0.06, top - bot])
+    ax_a.barh(np.arange(n), share.values, 0.8, color=LIGHT)
+    ax_a.set_ylim(n - 0.5, -0.5)
+    ax_a.set_xlim(0, 1)
+    strip(ax_a)
+    fig.text(0.105, top + 0.035, "Assay", fontsize=fsl, va="bottom")
+    for i, (lab, sh) in enumerate(share.items()):
+        ax_a.text(-0.05, i, lab, ha="right", va="center", fontsize=fsl, transform=ax_a.get_yaxis_transform())
+        ax_a.text(sh + 0.04, i, pct(sh), va="center", fontsize=fsl - 0.6, color=SUB)
+    ax_c = fig.add_axes([0.215, bot, 0.40, top - bot])
+    ax_c.set_xlim(0, 1)
+    ax_c.set_ylim(n - 0.5, -0.5)
+    for i, (lab, row) in enumerate(A.iterrows()):
+        left, tot = 0.0, row.sum()
+        for f in fams:
+            w = row.get(f, 0) / tot
+            if w <= 0:
+                continue
+            ax_c.barh(i, w, 0.8, left=left, color=FAMILY_COLOR[f], edgecolor="white", linewidth=0.4)
+            seg_mm = w * 0.40 * W
+            if seg_mm > 1.35 * len(f) + 3:  # label only segments wide enough for it
+                ax_c.text(left + w / 2, i, f, ha="center", va="center", fontsize=fsl - 1.2,
+                          color=INK if f == "Healthy" else "white")
+            left += w
+    strip(ax_c)
+    fig.text(0.215, top + 0.035, "Condition proportions", fontsize=fsl, va="bottom")
+    x, y, rend = 0.215, 0.19, fig.canvas.get_renderer()
+    for f in fams:  # two legend rows, kept left of the cell-type ring
+        sh = G[G.family == f].n_cells.sum() / total
+        r = Rectangle((x, y - 0.03), 0.009, 0.06, transform=fig.transFigure, color=FAMILY_COLOR[f])
+        t = fig.text(x + 0.013, y, f"{f} {pct(sh)}", fontsize=fsl - 0.6, va="center")
+        bb = t.get_window_extent(renderer=rend).transformed(fig.transFigure.inverted())
+        if bb.x1 > 0.615:
+            x, y = 0.215, y - 0.12
+            r.set_xy((x, y - 0.03))
+            t.set_position((x + 0.013, y))
+            bb = t.get_window_extent(renderer=rend).transformed(fig.transFigure.inverted())
+        fig.patches.append(r)
+        x = bb.x1 + 0.018
+    # cell types
+    l1 = C.groupby("l1").n_cells.sum()
+    show = l1.reindex(L1_SHOW)
+    rest = total - show.sum()
+    vals = list(show.values) + [rest]
+    keys = L1_SHOW + ["Other"]
+    ax_d = fig.add_axes([0.645, 0.02, 0.14, 0.84])
+    ax_d.pie(vals, colors=[L1_COLOR[k] for k in keys], startangle=90, counterclock=False,
+             wedgeprops={"width": 0.36, "linewidth": 0.6, "edgecolor": "white"})
+    ax_d.set_aspect("equal")
+    ax_d.text(0, 0, "Cell\ntypes", ha="center", va="center", fontsize=fsl)
+    for j, (k, v) in enumerate(zip(keys, vals)):
+        y = 0.80 - j * 0.118
+        fig.patches.append(Rectangle((0.80, y - 0.03), 0.009, 0.06, transform=fig.transFigure, color=L1_COLOR[k]))
+        fig.text(0.813, y, k.replace("Progenitor cell", "Progenitor"), fontsize=fsl, va="center")
+        fig.text(0.995, y, pct(v / total), fontsize=fsl, va="center", ha="right", color=SUB)
+    return fig, (W, H), {L[0]: "pretraining corpus: assay, condition family and L1 cell-type shares"}
+
+
+def save(fig, stem, canvas, panels, note):
+    out = {}
+    for ext in ("pdf", "png", "svg"):
+        p = FIG / f"{stem}.{ext}"
+        fig.savefig(p, dpi=300 if ext == "png" else None)
+        out[ext] = {"path": str(p.relative_to(MS)), "sha256": hashlib.sha256(p.read_bytes()).hexdigest()}
+    prov = {"script": "scripts/corpus/build_figure1_corpus.py", "canvas_mm": list(canvas), "panels": panels,
+            "inputs": {f.name: hashlib.sha256(f.read_bytes()).hexdigest() for f in sorted(SRC.glob("*.csv"))
+                       + [SRC / "corpus_summary.json"]},
+            "outputs": out, "note": note,
+            "scope": "Rendering only; every value is read from source_data/corpus/ (build_corpus_tables.py)."}
+    (FIG / f"{stem}.provenance.json").write_text(json.dumps(prov, indent=1) + "\n")
+    plt.close(fig)
+    print(stem, canvas)
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    a = ap.parse_args()
+    abc = string.ascii_lowercase
+    fig, canvas, panels = draw_compact(abc[abc.index("c"):])
+    save(fig, "fig01_corpus", canvas, panels, "Fig. 1c strip under the current fig01_architecture (a-b); 180 mm")
+    with plt.rc_context({"font.family": "Arial"}):  # the Nature-style overview is set in Arial
+        fig, canvas, panels = draw_compact(abc[abc.index("d"):], nature=True)
+    save(fig, "fig01_corpus_nature", canvas, panels, "Fig. 1d strip under fig01_architecture_nature (a-c); 180 mm")
+    fig, canvas, panels = draw_full(abc)
+    save(fig, "figS_corpus", canvas, panels, "Supplementary: detailed corpus description")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

paper-releases/pbisc-diffusion/updates/20261006T133650Z-fig1-nature-style-candidate/diffusion/metadata/inference_locations.json

@@ -0,0 +1,5 @@
+{
+  "locations": [],
+  "project_id": "pbisc-diffusion",
+  "update_id": "20261006T133650Z-fig1-nature-style-candidate"
+}

paper-releases/pbisc-diffusion/updates/20261006T133650Z-fig1-nature-style-candidate/diffusion/metadata/request.json

@@ -0,0 +1,127 @@
+{
+  "assets": [
+    {
+      "host": "server_1",
+      "kind": "document",
+      "source": "/home/sj_server_1/PBISC/paper-release-20260928/manuscript/editorial/fig1_nature_redesign_plan_20261006.md",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "figure",
+      "source": "/home/sj_server_1/PBISC/paper-release-20260928/manuscript/figures/drafts/fig01_nature_preview_20261006.png",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "figure",
+      "source": "/home/sj_server_1/PBISC/paper-release-20260928/manuscript/figures/fig01_architecture_nature.pdf",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "figure",
+      "source": "/home/sj_server_1/PBISC/paper-release-20260928/manuscript/figures/fig01_architecture_nature.png",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "config",
+      "source": "/home/sj_server_1/PBISC/paper-release-20260928/manuscript/figures/fig01_architecture_nature.provenance.json",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "figure",
+      "source": "/home/sj_server_1/PBISC/paper-release-20260928/manuscript/figures/fig01_architecture_nature.svg",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "figure",
+      "source": "/home/sj_server_1/PBISC/paper-release-20260928/manuscript/figures/fig01_corpus.pdf",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "figure",
+      "source": "/home/sj_server_1/PBISC/paper-release-20260928/manuscript/figures/fig01_corpus.png",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "config",
+      "source": "/home/sj_server_1/PBISC/paper-release-20260928/manuscript/figures/fig01_corpus.provenance.json",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "figure",
+      "source": "/home/sj_server_1/PBISC/paper-release-20260928/manuscript/figures/fig01_corpus.svg",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "figure",
+      "source": "/home/sj_server_1/PBISC/paper-release-20260928/manuscript/figures/fig01_corpus_nature.pdf",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "figure",
+      "source": "/home/sj_server_1/PBISC/paper-release-20260928/manuscript/figures/fig01_corpus_nature.png",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "config",
+      "source": "/home/sj_server_1/PBISC/paper-release-20260928/manuscript/figures/fig01_corpus_nature.provenance.json",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "figure",
+      "source": "/home/sj_server_1/PBISC/paper-release-20260928/manuscript/figures/fig01_corpus_nature.svg",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "figure",
+      "source": "/home/sj_server_1/PBISC/paper-release-20260928/manuscript/figures/figS_corpus.pdf",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "figure",
+      "source": "/home/sj_server_1/PBISC/paper-release-20260928/manuscript/figures/figS_corpus.png",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "config",
+      "source": "/home/sj_server_1/PBISC/paper-release-20260928/manuscript/figures/figS_corpus.provenance.json",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "figure",
+      "source": "/home/sj_server_1/PBISC/paper-release-20260928/manuscript/figures/figS_corpus.svg",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "code",
+      "source": "/home/sj_server_1/PBISC/paper-release-20260928/manuscript/scripts/build_figure1_architecture_nature.py",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "code",
+      "source": "/home/sj_server_1/PBISC/paper-release-20260928/manuscript/scripts/corpus/build_figure1_corpus.py",
+      "state": "completed"
+    }
+  ],
+  "inference_locations": [],
+  "project_id": "pbisc-diffusion",
+  "summary": "Candidate Nature-style Figure 1 (not yet in the manuscript): plan from six Nature-family Fig. 1 overviews (editorial/fig1_nature_redesign_plan_20261006.md); new SVG master fig01_architecture_nature (a pretraining on pseudobulk, b diffusion on each gene's value and detection with the drawn read-out, c from a measured bulk to cells with optional few-pair low-rank adaptation and uses), Arial, 180 x 95 mm, schematic with corpus numbers from corpus_summary.json; panel-d strip variant fig01_corpus_nature; preview in figures/drafts. The current fig01_corpus (panel c) and overview_figure.tex are unchanged."
+}