Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261012T130738Z-strictpairs-implementation/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/archive/20261012T130738Z-strictpairs-implementation/snapshot/tools/figure5_details.py

@@ -0,0 +1,104 @@
+"""Draw all-state results and the explicitly unmatched Behcet A/B comparison."""
+from pathlib import Path
+import hashlib
+import json
+import numpy as np
+import pandas as pd
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+
+
+def sha(p):
+    return hashlib.file_digest(Path(p).open('rb'),'sha256').hexdigest()
+
+
+def all_state_metrics(donor, summary):
+    records=[]
+    for (cohort,unit,arm,state),d in donor.groupby(['cohort','unit','arm','state'],sort=True):
+        if d.donor_id.duplicated().any():
+            raise ValueError('repeated visits must be collapsed before rare-state detection')
+        present=d.obs_state.gt(0); absent=d.obs_state.eq(0)
+        records.append({'cohort':cohort,'unit':unit,'arm':arm,'state':state,
+                        'missed_observed_fraction':float(d.loc[present,'gen_state'].eq(0).mean()) if present.any() else np.nan,
+                        'generated_in_observed_zero_fraction':float(d.loc[absent,'gen_state'].gt(0).mean()) if absent.any() else np.nan,
+                        'n_observed_positive_donors':int(present.sum()),'n_evaluable_donors':len(d)})
+    extra=pd.DataFrame(records)
+    keys=['cohort','unit','arm','state']
+    return summary.merge(extra,on=keys,validate='one_to_one')
+
+
+def render_all_states(out, donor, summary, tier, arms):
+    data=all_state_metrics(donor,summary)
+    data.to_csv(out/'source_data/rare_all_states.csv',index=False)
+    agg=data.groupby(['cohort','state','arm'],as_index=False).agg(
+        abundance_error=('mae_donor_pp','mean'), abundance_error_draw_sd=('mae_donor_pp','std'),
+        ranking=('spearman_donor','mean'),ranking_draw_sd=('spearman_donor','std'),
+        missed_observed_fraction=('missed_observed_fraction','mean'),
+        generated_in_observed_zero_fraction=('generated_in_observed_zero_fraction','mean'))
+    agg.to_csv(out/'source_data/rare_all_states_aggregate.csv',index=False)
+    keys=list(dict.fromkeys(zip(agg.cohort,agg.state)))
+    fig,axes=plt.subplots(1,4,figsize=(12,max(6,len(keys)*.18)),layout='constrained')
+    for ax,col,label,vmax in zip(axes,['abundance_error','ranking','missed_observed_fraction','generated_in_observed_zero_fraction'],
+                                ['Abundance error (pp)','Abundance Spearman r','Missed observed-positive donors','Generated in observed-zero donors'],[None,1,1,1]):
+        matrix=np.full((len(keys),len(arms)),np.nan)
+        for i,(cohort,state) in enumerate(keys):
+            for j,arm in enumerate(arms):
+                row=agg[(agg.cohort==cohort)&(agg.state==state)&(agg.arm==arm)]
+                if len(row):matrix[i,j]=row.iloc[0][col]
+        image=ax.imshow(np.ma.masked_invalid(matrix),aspect='auto',cmap='coolwarm' if col=='ranking' else 'viridis',
+                        vmin=-1 if col=='ranking' else 0,vmax=vmax)
+        ax.set_xticks(range(len(arms)),arms,rotation=65,ha='right',fontsize=7)
+        ax.set_yticks(range(len(keys)),[f'{c}: {s}' for c,s in keys] if ax is axes[0] else [])
+        ax.tick_params(axis='y',labelsize=5.2);ax.set_title(label,fontsize=9)
+        fig.colorbar(image,ax=ax,shrink=.5)
+    fig.suptitle('All predefined states · every draw retained · '+tier)
+    for ext in ['pdf','svg','png']:fig.savefig(out/'figures'/f'fig5_all_states_{tier}.{ext}',dpi=220)
+    plt.close(fig)
+    return data
+
+
+def behcet_source(behcet,out):
+    (out/'reports').mkdir(parents=True,exist_ok=True)
+    source=behcet/'out/rules_groups/per_sample_group_metrics.csv'
+    pairs=behcet.parent/'behcet_pair_recovery_20261004/out/pairs_recovered.csv'
+    group=behcet/'out/group_table.csv'
+    train=set(pd.read_csv(pairs).bulk_sample.astype(str))
+    if len(train)!=3:raise ValueError('Behcet candidate training set changed')
+    data=pd.read_csv(source)
+    names=['obs','obs_thin_lora3','zs_raw_s13','zs_cal_s13','lora3_raw_s13','lora3_raw_s04']
+    data=data[data.arm.isin(names)&(data.arm.str.startswith('obs')|~data.sample_id.isin(train))].copy()
+    reference=pd.read_csv(group)
+    for arm,sub in data.groupby('arm'):
+        expected=reference[(reference.arm==arm)&reference.rows.isin(['test','observed'])&(reference.metric=='c1q_high_rule_A')].iloc[0]
+        if (int(sub.group.eq('BD').sum()),int(sub.group.eq('HC').sum()))!=(int(expected.n_bd),int(expected.n_hc)):
+            raise ValueError('Behcet individual data do not reproduce frozen held-out groups')
+    data['evidence_tier']='descriptive_unmatched'
+    data['real_reference_includes_training_donors']=True
+    data.to_csv(out/'source_data/rare_behcet_per_sample.csv',index=False)
+    (out/'reports/rare_behcet_provenance.json').write_text(json.dumps({
+        'schema':'pbisc.fig5.behcet-descriptive.v1','sources':{str(p):sha(p) for p in [source,pairs,group]},
+        'training_bulk_samples':sorted(train),'pair_identity':'2 primary passes; 1 uncertain',
+        'calibration':'zs_cal is gene-wise calibration fitted on the same three candidate pairs; it is not external AIFI ref-cal',
+        'real_reference':'4 BD and 4 HC; includes training sc donors, mostly unmatched to held-out bulks',
+        'rules':{'A':'at least one C1Q gene detected','B':'at least two C1Q genes co-detected in the same cell'},
+        'independent_paired_validation':False},indent=2)+'\n')
+    return data,names
+
+
+def render_behcet(behcet,out,tier):
+    data,names=behcet_source(behcet,out)
+    labels=['Observed native','Observed thinned to LoRA','Raw','Same-3-pair calibration','LoRA-3 seed 1','LoRA-3 seed 2']
+    fig,axes=plt.subplots(1,2,figsize=(10,4.5),layout='constrained')
+    for ax,rule,title in zip(axes,['A','B'],['A  Any C1Q gene','B  At least two C1Q genes in one cell']):
+        for j,arm in enumerate(names):
+            for k,group in enumerate(['HC','BD']):
+                values=100*data[(data.arm==arm)&(data.group==group)][f'c1q_high_fraction_{rule}'].to_numpy()
+                y=np.full(len(values),j+(k-.5)*.22)+np.linspace(-.05,.05,len(values))
+                ax.scatter(values,y,s=13,c='#c15f46' if group=='BD' else '#437c96',alpha=.65,label=group if j==0 else None)
+                ax.plot(np.mean(values),j+(k-.5)*.22,'|',color='black',markersize=10)
+        ax.set_yticks(range(len(names)),labels);ax.invert_yaxis();ax.set_xlabel('Monocytes satisfying rule (%)')
+        ax.set_title(title,fontsize=10);ax.legend(frameon=False,fontsize=8);ax.grid(axis='x',alpha=.15)
+    fig.suptitle('Behcet · descriptive unmatched reference; observed set includes training donors',fontsize=10)
+    for ext in ['pdf','svg','png']:fig.savefig(out/'figures'/f'fig5_behcet_rules_{tier}.{ext}',dpi=220)
+    plt.close(fig)

paper-releases/pbisc-diffusion/updates/20261012T130738Z-strictpairs-implementation/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/archive/20261012T130738Z-strictpairs-implementation/snapshot/tools/figure5_panels.py

@@ -0,0 +1,208 @@
+#!/usr/bin/env python3
+"""Render Figure 5 from the corrected rare-state tables; preserve diagnostic labels."""
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+
+HERE = Path(__file__).resolve().parents[1]
+M8 = HERE.parents[1]
+BEHCET = M8 / "plans/behcet_c1q_lora3_20261004"
+COLORS = {"lora5": "#006c80", "scsemi5": "#b76938", "zs_raw": "#7d7d88", "zs_cal": "#b38b2d",
+          "lora": "#006c80", "pairedcal": "#b38b2d", "scsemi": "#b76938",
+          "raw": "#7d7d88", "refcal": "#70569a"}
+ARM_ORDER = {"diagnostic": ("zs_raw", "zs_cal", "scsemi5", "lora5"),
+             "strict": ("raw", "refcal", "pairedcal", "scsemi", "lora")}
+REFERENCE_ARM = {"diagnostic": "lora5", "strict": "lora"}
+
+
+def validate_plot_data(sample: pd.DataFrame, donor: pd.DataFrame,
+                       summary: pd.DataFrame, tier: str) -> list[str]:
+    if tier not in ARM_ORDER:
+        raise ValueError(f"unknown Figure 5 evidence tier: {tier}")
+    available = set(summary.arm)
+    if tier == "strict" and available != set(ARM_ORDER[tier]):
+        raise ValueError(f"strict figure arms incomplete: {sorted(available)}")
+    arms = [a for a in ARM_ORDER[tier] if a in available]
+    if not arms or not set(arms) <= set(sample.arm) or not set(arms) <= set(donor.arm):
+        raise ValueError("Figure 5 plotting tables lack matched arm data")
+    focus = "C1Q-high monocyte (reference)"
+    if summary[(summary.arm == REFERENCE_ARM[tier]) & (summary.state == focus)].empty:
+        raise ValueError("Figure 5 reference C1Q state missing")
+    if sample[(sample.state == focus) & (sample.arm == REFERENCE_ARM[tier])].empty or donor[
+        (donor.state == focus) & (donor.arm == REFERENCE_ARM[tier])].empty:
+        raise ValueError("Figure 5 sample/donor C1Q scatter missing")
+    if sample[(sample.state_kind == "markers") & (sample.arm.isin(arms))].empty:
+        raise ValueError("Figure 5 marker codetection data missing")
+    return arms
+
+
+def _behcet(out: Path) -> pd.DataFrame:
+    source = BEHCET / "out/group_table.csv"
+    if not source.is_file():
+        raise FileNotFoundError(source)
+    x = pd.read_csv(source)
+    x = x[(x.rows == "test") & (x.metric == "c1q_high_rule_A") &
+          x.arm.isin(["zs_raw_s13", "zs_cal_s13", "lora3_raw_s13", "lora3_raw_s04"])]
+    x = x.assign(evidence_tier="descriptive_unmatched",
+                 training="3 BD-only candidate pairs; 2 primary identity passes, 1 uncertain",
+                 truth="4 BD and 4 HC sc donors mostly unmatched to generated-bulk donors",
+                 rule="any C1Q gene; weak single-gene state")
+    x.to_csv(out / "source_data/rare_behcet_descriptive.csv", index=False)
+    return x
+
+
+def require_visual_readiness(out: Path, tier: str) -> None:
+    if tier != "strict":
+        raise ValueError("complete visual readiness requires strict Figure 5 data")
+    provenance = out / "reports/rare_provenance.json"
+    visual = out / "reports/rare_visual_provenance.json"
+    if not provenance.is_file() or not visual.is_file():
+        raise ValueError("strict Figure 5 visual provenance is incomplete")
+    rare = json.loads(provenance.read_text())
+    vis = json.loads(visual.read_text())
+    if (len(rare.get("units", [])) != 20 or
+        {u.get("evidence_tier") for u in rare["units"]} != {"strict"} or
+        rare.get("visuals", {}).get("status") != "complete" or
+        vis.get("schema") != "pbisc.figure5.marker-visuals.v1" or
+        vis.get("status") != "complete" or
+        len(vis.get("examples", [])) != 3 or
+        any(e.get("status") not in {"available", "unavailable"} for e in vis["examples"])):
+        raise ValueError("strict Figure 5 visual readiness is incomplete")
+    for ext in ("pdf", "svg", "png"):
+        path = out / "figures" / f"fig5_rare_visuals_strict.{ext}"
+        if not path.is_file() or path.stat().st_size == 0:
+            raise ValueError(f"strict Figure 5 visual asset absent: {path}")
+
+
+def render(out: Path, *, require_complete: bool = False) -> None:
+    src = out / "source_data"
+    sample = pd.read_csv(src / "rare_per_sample.csv")
+    donor = pd.read_csv(src / "rare_per_donor.csv")
+    summary = pd.read_csv(src / "rare_summary.csv")
+    if summary.empty:
+        raise ValueError("no rare-state data")
+    tiers = set(summary.evidence_tier)
+    if len(tiers) != 1:
+        raise ValueError("do not mix strict and diagnostic analyses in one figure")
+    tier = tiers.pop()
+    if require_complete:
+        require_visual_readiness(out, tier)
+    arms = validate_plot_data(sample, donor, summary, tier)
+    reference_arm = REFERENCE_ARM[tier]
+    behcet = _behcet(out)
+    plt.rcParams.update({"font.family": "DejaVu Sans", "font.size": 8, "pdf.fonttype": 42})
+    fig = plt.figure(figsize=(13.2, 13.5), constrained_layout=True)
+    gs = fig.add_gridspec(3, 2, height_ratios=[1.5, 1, 1])
+    axs = [fig.add_subplot(gs[i, j]) for i in range(3) for j in range(2)]
+    ax = axs[0]
+    # Actual observed fractions: median over repeated draws; every state remains visible.
+    obs = (summary[summary.arm == reference_arm].groupby(["state", "cohort"], as_index=False)
+           .obs_pct.median())
+    states = list(dict.fromkeys(summary.state))
+    cohorts = list(dict.fromkeys(summary.cohort))
+    for i, state in enumerate(states):
+        for j, cohort in enumerate(cohorts):
+            v = obs[(obs.state == state) & (obs.cohort == cohort)].obs_pct
+            if len(v):
+                value = float(v.iloc[0])
+                ax.scatter(j, i, s=24 + 120 * np.sqrt(max(value, 0) / 100),
+                           c=[np.log10(value + .01)], cmap="viridis", vmin=-2, vmax=1.5,
+                           edgecolors="#425260", linewidths=.3)
+                ax.annotate(f"{value:.1f}" if value >= .1 else f"{value:.2f}",
+                            (j, i), xytext=(6, 0), textcoords="offset points",
+                            va="center", fontsize=5.5, color="#344047")
+    ax.set_xticks(range(len(cohorts)), [s.replace("_", " ") for s in cohorts], rotation=25, ha="right")
+    ax.set_yticks(range(len(states)), states)
+    ax.invert_yaxis()
+    ax.set_xlim(-.5, len(cohorts)-.35)
+    ax.grid(alpha=.17)
+    ax.set_title("A  Observed state share within parent (%) · all evaluable rules", loc="left", weight="bold")
+    ax = axs[1]
+    observed_donors = donor[donor.arm == reference_arm]
+    for i, state in enumerate(states):
+        for j, cohort in enumerate(cohorts):
+            part = observed_donors[(observed_donors.state == state) & (observed_donors.cohort == cohort)]
+            if part.empty:
+                continue
+            counts = part.groupby('unit').agg(present=('obs_state', lambda x: int((x > 0).sum())), total=('donor_id', 'nunique'))
+            ax.text(j, i, f"{counts.present.median():g}/{counts.total.median():g}", ha='center', va='center', fontsize=6)
+    ax.set_xticks(range(len(cohorts)), [s.replace('_', ' ') for s in cohorts], rotation=25, ha='right')
+    ax.set_yticks(range(len(states)), []); ax.set_ylim(len(states)-.5, -.5); ax.set_xlim(-.5,len(cohorts)-.5)
+    ax.set_title('Observed-positive / evaluated donors · median across draws',loc='left',fontsize=9,weight='bold')
+    ax = axs[2]
+    for i, arm in enumerate(arms):
+        y = summary.loc[summary.arm == arm, "mae_donor_pp"].dropna()
+        if len(y):
+            ax.boxplot([y], positions=[i], widths=.48, showfliers=False,
+                       boxprops=dict(color=COLORS[arm]), whiskerprops=dict(color=COLORS[arm]),
+                       capprops=dict(color=COLORS[arm]), medianprops=dict(color="#132f39"))
+            ax.scatter(np.full(len(y), i) + np.random.default_rng(81+i).uniform(-.2, .2, len(y)),
+                       y, s=3, color=COLORS[arm], alpha=.2)
+    ax.set_xticks(range(len(arms)), arms, rotation=20)
+    ax.set_ylabel("Donor absolute error (percentage points)")
+    ax.set_title("B  Abundance error", loc="left", weight="bold", pad=14)
+    ax = axs[3]
+    focus = donor[donor.state == "C1Q-high monocyte (reference)"]
+    sample_focus = sample[(sample.state == "C1Q-high monocyte (reference)") &
+                          (sample.arm == reference_arm)].copy()
+    sx = 100 * sample_focus.obs_state / sample_focus.obs_parent.replace(0, np.nan)
+    sy = 100 * sample_focus.gen_state / sample_focus.gen_parent.replace(0, np.nan)
+    ax.scatter(sx, sy, s=5, alpha=.12, label="matched samples (LoRA)", color="#4b5960")
+    for arm in arms:
+        d = focus[focus.arm == arm]
+        ax.scatter(d.obs_pct, d.gen_pct, s=13, alpha=.45, label=arm, color=COLORS[arm])
+    lim = max(2, np.nanmax(focus[["obs_pct", "gen_pct"]].to_numpy()) * 1.05) if len(focus) else 2
+    ax.plot([0, lim], [0, lim], color="#72818a", linewidth=.8, linestyle="--")
+    ax.set(xlim=(0, lim), ylim=(0, lim), xlabel="Observed donor C1Q share (%)",
+           ylabel="Generated donor C1Q share (%)")
+    ax.legend(frameon=False, fontsize=7)
+    ax.set_title("C  C1Q share by donor", loc="left", weight="bold", pad=14)
+    ax = axs[4]
+    marker = sample[(sample.state_kind == "markers") & (sample.arm.isin(arms))]
+    cod = marker.groupby("arm", as_index=False)[["obs_codetection", "gen_codetection"]].mean()
+    x = np.arange(len(cod))
+    ax.bar(x-.17, 100*cod.obs_codetection, width=.34, color="#c7d5d9", label="Observed")
+    ax.bar(x+.17, 100*cod.gen_codetection, width=.34,
+           color=[COLORS.get(a, "#777") for a in cod.arm], label="Generated")
+    ax.set_xticks(x, cod.arm, rotation=20)
+    ax.set_ylabel("Parent cells with ≥2 positive markers (%)")
+    ax.legend(frameon=False, fontsize=7)
+    ax.set_title("D  Multi-marker codetection", loc="left", weight="bold", pad=14)
+    ax = axs[5]
+    names = {"zs_raw_s13": "Zero-shot", "zs_cal_s13": "Calibrated",
+             "lora3_raw_s13": "LoRA-3 seed 1", "lora3_raw_s04": "LoRA-3 seed 2"}
+    yy = np.arange(len(behcet))
+    ax.barh(yy, behcet.gap_pp, color=["#7d7d88", "#b38b2d", "#006c80", "#2497aa"][:len(behcet)])
+    ax.axvline(0, color="#3f4b4e", linewidth=.7)
+    ax.set_yticks(yy, [names[a] for a in behcet.arm])
+    ax.invert_yaxis()
+    ax.set_xlabel("BD − HC C1Q-positive monocyte share (pp)")
+    ax.set_title("E  Behçet disease contrast", loc="left", weight="bold", pad=14)
+    ax.text(.01, -.32, "3 candidate BD training pairs (2 primary identity passes, 1 uncertain); "
+            "6 BD + 10 HC held-out bulks. Real sc: 4 BD + 4 HC, mostly different donors.\n"
+            "Rule A is any C1Q gene; multi-gene C1Q-high cells remain under-produced. "
+            "No independent paired-sample claim.", transform=ax.transAxes, va="top", fontsize=7)
+    fig.suptitle(f"Figure 5  Rare-state abundance and limits  |  {tier.upper()}", fontsize=16, weight="bold")
+    (out / "figures").mkdir(exist_ok=True)
+    for ext in ("pdf", "svg", "png"):
+        fig.savefig(out / "figures" / f"fig5_rare_states_{tier}.{ext}", dpi=220, bbox_inches="tight")
+    plt.close(fig)
+    from figure5_details import render_all_states, render_behcet
+    render_all_states(out, donor, summary, tier, arms)
+    render_behcet(BEHCET, out, tier)
+
+
+if __name__ == "__main__":
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--output", type=Path, default=HERE)
+    ap.add_argument("--require-complete", action="store_true")
+    args = ap.parse_args()
+    render(args.output, require_complete=args.require_complete)

paper-releases/pbisc-diffusion/updates/20261012T130738Z-strictpairs-implementation/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/archive/20261012T130738Z-strictpairs-implementation/snapshot/tools/finalize_campaign.py

@@ -0,0 +1,312 @@
+"""Complete source-bound CPU analyses and render Figure 1–5 after the GPU campaign."""
+from __future__ import annotations
+import argparse
+import json
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+import time
+
+from runtime import Runtime, atomic_json, sha256, stamp
+import campaign as C
+
+ROOT = C.ROOT
+ARMS = ("lora", "pairedcal", "scsemi", "raw", "refcal")
+PDF_PY = "/home/sj_server_1/miniforge3/bin/python"  # verified pptx, matplotlib, pandas environment
+
+
+def assert_publication_ready(figures: dict, rare: dict) -> None:
+    if figures.get("status") != "complete":
+        raise ValueError("Figure 2–4 strict evidence is incomplete")
+    if rare.get("design") != "strict5pair" or rare.get("units") != 20:
+        raise ValueError("Figure 5 requires all 20 strict units; diagnostic results are insufficient")
+
+
+def generated_arms(path: Path) -> dict[str, Path]:
+    cohort = C.read_support(path)["cohort"]
+    values = {a: C.gen_dir(path) / f"{a}.npz" for a in ("lora", "pairedcal", "scsemi")}
+    values.update({a: ROOT / "generated/global" / cohort / f"{a}.npz" for a in ("raw", "refcal")})
+    return values
+
+
+def wait_cuda_idle() -> None:
+    while True:
+        result = subprocess.run(["nvidia-smi", "--query-compute-apps=pid,process_name,used_memory",
+                                 "--format=csv,noheader"], capture_output=True, text=True, check=True)
+        if not result.stdout.strip():
+            return
+        time.sleep(15)
+
+
+def deconvolution(runtime: Runtime, units: list[Path]) -> None:
+    script = ROOT / "tools/deconv_strict.py"
+    for path in units:
+        support = C.read_support(path)
+        if support["cohort"] == "immicro":
+            continue
+        out = ROOT / "deconvolution" / C.relative(path)
+        for action in ("prepare", "bayesprism", "cibersortx", "score"):
+            wait_cuda_idle()
+            outputs = {"prepare": [out / "INPUTS.json"],
+                       "bayesprism": [out / "inputs" / support["cohort"] / "fewshot0_full/bp/DONE"],
+                       "cibersortx": [out / "cibersortx" / support["cohort"] / "fewshot0/out_fractions/DONE"],
+                       "score": [out / "score/SUMMARY.json", out / "score/figure4_methods.csv",
+                                 out / "score/expression_signal.csv"]}[action]
+            runtime.execute(f"{C.name(path)}-deconv-{action}",
+                            [C.CPU_PY, "-u", str(script), "--support-manifest", str(path),
+                             "--action", action, "--threads", "4"], memory_gib=24,
+                            inputs=[path, script], outputs=outputs,
+                            previous_outputs=preserve_preview_outputs(runtime, f"{C.name(path)}-deconv-{action}", outputs)
+                            if action == "prepare" else None)
+            if action == "score":
+                result = json.loads((out / "score/SUMMARY.json").read_text())
+                if result.get("status") not in ("complete", "complete_with_not_estimable"):
+                    raise ValueError(f"deconvolution is not complete: {out}")
+
+
+def rare_caches(runtime: Runtime, units: list[Path]) -> None:
+    script = ROOT / "tools/rare_cache_builder.py"
+    for path in units:
+        if C.read_support(path)["cohort"] == "immicro":
+            continue
+        out = ROOT / "work/rare_strict_caches" / C.relative(path)
+        score = ROOT / "scores" / C.relative(path) / "score"
+        argv = [C.CPU_PY, "-u", str(script), "--support-manifest", str(path),
+                "--score-dir", str(score), "--output-dir", str(out),
+                "--cell-budget", "1500", "--depth-target", "1000"]
+        for arm, source in generated_arms(path).items():
+            argv += ["--arm", f"{arm}={source}"]
+        runtime.execute(f"{C.name(path)}-rare-cache", argv, memory_gib=16,
+                        inputs=[path, script, score / "summary.json", score.parent / "scoring_support.json"],
+                        outputs=[out / "rare_manifest.json"])
+
+
+def preserve_diagnostic() -> None:
+    """Keep the first diagnostic's source data when strict tables replace the live navigation files."""
+    dest = ROOT / "diagnostic_legacy_v1"
+    if dest.exists():
+        return
+    files = [*sorted((ROOT / "source_data").glob("rare_*")),
+             *sorted((ROOT / "reports").glob("rare_*")),
+             *sorted((ROOT / "figures").glob("fig5*diagnostic*"))]
+    records = []
+    for path in files:
+        if path.is_file():
+            target = dest / path.relative_to(ROOT)
+            target.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(path, target)
+            records.append({"path": str(target), "sha256": sha256(target)})
+    atomic_json(dest / "PRESERVED.json", {"at": stamp(), "design": "legacy_5donor_diagnostic", "files": records})
+
+
+def preserve_preview_outputs(runtime: Runtime, name: str, paths: list[Path]) -> dict:
+    """A preview may be replaced only after preserving its exact bytes with an explicit receipt."""
+    if runtime.receipt_path(name).exists():
+        return {}
+    proof = {}
+    for path in paths:
+        if not path.exists():
+            continue
+        dest = ROOT / "previews/before_strict_final" / name / path.relative_to(ROOT)
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        if dest.exists() and sha256(dest) != sha256(path):
+            raise ValueError(f"a different preview is already preserved: {dest}")
+        if not dest.exists():
+            shutil.copy2(path, dest)
+        proof[str(path)] = {"backup": str(dest), "sha256": sha256(path)}
+    if proof:
+        atomic_json(ROOT / "previews/before_strict_final" / f"{name}.json", {"at": stamp(), "outputs": proof})
+    return proof
+
+
+def _run_preserving(runtime: Runtime, name: str, argv: list[str], *, memory_gib: int,
+                    inputs: list[Path], outputs: list[Path]) -> None:
+    runtime.execute(name, argv, memory_gib=memory_gib, inputs=inputs, outputs=outputs,
+                    previous_outputs=preserve_preview_outputs(runtime, name, outputs))
+
+
+def cross_draw_statistics(runtime: Runtime, units: list[Path]) -> None:
+    script = ROOT / "tools/finalize_outputs.py"
+    disease = [p for p in units if C.read_support(p)["cohort"] != "immicro"]
+    if len(disease) != 20:
+        raise ValueError("cross-draw statistics require all 20 disease units")
+    inputs = [script, ROOT / "tools/score_strict.py", ROOT / "tools/donor_statistics.py"]
+    for path in disease:
+        base = ROOT / "scores" / C.relative(path)
+        inputs.extend([path, base / "scoring_support.json", base / "score/summary.json",
+                       base / "score/per_donor.csv", base / "statistics/per_donor_long.csv",
+                       base / "statistics/status.json"])
+    _run_preserving(runtime, "aggregate-five-draw-donor-ci",
+                    [C.CPU_PY, str(script), "--action", "cross-draw", "--require-complete"],
+                    memory_gib=8, inputs=inputs,
+                    outputs=[ROOT / "source_data/fig4_cross_draw_donor_ci.csv",
+                             ROOT / "source_data/fig4_cross_draw_donor_ci.json"])
+
+
+def corrected_disease_signal(runtime: Runtime, units: list[Path]) -> None:
+    script = ROOT / "tools/disease_signal.py"
+    disease = [p for p in units if C.read_support(p)["cohort"] != "immicro"]
+    if len(disease) != 20:
+        raise ValueError("donor-aware disease signal requires all 20 disease units")
+    inputs = [script, ROOT / "tools/score_strict.py", ROOT / "tools/donor_statistics.py"]
+    for path in disease:
+        base = ROOT / "scores" / C.relative(path)
+        deg = base / "statistics/donor_deg"
+        inputs.extend([path, base / "scoring_support.json", base / "score/summary.json",
+                       base / "statistics/status.json", deg / "genes_kept.csv",
+                       deg / "donor_deg_summary.csv"])
+        inputs.extend(sorted(p for p in deg.glob("*/*/*") if p.is_file() and p.name in (
+            "donor_condition_pseudobulk.csv", "donor_limma_genes.csv", "limma_status.json")))
+        cohort = C.read_support(path)["cohort"]
+        inputs.extend([C.OLD / "data" / cohort / "features.npz", C.OLD / "data" / cohort / "folds.csv"])
+    names = ("fig4_donor_aware_signal.csv", "fig4_donor_aware_summary.csv",
+             "fig4_donor_aware_genes.csv", "fig4_donor_aware_cat.csv",
+             "fig4_donor_aware_provenance.json")
+    _run_preserving(runtime, "compute-donor-aware-disease-signal",
+                    [C.CPU_PY, str(script), "--require-complete"], memory_gib=12,
+                    inputs=inputs, outputs=[ROOT / "source_data" / name for name in names])
+
+
+def _figure234_outputs() -> list[Path]:
+    names = ("fig2_ablation_and_support", "fig3_healthy_strict_oof", "fig3_realism_metrics",
+             "fig3_umap_by_celltype", "fig3_composition_fractions", "fig3_runtime_components",
+             "fig3_canonical_marker_dotplot", "fig4_disease_strict_draws", "fig4_disease_signal_strict",
+             "fig4_disease_signal_scatter", "fig4_disease_signal_heatmap", "fig4_disease_signal_cat",
+             "fig4_deconvolution_strict", "fig4_deconvolution_expression_strict",
+             "fig4_deconvolution_historical_signal", "fig4_deconvolution_covered_sensitivity",
+             "fig4_historical_5fold_separate")
+    files = [ROOT / "figures" / f"{name}.{ext}" for name in names for ext in ("pdf", "svg", "png")]
+    files += [ROOT / "source_data" / name for name in (
+        "fig2_historical_rank_full.csv", "fig2_strict_curve.csv", "fig3_per_sample.csv",
+        "fig3_extras.csv", "fig4_strict_per_sample.csv", "fig4_corrected_statistics.csv",
+        "fig4_strict_contrast.csv", "fig4_deconvolution.csv", "fig4_deconvolution_signal.csv",
+        "fig4_historical_5fold.csv")]
+    files += [ROOT / "reports/figures234_readiness.json", ROOT / "reports/figures234_readiness.md"]
+    return files
+
+
+def final_documents(runtime: Runtime, figures: dict, rare: dict) -> None:
+    assert_publication_ready(figures, rare)
+    deck = ROOT / "tools/build_review_deck.py"
+    panel_outputs = [ROOT / "deck" / f"fig1_panel_{panel}.{ext}"
+                     for panel in ("ab", "cd", "e") for ext in ("png", "svg")]
+    _run_preserving(runtime, "render-final-review-deck",
+                    [PDF_PY, str(deck), "--require-complete"], memory_gib=4,
+                    inputs=[deck, ROOT / "reports/figures234_readiness.json",
+                            ROOT / "reports/rare_provenance.json", ROOT / "reports/rare_visual_provenance.json"],
+                    outputs=[ROOT / "deck/paper_figures_final.pptx", ROOT / "deck/final_gate_sources.json",
+                             ROOT / "deck/README.md", *panel_outputs])
+    manuscript = ROOT / "tools/assemble_manuscript.py"
+    stage = ROOT / "manuscript"
+    previous_sources = [*stage.glob("*.tex"), *stage.glob("sections/*.tex"),
+                        stage / "main.pdf", stage / "supplementary.pdf", stage / "integration_manifest.json"]
+    # Assembly changes many staged TeX files; preserve the earlier review copy
+    # before replacing any of them, while Runtime protects its manifest output.
+    proof = preserve_preview_outputs(runtime, "assemble-verified-manuscript", previous_sources)
+    manifest = stage / "integration_manifest.json"
+    runtime.execute("assemble-verified-manuscript", [C.CPU_PY, str(manuscript), "--require-complete"],
+                    memory_gib=4,
+                    inputs=[manuscript, ROOT / "reports/figures234_readiness.json",
+                            ROOT / "reports/rare_provenance.json",
+                            ROOT / "source_data/fig4_cross_draw_donor_ci.csv"],
+                    outputs=[manifest],
+                    previous_outputs={str(manifest): proof[str(manifest)]} if str(manifest) in proof else {})
+    export = ROOT / "tools/finalize_outputs.py"
+    _run_preserving(runtime, "compile-final-manuscript-pdfs",
+                    [PDF_PY, str(export), "--action", "manuscript-pdf", "--require-complete"],
+                    memory_gib=8, inputs=[export, manifest, stage / "main.tex", stage / "supplementary.tex"],
+                    outputs=[stage / "main.pdf", stage / "supplementary.pdf"])
+    _run_preserving(runtime, "convert-final-deck-pdf",
+                    [PDF_PY, str(export), "--action", "deck-pdf", "--require-complete"],
+                    memory_gib=8, inputs=[export, ROOT / "deck/paper_figures_final.pptx",
+                                          ROOT / "deck/final_gate_sources.json"],
+                    outputs=[ROOT / "deck/paper_figures_final.pdf"])
+
+
+def render(runtime: Runtime, units: list[Path]) -> None:
+    preserve_diagnostic()
+    cross_draw_statistics(runtime, units)
+    corrected_disease_signal(runtime, units)
+    visual = ROOT / "tools/export_healthy_visuals.py"
+    _run_preserving(runtime, "export-healthy-visuals", [C.CPU_PY, str(visual)], memory_gib=24,
+                    inputs=[visual, *units], outputs=[ROOT / "source_data" / name for name in (
+                        "fig3_visual_data.json", "fig3_visual_data.npz", "fig3_marker_codetection.csv",
+                        "fig3_runtime_evidence.json", "fig3_runtime.csv", "fig3_runtime.json",
+                        "fig3_celltype_fractions.csv", "fig3_umap_coordinates.csv")])
+    cache_root = ROOT / "work/rare_strict_caches"
+    analysis = ROOT / "tools/build_figure5.py"
+    _run_preserving(runtime, "analyze-strict-rare", [C.CPU_PY, str(analysis), "--manifest-dir", str(cache_root)],
+                    memory_gib=12, inputs=[analysis, *sorted(cache_root.rglob("rare_manifest.json"))],
+                    outputs=[ROOT / "source_data" / name for name in (
+                        "rare_per_sample.csv", "rare_per_donor.csv", "rare_summary.csv",
+                        "rare_ineligible_states.csv")])
+    export = ROOT / "tools/export_rare_visuals.py"
+    _run_preserving(runtime, "export-strict-rare-visuals",
+                    [C.CPU_PY, str(export), "--manifest-dir", str(cache_root)],
+                    memory_gib=16, inputs=[export, ROOT / "source_data/rare_summary.csv"],
+                    outputs=[ROOT / "reports/rare_visual_provenance.json", ROOT / "reports/rare_provenance.json",
+                             *[ROOT / "source_data" / n for n in ("rare_visual_cells.csv", "rare_visual_heatmap.csv",
+                                                                         "rare_visual_donor_draws.csv")],
+                             *[ROOT / "figures" / f"fig5_rare_visuals_strict.{ext}" for ext in ("pdf", "svg", "png")]])
+    plot = ROOT / "tools/figure5_panels.py"
+    _run_preserving(runtime, "render-strict-rare", [C.CPU_PY, str(plot), "--require-complete"],
+                    memory_gib=4, inputs=[plot, ROOT / "tools/figure5_details.py", ROOT / "reports/rare_provenance.json"],
+                    outputs=[ROOT / "source_data" / name for name in ("rare_behcet_descriptive.csv",
+                                "rare_behcet_per_sample.csv", "rare_all_states.csv", "rare_all_states_aggregate.csv")]
+                            + [ROOT / "reports/rare_behcet_provenance.json"]
+                            + [ROOT / "figures" / f"fig5_{stem}_strict.{ext}" for stem in
+                                ("rare_states", "all_states", "behcet_rules") for ext in ("pdf", "svg", "png")])
+    plot = ROOT / "tools/build_results_figures.py"
+    _run_preserving(runtime, "render-strict-figures234", [C.CPU_PY, str(plot), "--require-complete"],
+                    memory_gib=8, inputs=[plot, ROOT / "tools/figure2_panels.py", ROOT / "deconvolution/deconvolution_manifest.json",
+                                          ROOT / "source_data/fig4_cross_draw_donor_ci.json",
+                                          ROOT / "source_data/fig4_donor_aware_provenance.json"],
+                    outputs=_figure234_outputs())
+    ready = json.loads((ROOT / "reports/figures234_readiness.json").read_text())
+    rare = json.loads((ROOT / "reports/rare_provenance.json").read_text())
+    strict = all(u.get("design") == "strict5pair" and u.get("evidence_tier") == "strict" for u in rare.get("units", []))
+    assert_publication_ready(ready, {"design": "strict5pair" if strict else "diagnostic", "units": len(rare.get("units", []))})
+    final_documents(runtime, ready, {"design": "strict5pair" if strict else "diagnostic",
+                                   "units": len(rare.get("units", []))})
+
+
+def main() -> None:
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument("--stage", choices=("deconvolution", "rare", "render", "all"), default="all")
+    a = p.parse_args()
+    units = C.discover_units()
+    if len(units) != 40:
+        raise ValueError("all 40 strict support units are required before finalization")
+    runtime = Runtime(ROOT)
+    state = {"state": "running", "stage": a.stage, "at": stamp(), "figure6": "waiting_user_data"}
+    out = ROOT / "FINALIZATION_STATUS.json"
+    atomic_json(out, state)
+    try:
+        if a.stage in ("deconvolution", "all"):
+            deconvolution(runtime, units)
+        if a.stage in ("rare", "all"):
+            rare_caches(runtime, units)
+        if a.stage in ("render", "all"):
+            render(runtime, units)
+        if a.stage in ("render", "all"):
+            artifacts = [ROOT / "manuscript/main.pdf", ROOT / "manuscript/supplementary.pdf",
+                         ROOT / "deck/paper_figures_final.pptx", ROOT / "deck/paper_figures_final.pdf",
+                         ROOT / "source_data/fig4_cross_draw_donor_ci.csv",
+                         ROOT / "source_data/fig4_donor_aware_signal.csv"]
+            if any(not p.is_file() or p.stat().st_size == 0 for p in artifacts):
+                raise ValueError("final PDF/deck or disease source artifact missing after render")
+            state.update(state="complete", artifacts={str(p): sha256(p) for p in artifacts},
+                         canonical_integration="awaiting_review", archive_update="coordinator_task_end")
+        else:
+            state.update(state="selected_finalization_stage_complete")
+        state["finished_at"] = stamp()
+    except BaseException as exc:
+        state.update(state="stopped_needs_inspection", error=str(exc), stopped_at=stamp())
+        raise
+    finally:
+        atomic_json(out, state)
+
+
+if __name__ == "__main__":
+    main()

paper-releases/pbisc-diffusion/updates/20261012T130738Z-strictpairs-implementation/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/archive/20261012T130738Z-strictpairs-implementation/snapshot/tools/finalize_outputs.py

@@ -0,0 +1,168 @@
+#!/usr/bin/env python3
+"""CPU-only final source data and PDF exports after strict evidence gates."""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import subprocess
+import tempfile
+from pathlib import Path
+
+os.environ["CUDA_VISIBLE_DEVICES"] = ""
+
+import pandas as pd  # noqa: E402
+
+from runtime import sha256  # noqa: E402
+from score_strict import read_support, validate_draw_long  # noqa: E402
+from donor_statistics import summarize_metrics  # noqa: E402
+
+ROOT = Path(__file__).resolve().parents[1]
+COHORTS = ("ye2026_sepsis", "imperial_eskd", "giroux2022", "ji2025_chili")
+ARMS = ("lora", "pairedcal", "scsemi", "raw", "refcal")
+
+
+def cohort_draw_ci(cohort: str, *, draws=range(5)) -> tuple[pd.DataFrame, dict]:
+    """One donor-cluster bootstrap over all five verified draws of a cohort."""
+    if cohort not in COHORTS or tuple(draws) != tuple(range(5)):
+        raise ValueError("cross-draw CI requires exactly five canonical disease draws")
+    supports = []
+    for draw in draws:
+        path = ROOT / "protocol/splits" / cohort / "disease" / f"draw{draw}" / "support.json"
+        if not path.is_file():
+            raise ValueError(f"five-draw support missing: {path}")
+        support = read_support(path)
+        if (support.get("cohort") != cohort or support.get("design") != "disease_existing_draw" or
+                support.get("unit") != f"draw{draw}_n5" or support.get("n_pairs") != 5):
+            raise ValueError(f"five-draw support differs: {path}")
+        supports.append(support)
+    tables, sources = [], []
+    for draw, support in zip(draws, supports):
+        path = ROOT / "scores" / cohort / "disease" / f"draw{draw}" / "statistics/per_donor_long.csv"
+        status_path = path.parent / "status.json"
+        if not status_path.is_file():
+            raise ValueError(f"corrected donor DEG pending: {status_path}")
+        status = json.loads(status_path.read_text())
+        if (status.get("support_sha256") != support["sha256"] or
+                status.get("bootstrap_replicates") != 2000 or
+                status.get("disease_deg", {}).get("status") not in ("ok", "complete_with_not_estimable")):
+            raise ValueError(f"corrected donor DEG pending or wrong support: {status_path}")
+        # validate_draw_long requires another current draw; the next frozen
+        # support supplies that context so every one of the five is verified.
+        current = supports[(draw + 1) % 5]
+        table = validate_draw_long(path, current, ARMS)
+        tables.append(table)
+        sources.append({"unit": support["unit"], "support_sha256": support["sha256"],
+                        "support_path": str(ROOT / "protocol/splits" / cohort / "disease" / f"draw{draw}" / "support.json"),
+                        "long_path": str(path), "long_sha256": sha256(path),
+                        "statistics_status_sha256": sha256(status_path),
+                        "score_binding_sha256": sha256(path.parents[1] / "scoring_support.json"),
+                        "score_summary_sha256": sha256(path.parents[1] / "score/summary.json")})
+    rows = pd.concat(tables, ignore_index=True)
+    if set(rows.draw.astype(str)) != {f"draw{d}_n5" for d in draws}:
+        raise ValueError("five verified long tables do not contain five distinct draws")
+    result = summarize_metrics(rows, baseline="raw", n_boot=2000, seed=20261012)
+    if result.empty or set(result.arm) != set(ARMS) - {"raw"}:
+        raise ValueError("cross-draw CI lacks the common five-arm comparison")
+    result.insert(0, "cohort", cohort)
+    result.insert(1, "design", "strict_exact5_donor_draw_cluster")
+    receipt = {"schema": "pbisc.paper.fig4-cross-draw-donor-ci.v1", "cohort": cohort,
+               "draws": [f"draw{d}_n5" for d in draws], "baseline": "raw",
+               "bootstrap_unit": "unique_donor_all_draws_and_visits", "n_boot": 2000, "seed": 20261012,
+               "sources": sources, "n_rows": len(result)}
+    return result, receipt
+
+
+def write_cross_draw_ci() -> None:
+    tables, sources = [], []
+    for cohort in COHORTS:
+        table, receipt = cohort_draw_ci(cohort)
+        tables.append(table)
+        sources.append(receipt)
+    output = ROOT / "source_data/fig4_cross_draw_donor_ci.csv"
+    record = ROOT / "source_data/fig4_cross_draw_donor_ci.json"
+    output.parent.mkdir(parents=True, exist_ok=True)
+    pd.concat(tables, ignore_index=True).to_csv(output, index=False)
+    record.write_text(json.dumps({"schema": "pbisc.paper.fig4-cross-draw-donor-ci-collection.v1",
+                                  "cohorts": sources, "csv": str(output), "csv_sha256": sha256(output)},
+                                 indent=2) + "\n")
+
+
+def _pdf(path: Path) -> None:
+    if not path.is_file() or path.stat().st_size < 1024:
+        raise ValueError(f"PDF export missing or invalid: {path}")
+    with path.open("rb") as stream:
+        if stream.read(5) != b"%PDF-":
+            raise ValueError(f"PDF export missing or invalid: {path}")
+
+
+def _require_staged_manuscript() -> None:
+    import assemble_manuscript as A
+    manifest = ROOT / "manuscript/integration_manifest.json"
+    if not manifest.is_file():
+        raise ValueError("final staged manuscript manifest missing")
+    record = json.loads(manifest.read_text())
+    if record.get("mode") != "complete" or record.get("gaps"):
+        raise ValueError("staged manuscript is not a complete strict assembly")
+    gaps, _ = A.strict_gate()
+    if gaps:
+        raise ValueError("strict manuscript gate changed: " + "; ".join(gaps[:3]))
+    for rel, info in record.get("staged_changes", {}).items():
+        path = ROOT / "manuscript" / rel
+        if not path.is_file() or sha256(path) != info["sha256"]:
+            raise ValueError(f"staged manuscript source changed after assembly: {rel}")
+    for rel, old_sha in record.get("canonical_source_sha256", {}).items():
+        path = A.CANON / rel
+        if not path.is_file() or sha256(path) != old_sha:
+            raise ValueError(f"canonical manuscript changed after assembly: {rel}")
+
+
+def compile_manuscript_pdfs() -> None:
+    _require_staged_manuscript()
+    stage = ROOT / "manuscript"
+    (ROOT / "work").mkdir(parents=True, exist_ok=True)
+    with tempfile.TemporaryDirectory(prefix="pbisc-strict-tex-", dir=ROOT / "work") as work:
+        temp = Path(work)
+        for name in ("main", "supplementary"):
+            subprocess.run(["/home/sj_server_1/.local/bin/tectonic", "--keep-logs", "--outdir", str(temp), f"{name}.tex"],
+                           cwd=stage, check=True)
+            _pdf(temp / f"{name}.pdf")
+        for name in ("main", "supplementary"):
+            (temp / f"{name}.pdf").replace(stage / f"{name}.pdf")
+
+
+def convert_deck_pdf() -> None:
+    import build_review_deck as D
+    D.final_gate(ROOT)
+    deck = ROOT / "deck/paper_figures_final.pptx"
+    if not deck.is_file() or deck.stat().st_size == 0:
+        raise ValueError("strict final PPTX missing")
+    (ROOT / "work").mkdir(parents=True, exist_ok=True)
+    with tempfile.TemporaryDirectory(prefix="pbisc-strict-deck-", dir=ROOT / "work") as work:
+        temp = Path(work)
+        profile = temp / "lo-profile"
+        subprocess.run(["/usr/bin/libreoffice", "-env:UserInstallation=" + profile.as_uri(),
+                        "--headless", "--convert-to", "pdf", "--outdir", str(temp), str(deck)],
+                       check=True)
+        pdf = temp / "paper_figures_final.pdf"
+        _pdf(pdf)
+        pdf.replace(ROOT / "deck/paper_figures_final.pdf")
+
+
+def main() -> None:
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument("--action", required=True, choices=("cross-draw", "manuscript-pdf", "deck-pdf"))
+    p.add_argument("--require-complete", action="store_true")
+    a = p.parse_args()
+    if not a.require_complete:
+        p.error("final outputs require --require-complete")
+    if a.action == "cross-draw":
+        write_cross_draw_ci()
+    elif a.action == "manuscript-pdf":
+        compile_manuscript_pdfs()
+    else:
+        convert_deck_pdf()
+
+
+if __name__ == "__main__":
+    main()