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/sample_one.py

@@ -0,0 +1,44 @@
+"""Run the frozen sampler inside the caller's ml-run unit, preserving separate receipt and error logs."""
+from __future__ import annotations
+import argparse
+import json
+from pathlib import Path
+import subprocess
+import sys
+from runtime import sha256
+
+
+def main() -> int:
+    p = argparse.ArgumentParser()
+    p.add_argument("--checkpoint", type=Path, required=True)
+    p.add_argument("--checkpoint-sha", required=True)
+    p.add_argument("--condition", type=Path, required=True)
+    p.add_argument("--output", type=Path, required=True)
+    p.add_argument("--seed", type=int, default=20260928)
+    a = p.parse_args()
+    if "ml.slice" not in Path("/proc/self/cgroup").read_text():
+        raise SystemExit("sampler wrapper must be started through ml-run")
+    if sha256(a.checkpoint) != a.checkpoint_sha:
+        raise SystemExit("checkpoint hash mismatch")
+    if any(a.output.with_suffix(s).exists() for s in (".npz", ".log", ".err")):
+        raise SystemExit("existing sampling output or log: preserve and inspect")
+    a.output.parent.mkdir(parents=True, exist_ok=True)
+    script = Path(__file__).resolve().parents[3] / "scripts/sample_sdd_standalone.py"
+    argv = [sys.executable, "-u", str(script), "--checkpoint", str(a.checkpoint),
+            "--condition-npz", str(a.condition), "--output", str(a.output), "--weights", "ema",
+            "--batch-size", "256", "--steps", "50", "--seed", str(a.seed), "--device", "cuda",
+            "--conditioner-source", "embedded", "--active-logit-threshold", "0.0",
+            "--support-readout", "bernoulli"]
+    with a.output.with_suffix(".log").open("x") as out, a.output.with_suffix(".err").open("x") as err:
+        result = subprocess.run(argv, stdout=out, stderr=err)
+    if result.returncode:
+        return result.returncode
+    receipt = json.loads(a.output.with_suffix(".log").read_text())
+    if receipt["output_sha256"] != sha256(a.output):
+        raise SystemExit("sampler output differs from its receipt")
+    print(json.dumps({"output": str(a.output), "output_sha256": receipt["output_sha256"]}), flush=True)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(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/score_strict.py

@@ -0,0 +1,717 @@
+#!/usr/bin/env python3
+"""Strict-support CPU scorer; imports legacy metric mains with isolated output roots.
+
+Example: python tools/score_strict.py --support-manifest protocol/splits/.../support.json
+    --out scores/COHORT/UNIT --arm lora=generated.npz --action all
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import importlib.util
+import json
+import os
+import re
+import sys
+from pathlib import Path
+
+for _key in ("OMP_NUM_THREADS", "OPENBLAS_NUM_THREADS", "MKL_NUM_THREADS", "NUMBA_NUM_THREADS"):
+    os.environ.setdefault(_key, "4")
+os.environ["CUDA_VISIBLE_DEVICES"] = ""
+
+import pandas as pd  # noqa: E402
+import numpy as np  # noqa: E402
+
+PLAN = Path(__file__).resolve().parents[1]
+LEGACY = PLAN.parent / "paired_finetune_intradataset_20260927"
+TOOLS = LEGACY / "tools"
+sys.path.insert(0, str(TOOLS))
+sys.path.insert(0, str(PLAN / "tools"))
+from campaign import BASE, BASE_SHA  # noqa: E402  canonical pretraining checkpoint pinned by campaign
+
+
+def manifest_digest(data: dict) -> str:
+    body = {k: v for k, v in data.items() if k != "sha256"}
+    return hashlib.sha256(json.dumps(body, sort_keys=True, separators=(",", ":"), allow_nan=False).encode()).hexdigest()
+
+
+def read_support(path: Path) -> dict:
+    data = json.loads(Path(path).read_text())
+    if data.get("schema") != "pbisc.paper.strict-support.v1" or data.get("sha256") != manifest_digest(data):
+        raise ValueError("strict support schema or hash mismatch")
+    train, test = data.get("train_sample_ids", []), data.get("test_sample_ids", [])
+    td, vd = data.get("train_donor_ids", []), data.get("test_donor_ids", [])
+    if not test or not train or len(train) != len(td) or len(test) != len(vd):
+        raise ValueError("support requires aligned train/test identities")
+    if data.get("n_pairs") != len(train):
+        raise ValueError("support n_pairs differs from exact training rows")
+    if len(set(train)) != len(train) or len(set(td)) != len(td) or len(set(test)) != len(test):
+        raise ValueError("duplicate support identity")
+    if set(td) & set(vd):
+        raise ValueError("train/test donor overlap")
+    if set(train) & set(test + data.get("excluded_sample_ids", [])):
+        raise ValueError("support sample overlap")
+    return data
+
+
+def patient_mapping(support: dict) -> pd.DataFrame:
+    return pd.DataFrame({"sample_id": support["test_sample_ids"], "donor_id": support["test_donor_ids"]})
+
+
+def validate_lora_run(run: dict, support: dict) -> None:
+    """Reject an old larger-support run even if its held-out IDs coincide."""
+    expected = support["train_sample_ids"]
+    actual = run.get("train_rows", [])
+    if len(actual) != len(expected) or set(actual) != set(expected):
+        raise ValueError("LoRA train_rows differ from exact strict support")
+    if len(expected) != support["n_pairs"] or len(set(support["train_donor_ids"])) != len(expected):
+        raise ValueError("strict support pair count differs from unique donors")
+    checks = {
+        "support_sha256": support["sha256"], "train_donor_ids": support["train_donor_ids"],
+        "test_rows_never_loaded_for_training": support["test_sample_ids"],
+        "excluded_selected_donor_visits": support.get("excluded_sample_ids", []),
+        "inner_val_rows": [], "fixed_steps": 3000, "steps_run": 3000,
+        "selected_step": 3000, "mode": "lora", "source_checkpoint_sha256": BASE_SHA,
+    }
+    for field, want in checks.items():
+        got = run.get(field)
+        if field in {"test_rows_never_loaded_for_training", "excluded_selected_donor_visits"}:
+            if not isinstance(got, list) or len(got) != len(want) or set(got) != set(want):
+                raise ValueError(f"LoRA {field} differs from strict support")
+        elif got != want:
+            raise ValueError(f"LoRA {field} differs from strict support")
+    if run.get("trainable", {}).get("lora_rank") != 16:
+        raise ValueError("LoRA rank differs from strict protocol")
+    if not re.fullmatch(r"[0-9a-f]{64}", str(run.get("checkpoint_sha256", ""))):
+        raise ValueError("LoRA checkpoint hash absent or invalid")
+
+
+def _sha(path: Path) -> str:
+    h = hashlib.sha256()
+    with Path(path).open("rb") as f:
+        for block in iter(lambda: f.read(8 * 1024 * 1024), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+def _unit_relative(support: dict) -> Path:
+    unit = support["unit"]
+    cohort = support["cohort"]
+    if support.get("design") == "healthy_outerfold":
+        match = re.fullmatch(r"fold(\d+)_n(\d+)", unit)
+        if match and int(match[2]) == support["n_pairs"]:
+            return Path(cohort) / "healthy" / f"fold{match[1]}" / f"n{match[2]}"
+    elif support.get("design") == "disease_existing_draw":
+        match = re.fullmatch(r"draw(\d+)_n(\d+)", unit)
+        if match and int(match[2]) == support["n_pairs"]:
+            return Path(cohort) / "disease" / f"draw{match[1]}"
+    raise ValueError("support unit/design is not a canonical strict campaign unit")
+
+
+def _strict_conditions(support: dict, rel: Path) -> dict:
+    folder = PLAN / "data" / rel
+    path = folder / "CONDITIONS.json"
+    support_path = PLAN / "protocol/splits" / rel / "support.json"
+    if not path.is_file() or not support_path.is_file():
+        raise ValueError("strict condition or support receipt missing")
+    if read_support(support_path)["sha256"] != support["sha256"]:
+        raise ValueError("canonical support hash differs")
+    rec = json.loads(path.read_text())
+    if (rec.get("support_sha256") != support["sha256"] or
+            rec.get("support_path") != str(support_path) or
+            rec.get("fit_sample_ids") != support["train_sample_ids"]):
+        raise ValueError("strict condition fit/support binding differs")
+    for name in ("test_raw.npz", "test_cal.npz"):
+        file = folder / name
+        if not file.is_file() or rec.get("files_sha256", {}).get(name) != _sha(file):
+            raise ValueError(f"strict condition file missing or hash differs: {name}")
+        with np.load(file, allow_pickle=False) as z:
+            if set(z["sample_ids"].astype(str)) != set(support["test_sample_ids"]):
+                raise ValueError(f"strict condition sample IDs differ: {name}")
+    return rec
+
+
+def validate_global_build_inputs(build: dict) -> None:
+    inputs = build.get("input_hashes", {})
+    if not inputs:
+        raise ValueError("global BUILD input hashes missing")
+    for raw, expected in inputs.items():
+        source = Path(raw)
+        if not source.is_file() or _sha(source) != expected:
+            raise ValueError(f"global BUILD input changed or missing: {source}")
+
+
+def validate_generation_arm(name: str, path: Path, support: dict) -> dict:
+    """Bind an NPZ to its actual strict training/calibration/export sources."""
+    rel = _unit_relative(support)
+    canonical_support = PLAN / "protocol/splits" / rel / "support.json"
+    if not canonical_support.is_file() or read_support(canonical_support)["sha256"] != support["sha256"]:
+        raise ValueError("arm support hash differs from canonical strict campaign support")
+    if name not in ("lora", "pairedcal", "scsemi", "raw", "refcal"):
+        raise ValueError(f"unsupported campaign arm {name}")
+    expected = (PLAN / "generated/global" / support["cohort"] / f"{name}.npz" if name in ("raw", "refcal")
+                else PLAN / "generated" / rel / f"{name}.npz")
+    path = Path(path).resolve()
+    if path != expected.resolve():
+        raise ValueError(f"canonical strict arm path required: {expected}")
+    if not path.is_file() or not path.with_suffix(".log").is_file():
+        raise ValueError(f"generation NPZ or receipt missing: {path}")
+    receipt = json.loads(path.with_suffix(".log").read_text())
+    if name == "scsemi" and receipt.get("schema") == "pbisc.scsemi.adopted-output.v1":
+        from import_scsemi_legacy import validate_adopted_generation
+        return validate_adopted_generation(path, support)
+    npz_sha = _sha(path)
+    if receipt.get("output") != str(path) or receipt.get("output_sha256") != npz_sha:
+        raise ValueError("generation output path/hash differs from receipt")
+    with np.load(path, allow_pickle=False) as z:
+        samples = z["sample_ids"].astype(str).tolist()
+        meta = json.loads(str(z["metadata_json"]))
+    if len(samples) != len(set(samples)) or not set(support["test_sample_ids"]) <= set(samples):
+        raise ValueError("generation sample IDs omit strict held-out samples")
+    if name not in ("raw", "refcal") and set(samples) != set(support["test_sample_ids"]):
+        raise ValueError("unit generation includes samples beyond strict test support")
+    if name in ("raw", "refcal"):
+        build_path = PLAN / "data/external_refcal" / support["cohort"] / "BUILD.json"
+        if not build_path.is_file():
+            raise ValueError("global external reference BUILD.json missing")
+        build = json.loads(build_path.read_text())
+        validate_global_build_inputs(build)
+        cond = PLAN / "data/external_refcal" / support["cohort"] / f"conditions_{name}.npz"
+        cond_sha = _sha(cond) if cond.is_file() else None
+        if (build.get("schema") != "pbisc.strict.external-reference.v1" or
+                build.get("cohort") != support["cohort"] or
+                build.get("target_sc_expression_accessed") is not False or
+                build.get("paired_target_samples_used") != 0 or
+                build.get("outputs", {}).get(str(cond)) != cond_sha or
+                not set(support["test_sample_ids"]) <= set(build.get("target_bulk_anchor_sample_ids", []))):
+            raise ValueError("global BUILD/condition metadata differs from external-reference protocol")
+        checkpoint_sha, checkpoint = BASE_SHA, BASE
+        source = str(build_path)
+    else:
+        conditions = _strict_conditions(support, rel)
+        cond_name = "test_cal.npz" if name == "pairedcal" else "test_raw.npz"
+        cond = PLAN / "data" / rel / cond_name
+        cond_sha = conditions["files_sha256"][cond_name]
+        checkpoint_sha, checkpoint = BASE_SHA, BASE
+        source = str(PLAN / "data" / rel / "CONDITIONS.json")
+        if name == "lora":
+            run_path = PLAN / "runs" / rel / "lora/RUN.json"
+            if not run_path.is_file():
+                raise ValueError("strict LoRA RUN.json missing")
+            run = json.loads(run_path.read_text())
+            validate_lora_run(run, support)
+            checkpoint = PLAN / "runs" / rel / "lora/checkpoint_ft.pt"
+            checkpoint_sha = run["checkpoint_sha256"]
+            if not checkpoint.is_file() or _sha(checkpoint) != checkpoint_sha:
+                raise ValueError("strict LoRA checkpoint differs from RUN.json")
+            source = str(run_path)
+        elif name == "scsemi":
+            work = PLAN / "scsemi" / rel
+            inputs_path = work / "inputs/inputs_manifest.json"
+            validation_path = path.with_suffix(".validation.json")
+            if not inputs_path.is_file() or not validation_path.is_file():
+                raise ValueError("strict scSemi inputs or export validation missing")
+            inputs, validation = json.loads(inputs_path.read_text()), json.loads(validation_path.read_text())
+            reps = [x["sample_id"] for x in inputs.get("representatives", [])]
+            if (inputs.get("mode") != "strict" or inputs.get("smoke") or
+                    inputs.get("support_sha256") != support["sha256"] or
+                    reps != support["train_sample_ids"] or
+                    inputs.get("targets") != support["test_sample_ids"] or
+                    inputs.get("train_donors") != support["train_donor_ids"] or
+                    inputs.get("n_representatives") != support["n_pairs"] or
+                    inputs.get("sources", {}).get("support.json") != _sha(PLAN / "protocol/splits" / rel / "support.json") or
+                    inputs.get("condition_sha256") != cond_sha or
+                    validation.get("passed") is not True or validation.get("npz_sha256") != npz_sha or
+                    receipt.get("run_signature") != meta.get("run_signature") or
+                    meta.get("work") != str(work)):
+                raise ValueError("scSemi export/work inputs differ from strict support")
+            source = str(inputs_path)
+            checkpoint_sha, checkpoint = None, None
+    if (receipt.get("condition_npz") != str(cond) or receipt.get("condition_sha256") != cond_sha or
+            meta.get("input_condition_path") != str(cond) or meta.get("input_condition_sha256") != cond_sha):
+        raise ValueError("generation condition differs from strict source")
+    if name != "scsemi" and (receipt.get("checkpoint") != str(checkpoint) or
+                              receipt.get("checkpoint_sha256") != checkpoint_sha or
+                              meta.get("checkpoint") != str(checkpoint) or
+                              meta.get("checkpoint_sha256") != checkpoint_sha):
+        raise ValueError("generation checkpoint differs from strict source")
+    if name == "scsemi" and (meta.get("representatives") != support["train_sample_ids"] or
+                              meta.get("train_donors") != support["train_donor_ids"] or meta.get("smoke")):
+        raise ValueError("scSemi metadata differs from strict representatives")
+    return {"arm": name, "npz": str(path), "npz_sha256": npz_sha,
+            "receipt": str(path.with_suffix(".log")), "receipt_sha256": _sha(path.with_suffix(".log")),
+            "source_binding": source, "source_binding_sha256": _sha(Path(source)),
+            "condition_npz": str(cond), "condition_sha256": cond_sha,
+            "checkpoint_sha256": checkpoint_sha, "support_sha256": support["sha256"]}
+
+
+def safe_out(path: Path) -> Path:
+    out = Path(path).resolve()
+    if not out.is_relative_to(PLAN.resolve()):
+        raise ValueError("--out must be within the strict-pairs plan directory")
+    protected = ("protocol", "tools", "tests", "data", "figures", "manuscript", "deck", "backups", "source_data")
+    if out == PLAN.resolve() or any(out.is_relative_to((PLAN / part).resolve()) for part in protected):
+        raise ValueError("--out must be a dedicated result directory within the strict-pairs plan")
+    return out
+
+
+def extra_root(out: Path) -> Path:
+    return Path(out) / "extras"
+
+
+def contrast_root(out: Path) -> Path:
+    return Path(out) / "contrast"
+
+
+def _legacy_module(name: str):
+    if name in sys.modules:
+        return sys.modules[name]
+    spec = importlib.util.spec_from_file_location(name, TOOLS / f"{name}.py")
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def _arms(values: list[str]) -> list[str]:
+    names = set()
+    out = []
+    for value in values:
+        name, sep, raw = value.partition("=")
+        if name == "observed":
+            raise ValueError("arm name 'observed' is reserved for the real reference")
+        if sep != "=" or not name or not raw or not name.replace("_", "").replace("-", "").isalnum() or name in names:
+            raise ValueError(f"bad or duplicate --arm {value!r}")
+        names.add(name)
+        out.append(f"{name}={Path(raw).resolve()}")
+    return out
+
+
+def _existing_score(score: Path, support: dict, names: list[str]) -> dict:
+    binding = score.parent / "scoring_support.json"
+    rec = json.loads(binding.read_text()) if binding.is_file() else {}
+    if rec.get("support_sha256") != support["sha256"]:
+        raise ValueError("score support hash absent or different")
+    p = score / "summary.json"
+    if not p.is_file():
+        raise ValueError(f"score output missing: {p}; run --action score first")
+    summary = json.loads(p.read_text())
+    if summary.get("dataset") != support["cohort"] or set(summary.get("donors", [])) != set(support["test_sample_ids"]):
+        raise ValueError("score summary does not match strict support test samples")
+    if names and set(summary.get("arms", [])) != set(names):
+        raise ValueError("score summary arm names differ from requested arms")
+    bindings = rec.get("arm_bindings", {})
+    if set(bindings) != set(summary.get("arms", [])):
+        raise ValueError("score generation binding missing or has different arms")
+    for name in summary["arms"]:
+        scored = summary.get("per_arm", {}).get(name, {})
+        source = bindings[name]
+        if scored.get("npz_sha256") != source.get("npz_sha256") or scored.get("npz") != source.get("npz"):
+            raise ValueError(f"score generation binding differs for {name}")
+    return summary
+
+
+def _call_score(support: dict, out: Path, arms: list[str], a: argparse.Namespace) -> None:
+    if not arms:
+        raise ValueError("--action score requires --arm NAME=NPZ")
+    arm_bindings = {name: validate_generation_arm(name, Path(path), support)
+                    for name, path in (arm.split("=", 1) for arm in arms)}
+    score = out / "score"
+    score.mkdir(parents=True, exist_ok=True)
+    binding = out / "scoring_support.json"
+    if binding.is_file() and json.loads(binding.read_text()).get("support_sha256") != support["sha256"]:
+        raise ValueError("existing output belongs to a different support hash")
+    if (score / "summary.json").is_file():
+        existing = json.loads((score / "summary.json").read_text())
+        if (existing.get("dataset") != support["cohort"] or
+                set(existing.get("donors", [])) != set(support["test_sample_ids"]) or
+                set(existing.get("arms", [])) != set(arm_bindings)):
+            raise ValueError("existing score differs from requested strict support or arms")
+        for name, source in arm_bindings.items():
+            scored = existing.get("per_arm", {}).get(name, {})
+            if scored.get("npz_sha256") != source["npz_sha256"] or scored.get("npz") != source["npz"]:
+                raise ValueError(f"existing score differs from validated generation for {name}")
+    binding.write_text(json.dumps({"schema": "pbisc.paper.strict-score-binding.v1",
+                                   "support_sha256": support["sha256"],
+                                   "cohort": support["cohort"], "unit": support["unit"],
+                                   "test_sample_ids": support["test_sample_ids"],
+                                   "test_donor_ids": support["test_donor_ids"],
+                                   "arm_bindings": arm_bindings}, indent=2) + "\n")
+    if (score / "summary.json").is_file():
+        _existing_score(score, support, list(arm_bindings))
+        return
+    mapping = patient_mapping(support)
+    mapping.to_csv(out / "patient_mapping.csv", index=False)
+    donor_file = out / "test_sample_ids.txt"
+    donor_file.write_text("\n".join(support["test_sample_ids"]) + "\n")
+    argv = ["--dataset", support["cohort"], "--out", str(score), "--donors", str(donor_file),
+            "--threads", str(a.threads)]
+    for arm in arms:
+        argv += ["--arm", arm]
+    if a.reference:
+        argv += ["--reference", str(a.reference)]
+    if a.annot:
+        argv += ["--annot", str(a.annot)]
+    for condition in a.condition:
+        argv += ["--condition", condition]
+    if a.allow_no_receipt:
+        argv.append("--allow-no-receipt")
+    if support["cohort"] == "giroux2022":
+        exclude = LEGACY / "data/sex_linked_genes/sex_linked_genes_exclude.csv"
+        if not exclude.is_file():
+            raise ValueError(f"required Giroux sex-gene exclusion missing: {exclude}")
+        argv += ["--exclude-genes", str(exclude)]
+    groups = {
+        "ye2026_sepsis": ("adult_sepsis,ped_sepsis", "adult_HC,adult_ICU_ctrl,ped_HC,ped_ICU_ctrl"),
+        "ji2025_chili": ("TOL,FU1", "BC,AC"),
+        "imperial_eskd": ("covid_positive", "covid_negative"),
+        "giroux2022": ("severe", "mild"),
+    }
+    if support["cohort"] in groups:
+        case, ctrl = groups[support["cohort"]]
+        argv += ["--case-groups", case, "--control-groups", ctrl]
+    else:
+        argv += ["--no-contrast", "--no-deg"]
+    if a.reuse_labels:
+        argv += ["--reuse-labels", str(a.reuse_labels)]
+    previous_argv = sys.argv
+    try:
+        sys.argv = [str(TOOLS / "score_ft.py"), *argv]
+        _legacy_module("score_ft").main(argv)
+    finally:
+        sys.argv = previous_argv
+    _existing_score(score, support, [x.split("=", 1)[0] for x in arms])
+
+
+def _call_extra(kind: str, support: dict, out: Path, arms: list[str], threads: int) -> None:
+    score = out / "score"
+    names = [x.split("=", 1)[0] for x in arms]
+    summary = _existing_score(score, support, names)
+    names = summary["arms"]
+    mod = _legacy_module("extra_metrics" if kind == "extras" else "contrast_extra")
+    root = extra_root(out) if kind == "extras" else contrast_root(out)
+    mod.OUT_ROOT = root
+    mod.SCORED.clear()
+    # Scored-mode paths are all rooted at OUT_ROOT; no legacy output tree is touched.
+    argv = ["--design", "scored", "--dataset", support["cohort"], "--score-dir", str(score),
+            "--arms", ",".join(names), "--unit", "strict", "--threads", str(threads),
+            "--fetch-dir", str(root / "_fetch_tmp")]
+    mod.main(argv)
+
+
+def _automatic_deg(support: dict, out: Path, summary: dict, threads: int) -> dict:
+    """Rebuild scored per-sample×type counts from the same legacy sources/readout.
+
+    This is bounded one arm and one cell type at a time.  The legacy scorer's
+    DEG outputs remain available for comparison; these fits are independent
+    corrected outputs and use the explicit support patient map.
+    """
+    import donor_statistics as DS
+
+    F = _legacy_module("ft_common")
+    S = _legacy_module("score_ft")
+    cache = Path(summary["reference"]["cache"])
+    ref, man = F.load_reference(cache)
+    if man["reference_sha256"] != summary["reference"]["reference_sha256"]:
+        raise ValueError("reference cache differs from scored reference")
+    deg = F.load_deg_reference(cache, man, ref)
+    sample_ids = np.asarray(summary["donors"], dtype=str)
+    pos = {x: i for i, x in enumerate(ref["donors"].astype(str))}
+    if any(x not in pos for x in sample_ids):
+        raise ValueError("scored sample absent from DEG reference")
+    sel_ref = np.asarray([pos[x] for x in sample_ids], dtype=int)
+    patient_of = dict(zip(support["test_sample_ids"], support["test_donor_ids"]))
+    donors = np.asarray([patient_of[x] for x in sample_ids], dtype=str)
+    conditions = np.asarray(summary["contrast_definition"]["groups"], dtype=str)
+    if conditions.shape != sample_ids.shape:
+        raise ValueError("contrast groups do not align with scored samples")
+    gene_ids = ref["score_ids"].astype(str)
+    keep = np.ones(len(gene_ids), bool)
+    exclusion = summary.get("gene_exclusion")
+    if support["cohort"] == "giroux2022" and not exclusion:
+        raise ValueError("Giroux DEG requires the recorded sex-gene exclusion")
+    if exclusion:
+        path = Path(exclusion["file"])
+        if not path.is_file() or F.sha(path) != exclusion["sha256"]:
+            raise ValueError("recorded gene exclusion file changed")
+        keep, _ = S.gene_exclusion(path, gene_ids.tolist())
+    genes = gene_ids[keep]
+    dest = out / "statistics" / "donor_deg"
+    dest.mkdir(parents=True, exist_ok=True)
+    pd.DataFrame({"gene_id": genes}).to_csv(dest / "genes_kept.csv", index=False)
+    all_rows = []
+    for arm_name in summary["arms"]:
+        pa = summary["per_arm"][arm_name]
+        path = Path(pa["npz"])
+        if not path.is_file():
+            all_rows.append({"arm": arm_name, "status": "pending", "reason": f"generated NPZ missing: {path}"})
+            continue
+        arm = S.open_arm(arm_name, path, ref["panel_ids"].astype(str), allow_no_receipt=True)
+        if arm["sha256"] != pa["npz_sha256"]:
+            arm["d"].close()
+            raise ValueError(f"{arm_name}: generated NPZ differs from scored input")
+        try:
+            npos = {x: i for i, x in enumerate(arm["sample_ids"])}
+            if any(x not in npos for x in sample_ids):
+                raise ValueError(f"{arm_name}: scored sample absent from generated NPZ")
+            row_lists = [np.flatnonzero(arm["bulk_index"] == npos[x]) for x in sample_ids]
+            selected = np.concatenate(row_lists)
+            gen_d = np.repeat(np.arange(len(sample_ids)), [len(x) for x in row_lists])
+            cells = pd.read_parquet(out / "score" / "arms" / arm_name / "generated_cells.parquet",
+                                    columns=["npz_row", "donor", "label"])
+            if not np.array_equal(cells.npz_row.to_numpy(), selected) or not np.array_equal(
+                    cells.donor.astype(str).to_numpy(), sample_ids[gen_d]):
+                raise ValueError(f"{arm_name}: generated cell labels do not match scored NPZ rows")
+            # Exact legacy rule: integerise the whole NPZ first, then select
+            # scored rows.  The seed and chunk size are inherited, not retyped.
+            rates = np.ascontiguousarray(arm["d"]["generated_counts"], dtype=np.float32)
+            full = F.PR.poisson_integerise(rates, seed=F.POISSON_SEED, chunk_rows=4096)
+            del rates
+            Xg = full[selected][:, ref["score_idx"]].tocsr()[:, keep].tocsr()
+            del full
+            ag = F.type_aggregates(Xg, gen_d, cells.label.astype(str).to_numpy(), len(sample_ids),
+                                   types=tuple(deg["types"]))
+            del Xg
+            arm_dir = dest / arm_name
+            arm_dir.mkdir(parents=True, exist_ok=True)
+            for ti, celltype in enumerate(deg["types"]):
+                slug = re.sub(r"[^a-z0-9]+", "_", str(celltype).lower()).strip("_")
+                type_dir = arm_dir / slug
+                obs = DS.pseudobulk_rows_from_arrays(
+                    sample_ids=sample_ids, donors=donors, conditions=conditions, gene_ids=genes,
+                    celltype=str(celltype), side="observed", n_cells=deg["n"][sel_ref, ti],
+                    sums=deg["sum"][sel_ref, ti][:, keep])
+                generated = DS.pseudobulk_rows_from_arrays(
+                    sample_ids=sample_ids, donors=donors, conditions=conditions, gene_ids=genes,
+                    celltype=str(celltype), side=arm_name, n_cells=ag["n"][:, ti],
+                    sums=ag["sum"][:, ti])
+                table = DS.donor_condition_pseudobulk(pd.concat([obs, generated], ignore_index=True))
+                result = DS.run_donor_limma(table, type_dir,
+                                            case=",".join(summary["contrast_definition"]["case_groups"]),
+                                            control=",".join(summary["contrast_definition"]["control_groups"]),
+                                            threads=threads)
+                jobs = {j["side"]: j for j in result.get("jobs", [])}
+                o, g = jobs.get("observed", {}), jobs.get(arm_name, {})
+                okay = o.get("status") == "ok" and g.get("status") == "ok"
+                missing_population = obs.empty or generated.empty
+                if result.get("status") in ("pending", "partial_or_pending"):
+                    type_status = "pending"
+                elif okay:
+                    type_status = "ok"
+                elif missing_population or all(x.get("status", "not_estimable") in ("ok", "not_estimable")
+                                               for x in (o, g)):
+                    type_status = "not_estimable"
+                else:
+                    type_status = "pending"
+                row = {"arm": arm_name, "celltype": celltype,
+                       "status": type_status,
+                       "observed_status": o.get("status", "no_population" if obs.empty else "missing"),
+                       "generated_status": g.get("status", "no_population" if generated.empty else "missing"),
+                       "n_case_donors_observed": o.get("n_case_donors"),
+                       "n_control_donors_observed": o.get("n_control_donors"),
+                       "n_case_donors_generated": g.get("n_case_donors"),
+                       "n_control_donors_generated": g.get("n_control_donors"),
+                       "method_observed": o.get("method"), "method_generated": g.get("method"),
+                       "reason_observed": o.get("reason"), "reason_generated": g.get("reason"),
+                       "reason_fit": result.get("reason"),
+                       "reason_population": ("observed cell type absent" if obs.empty else
+                                             "generated cell type absent" if generated.empty else None)}
+                if okay:
+                    top_o, top_g = set(o.get("top50_gene_ids", [])), set(g.get("top50_gene_ids", []))
+                    row.update(top50_overlap_count=len(top_o & top_g),
+                               observed_top50_size=len(top_o), generated_top50_size=len(top_g))
+                all_rows.append(row)
+        finally:
+            arm["d"].close()
+    pd.DataFrame(all_rows).to_csv(dest / "donor_deg_summary.csv", index=False)
+    n_pending = sum(x["status"] == "pending" for x in all_rows)
+    n_not_estimable = sum(x["status"] == "not_estimable" for x in all_rows)
+    overall = ("partial_or_pending" if n_pending or not all_rows else
+               "complete_with_not_estimable" if n_not_estimable else "ok")
+    return {"status": overall,
+            "method": "donor_condition_pseudobulk_limma_duplicateCorrelation_if_repeated_condition",
+            "n_genes_kept": int(len(genes)), "rows": len(all_rows),
+            "n_pending": n_pending, "n_not_estimable": n_not_estimable,
+            "summary_csv": str(dest / "donor_deg_summary.csv")}
+
+
+def require_corrected_deg(result: dict) -> None:
+    if result.get("status") not in ("ok", "complete_with_not_estimable", "not_applicable"):
+        raise ValueError("donor-aware DEG pending; inspect statistics/status.json and donor_deg summary")
+
+
+def validate_draw_long(path: Path, current_support: dict, expected_arms: list[str] | tuple[str, ...]) -> pd.DataFrame:
+    """Read one other disease draw only after its support, score and generation binding agree."""
+    if (current_support.get("design") != "disease_existing_draw" or current_support.get("n_pairs") != 5 or
+            not re.fullmatch(r"draw\d+_n5", current_support.get("unit", ""))):
+        raise ValueError("--draw-long requires a current strict disease n=5 draw")
+    path = Path(path).resolve()
+    try:
+        parts = path.relative_to((PLAN / "scores").resolve()).parts
+    except ValueError as exc:
+        raise ValueError("--draw-long must be a canonical score statistics path") from exc
+    if len(parts) != 5 or parts[1] != "disease" or parts[3:] != ("statistics", "per_donor_long.csv") or not re.fullmatch(r"draw\d+", parts[2]):
+        raise ValueError("--draw-long must be a canonical disease score statistics path")
+    cohort, draw = parts[0], parts[2]
+    if cohort != current_support["cohort"]:
+        raise ValueError("--draw-long cohort differs from current cohort")
+    unit = f"{draw}_n5"
+    if unit == current_support["unit"]:
+        raise ValueError("--draw-long must be a distinct draw")
+    support_path = PLAN / "protocol/splits" / cohort / "disease" / draw / "support.json"
+    if not support_path.is_file():
+        raise ValueError("--draw-long canonical support missing")
+    other = read_support(support_path)
+    if (other.get("cohort") != cohort or other.get("design") != "disease_existing_draw" or
+            other.get("unit") != unit or other.get("n_pairs") != 5):
+        raise ValueError("--draw-long strict support cohort/unit/n=5 mismatch")
+    base = path.parents[1]
+    binding_path = base / "scoring_support.json"
+    if not binding_path.is_file():
+        raise ValueError("--draw-long generation binding missing")
+    binding = json.loads(binding_path.read_text())
+    if (binding.get("schema") != "pbisc.paper.strict-score-binding.v1" or
+            binding.get("support_sha256") != other["sha256"] or
+            binding.get("cohort") != cohort or binding.get("unit") != unit or
+            binding.get("test_sample_ids") != other["test_sample_ids"] or
+            binding.get("test_donor_ids") != other["test_donor_ids"]):
+        raise ValueError("--draw-long generation binding differs from support")
+    names = set(expected_arms)
+    if not names or set(binding.get("arm_bindings", {})) != names:
+        raise ValueError("--draw-long arms differ from current score")
+    score = _existing_score(base / "score", other, list(names))
+    if set(score["arms"]) != names:
+        raise ValueError("--draw-long arms differ from current score")
+    for name, source in binding["arm_bindings"].items():
+        if validate_generation_arm(name, Path(source["npz"]), other) != source:
+            raise ValueError(f"--draw-long generation provenance differs for {name}")
+    rows = pd.read_csv(path, dtype={"draw": str, "sample_id": str, "donor_id": str, "arm": str, "metric": str})
+    required = {"draw", "sample_id", "donor_id", "arm", "metric", "value"}
+    if not required <= set(rows):
+        raise ValueError(f"--draw-long missing {sorted(required - set(rows))}")
+    if (rows.empty or set(rows.draw) != {unit} or set(rows.arm) != names or
+            set(rows.sample_id) != set(other["test_sample_ids"]) or
+            rows.duplicated(["draw", "sample_id", "donor_id", "arm", "metric"]).any()):
+        raise ValueError("--draw-long rows differ from strict draw/sample/arm contract")
+    if any(set(group.sample_id) != set(other["test_sample_ids"]) for _, group in rows.groupby("arm")):
+        raise ValueError("--draw-long arm lacks strict test samples")
+    patient_of = dict(zip(other["test_sample_ids"], other["test_donor_ids"]))
+    if (rows.donor_id != rows.sample_id.map(patient_of)).any():
+        raise ValueError("--draw-long patient mapping differs from strict support")
+    import donor_statistics as DS
+    expected = DS.score_table_with_patients(pd.read_csv(base / "score/per_donor.csv"), patient_mapping(other), draw=unit)
+    keys = ["draw", "sample_id", "donor_id", "arm", "metric"]
+    got = rows.sort_values(keys).reset_index(drop=True)
+    want = expected.sort_values(keys).reset_index(drop=True)
+    if (len(got) != len(want) or not got[keys].equals(want[keys]) or
+            not np.isclose(pd.to_numeric(got.value, errors="coerce"),
+                           pd.to_numeric(want.value, errors="coerce"), rtol=1e-12, atol=0,
+                           equal_nan=True).all()):
+        raise ValueError("--draw-long differs from scored metrics")
+    rows.attrs["support_sha256"] = other["sha256"]
+    rows.attrs["unit"] = unit
+    return rows
+
+
+def validate_draw_longs(paths: list[Path], current_support: dict,
+                        expected_arms: list[str] | tuple[str, ...]) -> list[pd.DataFrame]:
+    seen = {current_support["unit"]}
+    tables = []
+    for path in paths:
+        rows = validate_draw_long(path, current_support, expected_arms)
+        unit = rows.attrs["unit"]
+        if unit in seen:
+            raise ValueError(f"duplicate draw in --draw-long: {unit}")
+        seen.add(unit)
+        tables.append(rows)
+    return tables
+
+
+def _call_stats(support: dict, out: Path, arms: list[str], a: argparse.Namespace) -> None:
+    import donor_statistics as DS
+    score = out / "score"
+    summary = _existing_score(score, support, [x.split("=", 1)[0] for x in arms])
+    dest = out / "statistics"
+    dest.mkdir(parents=True, exist_ok=True)
+    mapping = patient_mapping(support)
+    mapping.to_csv(dest / "patient_mapping.csv", index=False)
+    rows = DS.score_table_with_patients(pd.read_csv(score / "per_donor.csv"), mapping, draw=support["unit"])
+    rows.to_csv(dest / "per_donor_long.csv", index=False)
+    combined = [rows]
+    for other in validate_draw_longs(a.draw_long, support, summary["arms"]):
+        combined.append(other)
+    all_rows = pd.concat(combined, ignore_index=True)
+    if all_rows.duplicated(["draw", "sample_id", "donor_id", "arm", "metric"]).any():
+        raise ValueError("duplicate draw/sample/arm/metric across --draw-long inputs")
+    all_rows.to_csv(dest / "per_donor_long_all.csv", index=False)
+    baseline = a.baseline or summary["arms"][0]
+    if baseline not in summary["arms"]:
+        raise ValueError(f"baseline {baseline} absent from score arms")
+    corrected = DS.summarize_metrics(all_rows, baseline=baseline)
+    corrected.to_csv(dest / "donor_bootstrap_2000.csv", index=False)
+    status = {"schema": "pbisc.paper.strict-statistics.v1", "support_sha256": support["sha256"],
+              "bootstrap_unit": "unique_donor_all_visits_and_draws", "bootstrap_replicates": 2000,
+              "draws": sorted(all_rows.draw.astype(str).unique().tolist()),
+              "disease_deg": {"status": "pending", "reason": "no donor x cell-type per-sample count table supplied"}}
+    if a.pseudobulk_table:
+        raw = pd.read_csv(a.pseudobulk_table)
+        if not set(raw.sample_id.astype(str)) <= set(support["test_sample_ids"]):
+            raise ValueError("pseudobulk table contains samples outside strict test support")
+        raw = raw.merge(mapping, on="sample_id", how="left", suffixes=("", "_support"), validate="many_to_one")
+        if "donor_id_support" in raw:
+            if (raw.donor_id.astype(str) != raw.donor_id_support.astype(str)).any():
+                raise ValueError("pseudobulk donor mapping differs from support")
+            raw = raw.drop(columns="donor_id_support")
+        raw["donor_id"] = raw["donor_id"].astype(str)
+        agg = DS.donor_condition_pseudobulk(raw)
+        cd = summary["contrast_definition"]
+        if cd.get("enabled"):
+            status["disease_deg"] = DS.run_donor_limma(agg, dest / "donor_deg",
+                                                         case=",".join(cd["case_groups"]),
+                                                         control=",".join(cd["control_groups"]),
+                                                         threads=a.threads)
+        else:
+            status["disease_deg"] = {"status": "not_applicable", "reason": "no case/control contrast"}
+    elif summary["contrast_definition"].get("enabled"):
+        status["disease_deg"] = _automatic_deg(support, out, summary, a.threads)
+    else:
+        status["disease_deg"] = {"status": "not_applicable", "reason": "no case/control contrast"}
+    (dest / "status.json").write_text(json.dumps(status, indent=2) + "\n")
+    require_corrected_deg(status["disease_deg"])
+
+
+def main(argv: list[str] | None = None) -> int:
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument("--support-manifest", type=Path, required=True)
+    p.add_argument("--out", type=Path, required=True)
+    p.add_argument("--arm", action="append", default=[])
+    p.add_argument("--action", choices=("score", "extras", "contrast", "stats", "all"), required=True)
+    p.add_argument("--reference", type=Path)
+    p.add_argument("--annot", type=Path)
+    p.add_argument("--condition", action="append", default=[])
+    p.add_argument("--reuse-labels", type=Path)
+    p.add_argument("--pseudobulk-table", type=Path)
+    p.add_argument("--draw-long", type=Path, action="append", default=[],
+                   help="other strict draw statistics/per_donor_long.csv files to cluster jointly")
+    p.add_argument("--baseline")
+    p.add_argument("--allow-no-receipt", action="store_true")
+    p.add_argument("--threads", type=int, default=4)
+    a = p.parse_args(argv)
+    if not 1 <= a.threads <= 8:
+        p.error("--threads must be 1..8")
+    support = read_support(a.support_manifest)
+    out = safe_out(a.out)
+    arms = _arms(a.arm)
+    out.mkdir(parents=True, exist_ok=True)
+    for action in (("score", "extras", "contrast", "stats") if a.action == "all" else (a.action,)):
+        if action == "score":
+            _call_score(support, out, arms, a)
+        elif action in ("extras", "contrast"):
+            _call_extra(action, support, out, arms, a.threads)
+        else:
+            _call_stats(support, out, arms, a)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(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/support_manifest.py

@@ -0,0 +1,226 @@
+"""CPU-only, exact one-sample-per-donor support contract for strict paired runs."""
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+from datetime import datetime
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+SCHEMA = "pbisc.paper.strict-support.v1"
+
+
+def _digest(value: dict) -> str:
+    body = {k: v for k, v in value.items() if k != "sha256"}
+    return hashlib.sha256(json.dumps(body, sort_keys=True, separators=(",", ":"), allow_nan=False).encode()).hexdigest()
+
+
+def _rows(folds: pd.DataFrame) -> pd.DataFrame:
+    need = {"sample_id", "donor_id", "group", "fold"}
+    if not need <= set(folds):
+        raise ValueError(f"folds missing {sorted(need - set(folds))}")
+    f = folds.copy()
+    for col in ("sample_id", "donor_id", "group"):
+        if f[col].isna().any() or f[col].astype(str).str.strip().eq("").any():
+            raise ValueError(f"missing or empty {col}")
+        f[col] = f[col].astype(str)
+    if f.sample_id.duplicated().any():
+        raise ValueError("duplicate or missing sample IDs")
+    return f
+
+
+def _finish(cohort: str, design: str, unit: str, f: pd.DataFrame, train: list[str], test: list[str],
+            *, seed: int | None = None, selection_audit: list[dict] | None = None) -> dict:
+    by_sample = f.set_index("sample_id")
+    donors = [str(by_sample.loc[s, "donor_id"]) for s in train]
+    selected = set(donors)
+    excluded = sorted(set(f.loc[f.donor_id.isin(selected), "sample_id"]) - set(train))
+    m = {"schema": SCHEMA, "cohort": cohort, "design": design, "unit": unit,
+         "n_pairs": len(train), "train_sample_ids": train, "train_donor_ids": donors,
+         "test_sample_ids": test, "test_donor_ids": f.set_index("sample_id").loc[test, "donor_id"].astype(str).tolist(),
+         "excluded_sample_ids": excluded, "seed": seed, "selection_audit": selection_audit or []}
+    m["sha256"] = _digest(m)
+    validate_manifest(m, f)
+    return m
+
+
+def validate_manifest(m: dict, folds: pd.DataFrame) -> None:
+    f = _rows(folds)
+    if m.get("schema") != SCHEMA or m.get("sha256") != _digest(m):
+        raise ValueError("support schema or hash mismatch")
+    index = f.set_index("sample_id")
+    train = m.get("train_sample_ids", [])
+    donors = m.get("train_donor_ids", [])
+    test = m.get("test_sample_ids", [])
+    td = m.get("test_donor_ids", [])
+    exc = m.get("excluded_sample_ids", [])
+    if not train or len(train) != len(donors) or len(train) != m.get("n_pairs") or len(set(donors)) != len(donors):
+        raise ValueError("n_pairs requires one unique sample per unique donor")
+    if any(len(set(x)) != len(x) for x in (train, test, exc)):
+        raise ValueError("duplicate sample ID")
+    if not set(train + test + exc) <= set(index.index):
+        raise ValueError("unknown sample ID")
+    if set(train) & (set(test) | set(exc)) or set(test) & set(exc):
+        raise ValueError("training/test/excluded overlap")
+    if index.loc[train, "donor_id"].astype(str).tolist() != donors:
+        raise ValueError("train sample/donor mismatch")
+    if index.loc[test, "donor_id"].astype(str).tolist() != td:
+        raise ValueError("test sample/donor mismatch")
+    if set(donors) & set(td):
+        raise ValueError("test donor overlaps training")
+    if (index.loc[train + test, "fold"] < 0).any():
+        raise ValueError("identity-excluded row used")
+    all_selected = set(f.loc[f.donor_id.isin(donors), "sample_id"])
+    if set(exc) != all_selected - set(train):
+        raise ValueError("other selected-donor visits must be excluded")
+    if m.get("design") == "healthy_outerfold":
+        fold = int(m["unit"].split("fold")[1].split("_")[0])
+        expected = set(f.loc[f.fold == fold, "sample_id"])
+        if set(test) != expected or set(f.loc[f.sample_id.isin(train), "fold"]) & {fold}:
+            raise ValueError("healthy outer fold mismatch")
+    elif m.get("design") == "disease_existing_draw":
+        expected = set(f.loc[(f.fold >= 0) & ~f.donor_id.isin(donors), "sample_id"])
+        if set(test) != expected:
+            raise ValueError("disease test set mismatch")
+    else:
+        raise ValueError("unknown design")
+
+
+def build_healthy(folds: pd.DataFrame, fold: int, n: int, *, seed: int) -> dict:
+    f = _rows(folds)
+    if fold not in range(5) or n < 1:
+        raise ValueError("invalid fold or n")
+    pool = f[(f.fold >= 0) & (f.fold != fold)]
+    # One permutation per fold, reused for every n: prefixes are nested.
+    donor_ids = sorted(pool.donor_id.unique())
+    if n > len(donor_ids):
+        raise ValueError("n exceeds training donors")
+    order = np.random.default_rng(seed).permutation(donor_ids).tolist()
+    train = []
+    for donor in order[:n]:
+        visits = sorted(pool.loc[pool.donor_id == donor, "sample_id"])
+        if len(visits) != 1:
+            raise ValueError("healthy donor has multiple visits; explicit visit policy required")
+        train.append(visits[0])
+    test = f.loc[f.fold == fold, "sample_id"].tolist()
+    return _finish("immicro", "healthy_outerfold", f"fold{fold}_n{n}", f, train, test, seed=seed)
+
+
+def _time_key(value: object, cohort: str) -> tuple[float, str]:
+    s = str(value).strip()
+    try:
+        v = float(s)
+        if np.isfinite(v):
+            return v, s
+    except ValueError:
+        pass
+    match = re.fullmatch(r"(?:day|d|fu)[ _-]?(\d+(?:\.\d+)?)", s, re.I)
+    if match:
+        return float(match.group(1)), s
+    if cohort == "ji2025_chili" and s.upper() in ("BC", "AC", "TOL"):
+        return (1.0 if s.upper() == "AC" else 0.0), s
+    if s.lower() in ("none (single sample per donor)", "baseline"):
+        return 0.0, s
+    try:
+        return float(datetime.strptime(s, "%d/%m/%Y").date().toordinal()), s
+    except ValueError as exc:
+        raise ValueError(f"unparseable clinical time {s!r}") from exc
+
+
+def build_disease(folds: pd.DataFrame, pairs: pd.DataFrame, draw_donors: list[str], cohort: str, draw: int,
+                  *, strata_regex: str = "") -> dict:
+    f = _rows(folds)
+    if len(draw_donors) != 5 or len(set(draw_donors)) != 5:
+        raise ValueError("disease draw requires exactly five unique donors")
+    need = {"sample_id", "timepoint", "identity_pass"}
+    if not need <= set(pairs):
+        raise ValueError(f"pairs metadata missing {sorted(need - set(pairs))}")
+    p = pairs.copy()
+    p.sample_id = p.sample_id.astype(str)
+    if p.sample_id.duplicated().any():
+        raise ValueError("duplicate pairs metadata sample ID")
+    p = p.set_index("sample_id")
+    chosen, audit = [], []
+    for donor in draw_donors:
+        rows = f[(f.donor_id == str(donor)) & (f.fold >= 0)]
+        if rows.empty or not set(rows.sample_id) <= set(p.index):
+            raise ValueError(f"donor {donor}: missing usable pair metadata")
+        matches = rows.group.str.contains(strata_regex, regex=True) if strata_regex else pd.Series(True, index=rows.index)
+        stratum = bool(matches.any())
+        candidates = []
+        for _, row in rows.iterrows():
+            sid = row.sample_id
+            if "donor_id" in p and str(p.loc[sid, "donor_id"]) != str(donor):
+                raise ValueError(f"{sid}: pairs metadata donor mismatch")
+            if "group" in p and str(p.loc[sid, "group"]) != str(row.group):
+                raise ValueError(f"{sid}: pairs metadata group mismatch")
+            identity = p.loc[sid, "identity_pass"]
+            if not (isinstance(identity, (bool, np.bool_)) and bool(identity)) or bool(matches.loc[row.name]) != stratum:
+                continue
+            time_field = "sample_date" if cohort == "imperial_eskd" and "sample_date" in p else "timepoint"
+            value = p.loc[sid, time_field]
+            if pd.isna(value):
+                raise ValueError(f"{sid}: missing {time_field}; cannot rank visits on one clinical time axis")
+            key, raw = _time_key(value, cohort)
+            candidates.append({"sample_id": sid, "time_value": key, "time_raw": raw,
+                               "time_field": time_field, "group": row.group})
+        candidates.sort(key=lambda x: (x["time_value"], x["sample_id"]))
+        if not candidates:
+            raise ValueError(f"donor {donor}: no identity-passed visit in assigned stratum")
+        chosen.append(candidates[0]["sample_id"])
+        audit.append({"donor_id": str(donor), "assigned_stratum": stratum,
+                      "selected_sample_id": candidates[0]["sample_id"], "candidates": candidates})
+    test = f.loc[(f.fold >= 0) & ~f.donor_id.isin(draw_donors), "sample_id"].tolist()
+    return _finish(cohort, "disease_existing_draw", f"draw{draw}_n{len(chosen)}", f, chosen, test,
+                   selection_audit=audit)
+
+
+def write_manifest(path: Path, manifest: dict) -> None:
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("x") as stream:
+        json.dump(manifest, stream, indent=2, allow_nan=False)
+        stream.write("\n")
+
+
+def load_manifest(path: Path, folds: pd.DataFrame) -> dict:
+    m = json.loads(Path(path).read_text())
+    validate_manifest(m, folds)
+    return m
+
+
+def select_rows(manifest: dict, folds: pd.DataFrame) -> tuple[np.ndarray, np.ndarray]:
+    """Return exact training and test row indices in manifest order; no validation subset."""
+    validate_manifest(manifest, folds)
+    pos = {str(s): int(i) for i, s in enumerate(folds.sample_id)}
+    return (np.asarray([pos[s] for s in manifest["train_sample_ids"]], dtype=np.int64),
+            np.asarray([pos[s] for s in manifest["test_sample_ids"]], dtype=np.int64))
+
+
+def validate_existing_run(manifest: dict, run: dict, *, fixed_steps: int, lora_rank: int,
+                          source_checkpoint_sha256: str, condition_npz_sha256: str,
+                          lr: float, lora_alpha: float, warmup: int, batch_size: int,
+                          ema_decay: float, seed: int) -> None:
+    """Refuse a skip unless the existing checkpoint receipt matches the requested strict run."""
+    fields = (("support_sha256", manifest["sha256"]),
+              ("train_donor_ids", manifest["train_donor_ids"]),
+              ("inner_val_rows", []), ("fixed_steps", fixed_steps),
+              ("steps_run", fixed_steps), ("selected_step", fixed_steps),
+              ("mode", "lora"), ("source_checkpoint_sha256", source_checkpoint_sha256),
+              ("condition_npz_sha256", condition_npz_sha256), ("lr", lr),
+              ("warmup", warmup), ("batch_size", batch_size),
+              ("ema_decay", ema_decay), ("seed", seed))
+    for key, expected in fields:
+        if run.get(key) != expected:
+            raise ValueError(f"existing strict run mismatch: {key}")
+    if (run.get("trainable", {}).get("lora_rank") != lora_rank or
+            run.get("trainable", {}).get("lora_alpha") != lora_alpha):
+        raise ValueError("existing strict run mismatch: LoRA rank/alpha")
+    for key, expected in (("train_rows", manifest["train_sample_ids"]),
+                          ("test_rows_never_loaded_for_training", manifest["test_sample_ids"])):
+        actual = run.get(key, [])
+        if len(actual) != len(expected) or set(actual) != set(expected):
+            raise ValueError(f"existing strict run mismatch: {key}")

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

@@ -0,0 +1,26 @@
+"""Validate explicit, same-budget legacy reuse without claiming new GPU work."""
+import argparse
+import json
+from pathlib import Path
+from import_scsemi_legacy import validate_adopted_generation
+from score_strict import read_support
+from runtime import atomic_json
+
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument('--support-manifest', type=Path, required=True)
+    p.add_argument('--npz', type=Path, required=True)
+    p.add_argument('--out', type=Path, required=True)
+    a = p.parse_args()
+    binding = validate_adopted_generation(a.npz, read_support(a.support_manifest))
+    record = {'schema': 'pbisc.scsemi.verified-reuse.v1', 'state': 'completed',
+              'new_gpu_training_or_inference': False, 'binding': binding}
+    if a.out.exists() and json.loads(a.out.read_text()) != record:
+        raise ValueError('existing adoption verification differs')
+    if not a.out.exists():
+        atomic_json(a.out, record)
+
+
+if __name__ == '__main__':
+    main()