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/backups/preflight_rejected_v1/protocol/splits/ye2026_sepsis/disease/draw4/support.json

@@ -0,0 +1,254 @@
+{
+  "schema": "pbisc.paper.strict-support.v1",
+  "cohort": "ye2026_sepsis",
+  "design": "disease_existing_draw",
+  "unit": "draw4_n5",
+  "n_pairs": 5,
+  "train_sample_ids": [
+    "IC23",
+    "Skin-S142",
+    "Res-PS22",
+    "Abd-S102",
+    "Skin-S46"
+  ],
+  "train_donor_ids": [
+    "IC23",
+    "Skin-S142",
+    "Res-PS22",
+    "Abd-S102",
+    "Skin-S46"
+  ],
+  "test_sample_ids": [
+    "Abd-PS04",
+    "Abd-PS05",
+    "Abd-PS07",
+    "Abd-PS19",
+    "Abd-PS20",
+    "Abd-PS23",
+    "Abd-PS27",
+    "Abd-S103",
+    "Abd-S120",
+    "Abd-S123",
+    "Abd-S156",
+    "Abd-S39",
+    "Abd-S42",
+    "Abd-S47",
+    "Abd-S51",
+    "Abd-S54",
+    "Abd-S57",
+    "Abd-S66",
+    "Abd-S79",
+    "Abd-S83",
+    "Abd-S98",
+    "HC01",
+    "HC05",
+    "HC07",
+    "HC09",
+    "HC12",
+    "HC13",
+    "HC16",
+    "IC10",
+    "IC15",
+    "IC16",
+    "IC19",
+    "IC22",
+    "PHC01",
+    "PHC02",
+    "PHC03",
+    "PHC05",
+    "PIC01",
+    "PIC02",
+    "PIC04",
+    "PIC05",
+    "Res-PS02",
+    "Res-PS03",
+    "Res-PS12",
+    "Res-PS16",
+    "Res-PS21",
+    "Res-PS25",
+    "Res-PS26",
+    "Res-S10",
+    "Res-S125",
+    "Res-S127",
+    "Res-S136",
+    "Res-S139",
+    "Res-S146",
+    "Res-S149",
+    "Res-S150",
+    "Res-S164",
+    "Res-S166",
+    "Res-S174",
+    "Res-S177",
+    "Res-S184",
+    "Res-S19",
+    "Res-S26",
+    "Res-S40",
+    "Res-S77",
+    "Res-S87",
+    "Skin-S140",
+    "Skin-S152",
+    "Skin-S38",
+    "Skin-S43",
+    "Skin-S52",
+    "Skin-S74",
+    "Uri-S134",
+    "Uri-S147",
+    "Uri-S157",
+    "Uri-S20",
+    "Uri-S93"
+  ],
+  "test_donor_ids": [
+    "Abd-PS04",
+    "Abd-PS05",
+    "Abd-PS07",
+    "Abd-PS19",
+    "Abd-PS20",
+    "Abd-PS23",
+    "Abd-PS27",
+    "Abd-S103",
+    "Abd-S120",
+    "Abd-S123",
+    "Abd-S156",
+    "Abd-S39",
+    "Abd-S42",
+    "Abd-S47",
+    "Abd-S51",
+    "Abd-S54",
+    "Abd-S57",
+    "Abd-S66",
+    "Abd-S79",
+    "Abd-S83",
+    "Abd-S98",
+    "HC01",
+    "HC05",
+    "HC07",
+    "HC09",
+    "HC12",
+    "HC13",
+    "HC16",
+    "IC10",
+    "IC15",
+    "IC16",
+    "IC19",
+    "IC22",
+    "PHC01",
+    "PHC02",
+    "PHC03",
+    "PHC05",
+    "PIC01",
+    "PIC02",
+    "PIC04",
+    "PIC05",
+    "Res-PS02",
+    "Res-PS03",
+    "Res-PS12",
+    "Res-PS16",
+    "Res-PS21",
+    "Res-PS25",
+    "Res-PS26",
+    "Res-S10",
+    "Res-S125",
+    "Res-S127",
+    "Res-S136",
+    "Res-S139",
+    "Res-S146",
+    "Res-S149",
+    "Res-S150",
+    "Res-S164",
+    "Res-S166",
+    "Res-S174",
+    "Res-S177",
+    "Res-S184",
+    "Res-S19",
+    "Res-S26",
+    "Res-S40",
+    "Res-S77",
+    "Res-S87",
+    "Skin-S140",
+    "Skin-S152",
+    "Skin-S38",
+    "Skin-S43",
+    "Skin-S52",
+    "Skin-S74",
+    "Uri-S134",
+    "Uri-S147",
+    "Uri-S157",
+    "Uri-S20",
+    "Uri-S93"
+  ],
+  "excluded_sample_ids": [],
+  "seed": null,
+  "selection_audit": [
+    {
+      "donor_id": "IC23",
+      "assigned_stratum": false,
+      "selected_sample_id": "IC23",
+      "candidates": [
+        {
+          "sample_id": "IC23",
+          "time_value": 0.0,
+          "time_raw": "none (single sample per donor)",
+          "time_field": "timepoint",
+          "group": "adult_ICU_ctrl"
+        }
+      ]
+    },
+    {
+      "donor_id": "Skin-S142",
+      "assigned_stratum": true,
+      "selected_sample_id": "Skin-S142",
+      "candidates": [
+        {
+          "sample_id": "Skin-S142",
+          "time_value": 0.0,
+          "time_raw": "none (single sample per donor)",
+          "time_field": "timepoint",
+          "group": "adult_sepsis"
+        }
+      ]
+    },
+    {
+      "donor_id": "Res-PS22",
+      "assigned_stratum": true,
+      "selected_sample_id": "Res-PS22",
+      "candidates": [
+        {
+          "sample_id": "Res-PS22",
+          "time_value": 0.0,
+          "time_raw": "none (single sample per donor)",
+          "time_field": "timepoint",
+          "group": "ped_sepsis"
+        }
+      ]
+    },
+    {
+      "donor_id": "Abd-S102",
+      "assigned_stratum": true,
+      "selected_sample_id": "Abd-S102",
+      "candidates": [
+        {
+          "sample_id": "Abd-S102",
+          "time_value": 0.0,
+          "time_raw": "none (single sample per donor)",
+          "time_field": "timepoint",
+          "group": "adult_sepsis"
+        }
+      ]
+    },
+    {
+      "donor_id": "Skin-S46",
+      "assigned_stratum": true,
+      "selected_sample_id": "Skin-S46",
+      "candidates": [
+        {
+          "sample_id": "Skin-S46",
+          "time_value": 0.0,
+          "time_raw": "none (single sample per donor)",
+          "time_field": "timepoint",
+          "group": "adult_sepsis"
+        }
+      ]
+    }
+  ],
+  "sha256": "e72d06f5f4f5c10cf7fff8edaee1493e18c67dc4bbf65793eae6c984120cc4d2"
+}

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

@@ -0,0 +1,714 @@
+#!/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())
+    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/backups/ye2026_sepsis_initial_support_20261012/disease/draw0/support.json

@@ -0,0 +1,249 @@
+{
+  "schema": "pbisc.paper.strict-support.v1",
+  "cohort": "ye2026_sepsis",
+  "design": "disease_existing_draw",
+  "unit": "draw0_n5",
+  "n_pairs": 5,
+  "train_sample_ids": [
+    "HC07",
+    "Abd-S66",
+    "Res-S150",
+    "Skin-S74",
+    "Res-S77"
+  ],
+  "train_donor_ids": [
+    "HC07",
+    "Abd-S66",
+    "Res-S150",
+    "Skin-S74",
+    "Res-S77"
+  ],
+  "test_sample_ids": [
+    "Abd-PS04",
+    "Abd-PS05",
+    "Abd-PS07",
+    "Abd-PS19",
+    "Abd-PS20",
+    "Abd-PS23",
+    "Abd-PS27",
+    "Abd-S102",
+    "Abd-S103",
+    "Abd-S120",
+    "Abd-S123",
+    "Abd-S156",
+    "Abd-S39",
+    "Abd-S42",
+    "Abd-S47",
+    "Abd-S51",
+    "Abd-S54",
+    "Abd-S57",
+    "Abd-S79",
+    "Abd-S83",
+    "Abd-S98",
+    "HC01",
+    "HC05",
+    "HC09",
+    "HC12",
+    "HC13",
+    "HC16",
+    "IC10",
+    "IC15",
+    "IC16",
+    "IC19",
+    "IC22",
+    "IC23",
+    "PHC01",
+    "PHC02",
+    "PHC03",
+    "PHC05",
+    "PIC01",
+    "PIC02",
+    "PIC04",
+    "PIC05",
+    "Res-PS02",
+    "Res-PS03",
+    "Res-PS12",
+    "Res-PS16",
+    "Res-PS21",
+    "Res-PS22",
+    "Res-PS25",
+    "Res-PS26",
+    "Res-S10",
+    "Res-S125",
+    "Res-S127",
+    "Res-S136",
+    "Res-S139",
+    "Res-S146",
+    "Res-S149",
+    "Res-S164",
+    "Res-S166",
+    "Res-S174",
+    "Res-S177",
+    "Res-S184",
+    "Res-S19",
+    "Res-S26",
+    "Res-S40",
+    "Res-S87",
+    "Skin-S140",
+    "Skin-S142",
+    "Skin-S152",
+    "Skin-S38",
+    "Skin-S43",
+    "Skin-S46",
+    "Skin-S52",
+    "Uri-S134",
+    "Uri-S147",
+    "Uri-S157",
+    "Uri-S20",
+    "Uri-S93"
+  ],
+  "test_donor_ids": [
+    "Abd-PS04",
+    "Abd-PS05",
+    "Abd-PS07",
+    "Abd-PS19",
+    "Abd-PS20",
+    "Abd-PS23",
+    "Abd-PS27",
+    "Abd-S102",
+    "Abd-S103",
+    "Abd-S120",
+    "Abd-S123",
+    "Abd-S156",
+    "Abd-S39",
+    "Abd-S42",
+    "Abd-S47",
+    "Abd-S51",
+    "Abd-S54",
+    "Abd-S57",
+    "Abd-S79",
+    "Abd-S83",
+    "Abd-S98",
+    "HC01",
+    "HC05",
+    "HC09",
+    "HC12",
+    "HC13",
+    "HC16",
+    "IC10",
+    "IC15",
+    "IC16",
+    "IC19",
+    "IC22",
+    "IC23",
+    "PHC01",
+    "PHC02",
+    "PHC03",
+    "PHC05",
+    "PIC01",
+    "PIC02",
+    "PIC04",
+    "PIC05",
+    "Res-PS02",
+    "Res-PS03",
+    "Res-PS12",
+    "Res-PS16",
+    "Res-PS21",
+    "Res-PS22",
+    "Res-PS25",
+    "Res-PS26",
+    "Res-S10",
+    "Res-S125",
+    "Res-S127",
+    "Res-S136",
+    "Res-S139",
+    "Res-S146",
+    "Res-S149",
+    "Res-S164",
+    "Res-S166",
+    "Res-S174",
+    "Res-S177",
+    "Res-S184",
+    "Res-S19",
+    "Res-S26",
+    "Res-S40",
+    "Res-S87",
+    "Skin-S140",
+    "Skin-S142",
+    "Skin-S152",
+    "Skin-S38",
+    "Skin-S43",
+    "Skin-S46",
+    "Skin-S52",
+    "Uri-S134",
+    "Uri-S147",
+    "Uri-S157",
+    "Uri-S20",
+    "Uri-S93"
+  ],
+  "excluded_sample_ids": [],
+  "seed": null,
+  "selection_audit": [
+    {
+      "donor_id": "HC07",
+      "assigned_stratum": false,
+      "selected_sample_id": "HC07",
+      "candidates": [
+        {
+          "sample_id": "HC07",
+          "time_value": 0.0,
+          "time_raw": "none (single sample per donor)",
+          "group": "adult_HC"
+        }
+      ]
+    },
+    {
+      "donor_id": "Abd-S66",
+      "assigned_stratum": true,
+      "selected_sample_id": "Abd-S66",
+      "candidates": [
+        {
+          "sample_id": "Abd-S66",
+          "time_value": 0.0,
+          "time_raw": "none (single sample per donor)",
+          "group": "adult_sepsis"
+        }
+      ]
+    },
+    {
+      "donor_id": "Res-S150",
+      "assigned_stratum": true,
+      "selected_sample_id": "Res-S150",
+      "candidates": [
+        {
+          "sample_id": "Res-S150",
+          "time_value": 0.0,
+          "time_raw": "none (single sample per donor)",
+          "group": "adult_sepsis"
+        }
+      ]
+    },
+    {
+      "donor_id": "Skin-S74",
+      "assigned_stratum": true,
+      "selected_sample_id": "Skin-S74",
+      "candidates": [
+        {
+          "sample_id": "Skin-S74",
+          "time_value": 0.0,
+          "time_raw": "none (single sample per donor)",
+          "group": "adult_sepsis"
+        }
+      ]
+    },
+    {
+      "donor_id": "Res-S77",
+      "assigned_stratum": true,
+      "selected_sample_id": "Res-S77",
+      "candidates": [
+        {
+          "sample_id": "Res-S77",
+          "time_value": 0.0,
+          "time_raw": "none (single sample per donor)",
+          "group": "adult_sepsis"
+        }
+      ]
+    }
+  ],
+  "sha256": "50001727b112845775b888f60d16814332810fdf4b70f2a099ff3846b479089e"
+}

paper-releases/pbisc-diffusion/updates/20261012T130738Z-strictpairs-implementation/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/archive/20261012T130738Z-strictpairs-implementation/snapshot/backups/ye2026_sepsis_initial_support_20261012/disease/draw1/support.json

@@ -0,0 +1,249 @@
+{
+  "schema": "pbisc.paper.strict-support.v1",
+  "cohort": "ye2026_sepsis",
+  "design": "disease_existing_draw",
+  "unit": "draw1_n5",
+  "n_pairs": 5,
+  "train_sample_ids": [
+    "HC12",
+    "Uri-S134",
+    "Uri-S147",
+    "Res-S164",
+    "Res-S166"
+  ],
+  "train_donor_ids": [
+    "HC12",
+    "Uri-S134",
+    "Uri-S147",
+    "Res-S164",
+    "Res-S166"
+  ],
+  "test_sample_ids": [
+    "Abd-PS04",
+    "Abd-PS05",
+    "Abd-PS07",
+    "Abd-PS19",
+    "Abd-PS20",
+    "Abd-PS23",
+    "Abd-PS27",
+    "Abd-S102",
+    "Abd-S103",
+    "Abd-S120",
+    "Abd-S123",
+    "Abd-S156",
+    "Abd-S39",
+    "Abd-S42",
+    "Abd-S47",
+    "Abd-S51",
+    "Abd-S54",
+    "Abd-S57",
+    "Abd-S66",
+    "Abd-S79",
+    "Abd-S83",
+    "Abd-S98",
+    "HC01",
+    "HC05",
+    "HC07",
+    "HC09",
+    "HC13",
+    "HC16",
+    "IC10",
+    "IC15",
+    "IC16",
+    "IC19",
+    "IC22",
+    "IC23",
+    "PHC01",
+    "PHC02",
+    "PHC03",
+    "PHC05",
+    "PIC01",
+    "PIC02",
+    "PIC04",
+    "PIC05",
+    "Res-PS02",
+    "Res-PS03",
+    "Res-PS12",
+    "Res-PS16",
+    "Res-PS21",
+    "Res-PS22",
+    "Res-PS25",
+    "Res-PS26",
+    "Res-S10",
+    "Res-S125",
+    "Res-S127",
+    "Res-S136",
+    "Res-S139",
+    "Res-S146",
+    "Res-S149",
+    "Res-S150",
+    "Res-S174",
+    "Res-S177",
+    "Res-S184",
+    "Res-S19",
+    "Res-S26",
+    "Res-S40",
+    "Res-S77",
+    "Res-S87",
+    "Skin-S140",
+    "Skin-S142",
+    "Skin-S152",
+    "Skin-S38",
+    "Skin-S43",
+    "Skin-S46",
+    "Skin-S52",
+    "Skin-S74",
+    "Uri-S157",
+    "Uri-S20",
+    "Uri-S93"
+  ],
+  "test_donor_ids": [
+    "Abd-PS04",
+    "Abd-PS05",
+    "Abd-PS07",
+    "Abd-PS19",
+    "Abd-PS20",
+    "Abd-PS23",
+    "Abd-PS27",
+    "Abd-S102",
+    "Abd-S103",
+    "Abd-S120",
+    "Abd-S123",
+    "Abd-S156",
+    "Abd-S39",
+    "Abd-S42",
+    "Abd-S47",
+    "Abd-S51",
+    "Abd-S54",
+    "Abd-S57",
+    "Abd-S66",
+    "Abd-S79",
+    "Abd-S83",
+    "Abd-S98",
+    "HC01",
+    "HC05",
+    "HC07",
+    "HC09",
+    "HC13",
+    "HC16",
+    "IC10",
+    "IC15",
+    "IC16",
+    "IC19",
+    "IC22",
+    "IC23",
+    "PHC01",
+    "PHC02",
+    "PHC03",
+    "PHC05",
+    "PIC01",
+    "PIC02",
+    "PIC04",
+    "PIC05",
+    "Res-PS02",
+    "Res-PS03",
+    "Res-PS12",
+    "Res-PS16",
+    "Res-PS21",
+    "Res-PS22",
+    "Res-PS25",
+    "Res-PS26",
+    "Res-S10",
+    "Res-S125",
+    "Res-S127",
+    "Res-S136",
+    "Res-S139",
+    "Res-S146",
+    "Res-S149",
+    "Res-S150",
+    "Res-S174",
+    "Res-S177",
+    "Res-S184",
+    "Res-S19",
+    "Res-S26",
+    "Res-S40",
+    "Res-S77",
+    "Res-S87",
+    "Skin-S140",
+    "Skin-S142",
+    "Skin-S152",
+    "Skin-S38",
+    "Skin-S43",
+    "Skin-S46",
+    "Skin-S52",
+    "Skin-S74",
+    "Uri-S157",
+    "Uri-S20",
+    "Uri-S93"
+  ],
+  "excluded_sample_ids": [],
+  "seed": null,
+  "selection_audit": [
+    {
+      "donor_id": "HC12",
+      "assigned_stratum": false,
+      "selected_sample_id": "HC12",
+      "candidates": [
+        {
+          "sample_id": "HC12",
+          "time_value": 0.0,
+          "time_raw": "none (single sample per donor)",
+          "group": "adult_HC"
+        }
+      ]
+    },
+    {
+      "donor_id": "Uri-S134",
+      "assigned_stratum": true,
+      "selected_sample_id": "Uri-S134",
+      "candidates": [
+        {
+          "sample_id": "Uri-S134",
+          "time_value": 0.0,
+          "time_raw": "none (single sample per donor)",
+          "group": "adult_sepsis"
+        }
+      ]
+    },
+    {
+      "donor_id": "Uri-S147",
+      "assigned_stratum": true,
+      "selected_sample_id": "Uri-S147",
+      "candidates": [
+        {
+          "sample_id": "Uri-S147",
+          "time_value": 0.0,
+          "time_raw": "none (single sample per donor)",
+          "group": "adult_sepsis"
+        }
+      ]
+    },
+    {
+      "donor_id": "Res-S164",
+      "assigned_stratum": true,
+      "selected_sample_id": "Res-S164",
+      "candidates": [
+        {
+          "sample_id": "Res-S164",
+          "time_value": 0.0,
+          "time_raw": "none (single sample per donor)",
+          "group": "adult_sepsis"
+        }
+      ]
+    },
+    {
+      "donor_id": "Res-S166",
+      "assigned_stratum": true,
+      "selected_sample_id": "Res-S166",
+      "candidates": [
+        {
+          "sample_id": "Res-S166",
+          "time_value": 0.0,
+          "time_raw": "none (single sample per donor)",
+          "group": "adult_sepsis"
+        }
+      ]
+    }
+  ],
+  "sha256": "01f2ac75fba1c6d47daabd6b42f207f6920bd54c1ed463ed437e6fc7056e6a2a"
+}