Archive 4 checkpoints (1-4)

paper-releases/20260928/diffusion/data/source_prep/ye2026_sepsis/code/ye2026_assemble.py

@@ -0,0 +1,482 @@
+#!/usr/bin/env python3
+"""Assemble the Ye 2026 sepsis paired bulk <-> scRNA fine-tuning files (CPU only).
+
+Inputs (processing run, produced by ye2026_pipeline.py):
+  pairing/sc_gex_libraries_with_bulk_match.csv, bulk/GSE279448_htseq_counts/harmonized.h5ad,
+  bulk/bulk_source_counts.npz, singlecell/<GSM>/{canonical.h5ad, pseudobulk_per_published_sample.h5,
+  source_axis_pseudobulk.npz, cell_sex_gene_counts.npz, summary.json}
+Outputs (OUT):
+  features.npz, cells_panel6k.npz, cells_obs.parquet, samples.csv, pairs.csv,
+  identity_sex.csv, identity_expression.csv, MANIFEST.json (QC_REPORT.md is written by hand from these)
+
+Rows = accepted bulk<->sc pairs, ordered by bulk GSM. Retained cells = flag_conservative_review_pass
+(qc_core: >=200 genes, >=500 UMIs, <=20 % mito), the ImMicro definition. Identity checks are reported,
+never used to drop rows.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import shutil
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+import h5py
+import numpy as np
+import pandas as pd
+import scipy.sparse as sp
+from scipy.stats import rankdata
+
+if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+    raise SystemExit("run with CUDA_VISIBLE_DEVICES=''")
+
+DATALAKE = Path("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc")
+RUN = DATALAKE / "processing/ye2026_sepsis_v1_20260927"
+REFERENCE = DATALAKE / "processing/strict_qc_v1_20260913/reference"
+M8 = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion")
+OUT = M8 / "plans/paired_finetune_intradataset_20260927/data/ye2026_sepsis"
+POSITIONS = M8 / "artifacts/panel_ladder_floor01_1m_20260923/tiers/6k/gene_positions.npy"
+POSITIONS_SHA = "653ffa45ac519000baa41086c52408009391d6e68cfb218bc6a50d34163fcb24"
+SELECTED = POSITIONS.parent / "selected_genes.csv"
+TMP = RUN / "assemble_tmp"
+SEX_GENES = ["XIST", "RPS4Y1", "DDX3Y", "UTY", "KDM5D"]
+SEX_IDS = {"XIST": "ENSG00000229807", "RPS4Y1": "ENSG00000129824", "DDX3Y": "ENSG00000067048",
+           "UTY": "ENSG00000183878", "KDM5D": "ENSG00000012817"}
+Y_GENES = ["RPS4Y1", "DDX3Y", "UTY", "KDM5D"]
+TOP_N = 2000
+RESID_K = (10, 20, 30)  # k=10 is the primary residualised test; 20 and 30 are sensitivity
+
+
+def sha256_file(path: Path) -> str:
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        for block in iter(lambda: f.read(1 << 24), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+def text(values) -> np.ndarray:
+    return np.asarray([v.decode() if isinstance(v, bytes) else str(v) for v in values])
+
+
+def require(ok: bool, msg: str) -> None:
+    if not ok:
+        raise SystemExit(msg)
+
+
+def sex_call(xist_cpm: float, y_cpm: float) -> tuple[str, float]:
+    """female if log2(XIST+1)-log2(Ysum+1) > 2, male if < -2, else ambiguous."""
+    score = float(np.log2(xist_cpm + 1) - np.log2(y_cpm + 1))
+    return ("female" if score > 2 else "male" if score < -2 else "ambiguous"), score
+
+
+def spearman_matrix(a: np.ndarray, b: np.ndarray) -> np.ndarray:
+    """Spearman rho between every row of a and every row of b (average ranks)."""
+    from scipy.stats import rankdata
+    ra = rankdata(a, axis=1)
+    rb = rankdata(b, axis=1)
+    ra = (ra - ra.mean(1, keepdims=True)) / ra.std(1, keepdims=True)
+    rb = (rb - rb.mean(1, keepdims=True)) / rb.std(1, keepdims=True)
+    return ra @ rb.T / a.shape[1]
+
+
+def main() -> int:
+    t0 = datetime.now(timezone.utc)
+    require(sha256_file(POSITIONS) == POSITIONS_SHA, "gene_positions.npy sha differs from the final run's")
+    positions = np.load(POSITIONS).astype(np.int64)
+    canonical = pd.read_csv(REFERENCE / "canonical_genes.tsv", sep="\t", dtype=str)
+    gene_ids = canonical.gene_id.to_numpy().astype("U15")
+    require(gene_ids.dtype.kind == "U" and all(len(x) == 15 for x in gene_ids), "gene id dtype")
+    require(len(gene_ids) == 20097 and canonical.panel_index.astype(int).tolist() == list(range(20097)), "axis")
+    selected = pd.read_csv(SELECTED)
+    require(np.array_equal(selected.gene_id.to_numpy(), gene_ids[positions]), "panel ids differ from positions")
+
+    table = pd.read_csv(RUN / "pairing/sc_gex_libraries_with_bulk_match.csv", dtype=str, keep_default_na=False)
+    summaries = {}
+    for gsm in table.sc_gsm:
+        s = json.loads((RUN / "singlecell" / gsm / "summary.json").read_text())
+        summaries[gsm] = s
+    bad = [g for g, s in summaries.items() if s["status"] != "PASS"]
+    pairs = table[table.paired == "True"].copy()
+    quarantined_pairs = sorted(set(bad) & set(pairs.sc_gsm))
+    pairs = pairs[~pairs.sc_gsm.isin(bad)].sort_values("bulk_gsm").reset_index(drop=True)
+    n = len(pairs)
+
+    # ---------------- bulk (canonical, harmonized by qc_bulk.harmonize)
+    import anndata as ad
+    bad_ = ad.read_h5ad(RUN / "bulk/GSE279448_htseq_counts/harmonized.h5ad")
+    bX = np.asarray(bad_.X, dtype=np.float64)
+    b_valid = np.asarray(bad_.layers["harmonization_valid"]).astype(bool)
+    b_index = bad_.obs_names.to_numpy().astype(str)
+    b_gsm = bad_.obs["source_GSM"].astype(str).to_numpy()
+    require(np.array_equal(bad_.var_names.to_numpy().astype(str), gene_ids), "bulk gene order")
+    require(str(bad_.uns["units"]) == "htseq_count_raw_gene_counts", "bulk units")
+    del bad_
+    brow = {g: i for i, g in enumerate(b_gsm)}
+    require(len(brow) == len(b_gsm), "duplicate bulk GSM")
+    inside = bX[b_valid]
+    require(np.isfinite(inside).all() and (inside >= 0).all() and np.array_equal(inside, np.rint(inside)),
+            "bulk values inside the measured mask must be nonnegative integers")
+    require(np.isnan(bX[~b_valid]).all(), "bulk values outside the mask must be NaN in the harmonized file")
+    bulk_all = np.where(b_valid, bX, 0.0)
+
+    # ---------------- sc per library: pseudobulk sums and masks for every PASS library
+    sc_gsms = [g for g in table.sc_gsm if summaries[g]["status"] == "PASS"]
+    sc_sum = np.zeros((len(sc_gsms), 20097))
+    sc_valid_all = np.zeros((len(sc_gsms), 20097), dtype=bool)
+    sc_n = np.zeros(len(sc_gsms), dtype=np.int64)
+    for i, g in enumerate(sc_gsms):
+        with h5py.File(RUN / "singlecell" / g / "pseudobulk_per_published_sample.h5", "r") as f:
+            require(np.array_equal(text(f["gene_id"][:]), gene_ids), f"{g}: gene order")
+            require(len(f["sample_id"]) == 1, f"{g}: exactly one sample per library")
+            require(f.attrs["units"] == "UMI_counts", f"{g}: units")
+            sc_sum[i] = f["qc_review_pass_cells_sum"][0]
+            sc_valid_all[i] = f["harmonization_valid"][:].astype(bool)
+            sc_n[i] = int(f["n_cells"][1, 0])
+        require(np.array_equal(sc_sum[i], np.rint(sc_sum[i])) and (sc_sum[i] >= 0).all(), f"{g}: noninteger sum")
+        require((sc_sum[i][~sc_valid_all[i]] == 0).all(), f"{g}: mass outside the measured mask")
+    srow = {g: i for i, g in enumerate(sc_gsms)}
+
+    # ---------------- per-pair feature rows
+    bi = np.asarray([brow[g] for g in pairs.bulk_gsm])
+    si = np.asarray([srow[g] for g in pairs.sc_gsm])
+    require(np.array_equal(b_index[bi], pairs.bulk_sample_id.to_numpy()), "bulk sample id join")
+    bulk_raw = bulk_all[bi]
+    bulk_valid = b_valid[bi]
+    pseudo_raw_sum = sc_sum[si]
+    sc_valid = sc_valid_all[si]
+    qc_cell_counts = sc_n[si]
+
+    # ---------------- sex check (source axis; XIST is not protein-coding)
+    bsrc = np.load(RUN / "bulk/bulk_source_counts.npz")
+    bids = list(bsrc["gene_ids"])
+    bcounts = bsrc["counts"]
+    bcpm = bcounts / bcounts.sum(1, keepdims=True) * 1e6
+    b_src_gsm = list(bsrc["gsm"])
+    sex_rows = []
+    for g in sc_gsms:
+        z = np.load(RUN / "singlecell" / g / "source_axis_pseudobulk.npz")
+        fid = list(z["feature_ids"])
+        tot = z["qc_pass_sum"][z["rna"]].sum()
+        rec = {"sc_gsm": g}
+        for gene in SEX_GENES:
+            rec["sc_" + gene + "_cpm"] = float(z["qc_pass_sum"][fid.index(SEX_IDS[gene])] / tot * 1e6)
+        rec["sc_Ysum_cpm"] = sum(rec["sc_" + x + "_cpm"] for x in Y_GENES)
+        rec["sc_sex_call"], rec["sc_sex_score"] = sex_call(rec["sc_XIST_cpm"], rec["sc_Ysum_cpm"])
+        sex_rows.append(rec)
+    sc_sex = pd.DataFrame(sex_rows).set_index("sc_gsm")
+    bulk_sex_rows = []
+    for j, g in enumerate(b_src_gsm):
+        rec = {"bulk_gsm": g}
+        for gene in SEX_GENES:
+            rec["bulk_" + gene + "_cpm"] = float(bcpm[j, bids.index(SEX_IDS[gene])])
+        rec["bulk_Ysum_cpm"] = sum(rec["bulk_" + x + "_cpm"] for x in Y_GENES)
+        rec["bulk_sex_call"], rec["bulk_sex_score"] = sex_call(rec["bulk_XIST_cpm"], rec["bulk_Ysum_cpm"])
+        bulk_sex_rows.append(rec)
+    bulk_sex = pd.DataFrame(bulk_sex_rows).set_index("bulk_gsm")
+
+    # ---------------- expression identity: every paired bulk vs every sc pseudobulk (retained cells)
+    common = b_valid.all(0) & sc_valid_all.all(0)
+
+    def logcpm(m: np.ndarray) -> np.ndarray:
+        x = m[:, common]
+        return np.log2(x / x.sum(1, keepdims=True) * 1e6 + 1)
+
+    lb_all, ls_all = logcpm(bulk_all), logcpm(sc_sum)
+    mean_score = 0.5 * (lb_all.mean(0) + ls_all.mean(0))
+    top = np.argsort(-mean_score, kind="mergesort")[:TOP_N]
+    rho = spearman_matrix(lb_all[bi][:, top], ls_all[:, top])                 # paired bulks x all sc
+    rho_rev = spearman_matrix(ls_all[si][:, top], lb_all[:, top])             # paired sc x all bulks
+    cb = lb_all - lb_all.mean(0)
+    cs = ls_all - ls_all.mean(0)
+    rho_c = spearman_matrix(cb[bi][:, top], cs[:, top])                       # modality-centred sensitivity
+    rho_c_rev = spearman_matrix(cs[si][:, top], cb[:, top])
+    expr = []
+    for r in range(n):
+        own = si[r]
+        order = np.argsort(-rho[r]); order_c = np.argsort(-rho_c[r])
+        rev = np.argsort(-rho_rev[r]); rev_c = np.argsort(-rho_c_rev[r])
+        expr.append({"sample_id": pairs.bulk_sample_id[r], "bulk_gsm": pairs.bulk_gsm[r], "sc_gsm": pairs.sc_gsm[r],
+                     "rho_own": rho[r, own], "best_sc_gsm": sc_gsms[order[0]], "rho_best": rho[r, order[0]],
+                     "own_rank_among_sc": int(np.flatnonzero(order == own)[0]) + 1,
+                     "best_is_own": bool(order[0] == own),
+                     "rho_second": rho[r, order[1]],
+                     "centred_rho_own": rho_c[r, own], "centred_best_sc_gsm": sc_gsms[order_c[0]],
+                     "centred_own_rank_among_sc": int(np.flatnonzero(order_c == own)[0]) + 1,
+                     "centred_best_is_own": bool(order_c[0] == own),
+                     "reverse_best_bulk_gsm": b_gsm[rev[0]], "reverse_own_rank_among_bulk": int(np.flatnonzero(rev == bi[r])[0]) + 1,
+                     "reverse_best_is_own": bool(rev[0] == bi[r]),
+                     "centred_reverse_best_bulk_gsm": b_gsm[rev_c[0]],
+                     "centred_reverse_own_rank_among_bulk": int(np.flatnonzero(rev_c == bi[r])[0]) + 1,
+                     "centred_reverse_best_is_own": bool(rev_c[0] == bi[r])})
+    expr = pd.DataFrame(expr)
+
+    # Residualised donor-identity test (unsupervised w.r.t. pairing): within each modality centre log CPM,
+    # remove the top-k sample principal components (shared disease-state / composition axes, computed on
+    # expressed genes), keep the 2,000 genes with the highest residual variance in both modalities, Pearson.
+    expressed = (lb_all.mean(0) > 3) & (ls_all.mean(0) > 1)
+    ex = np.flatnonzero(expressed)
+
+    def resid(x: np.ndarray, k: int) -> np.ndarray:
+        xc = x - x.mean(0)
+        u = np.linalg.svd(xc[:, ex], full_matrices=False)[0][:, :k]
+        return xc - u @ (u.T @ xc)
+
+    def pearson_matrix(a: np.ndarray, b: np.ndarray) -> np.ndarray:
+        a = (a - a.mean(1, keepdims=True)) / a.std(1, keepdims=True)
+        b = (b - b.mean(1, keepdims=True)) / b.std(1, keepdims=True)
+        return a @ b.T / a.shape[1]
+
+    for k in RESID_K:
+        rb_, rs_ = resid(lb_all, k), resid(ls_all, k)
+        vb = np.where(expressed, rb_.var(0), -1.0); vs = np.where(expressed, rs_.var(0), -1.0)
+        sel = np.argsort(rankdata(-vb) + rankdata(-vs), kind="mergesort")[:TOP_N]
+        fw = pearson_matrix(rb_[bi][:, sel], rs_[:, sel]); bw = pearson_matrix(rs_[si][:, sel], rb_[:, sel])
+        c1, c2, c3, c4, c5 = [], [], [], [], []
+        for r in range(n):
+            o = np.argsort(-fw[r]); o2 = np.argsort(-bw[r])
+            c1.append(int(np.flatnonzero(o == si[r])[0]) + 1); c2.append(int(np.flatnonzero(o2 == bi[r])[0]) + 1)
+            c3.append(sc_gsms[o[0]]); c4.append(float(fw[r, si[r]])); c5.append(float(fw[r, o[0]]))
+        expr[f"resid_k{k}_own_rank_bulk_to_sc"] = c1
+        expr[f"resid_k{k}_own_rank_sc_to_bulk"] = c2
+        expr[f"resid_k{k}_best_sc_gsm"] = c3
+        expr[f"resid_k{k}_r_own"] = c4
+        expr[f"resid_k{k}_r_best"] = c5
+
+    # ---------------- cells on the 6k panel (two passes: per-library temp files, then one CSR)
+    TMP.mkdir(exist_ok=True)
+    nnz_per, obs_blocks = [], []
+    for r in range(n):
+        g = pairs.sc_gsm[r]
+        h5 = RUN / "singlecell" / g / "canonical.h5ad"
+        with h5py.File(h5, "r") as f:
+            X = f["X"]
+            ncell = len(X["indptr"]) - 1
+            full = sp.csr_matrix((X["data"][:], X["indices"][:], X["indptr"][:]), shape=(ncell, 20097))
+            o = f["obs"]
+            keep = o["flag_conservative_review_pass"][:].astype(bool)
+            obs = pd.DataFrame({"cell_index": np.arange(ncell), "barcode": text(o["_index"][:]),
+                                "raw_gex_total": o["cell_total"][:], "n_genes": o["cell_detected"][:],
+                                "mito_pct": o["cell_mito_percent"][:],
+                                "flag_low_total_mad": o["flag_low_total_mad"][:].astype(bool),
+                                "flag_low_genes_mad": o["flag_low_genes_mad"][:].astype(bool),
+                                "flag_high_mito_mad": o["flag_high_mito_mad"][:].astype(bool),
+                                "flag_high_total_review_only": o["flag_high_total_review_only"][:].astype(bool)})
+            require(np.array_equal(text(o["sample_id"][:]), np.full(ncell, pairs.bulk_sample_id[r])), f"{g}: sample id")
+        require(int(keep.sum()) == qc_cell_counts[r], f"{g}: retained-cell count differs from pseudobulk file")
+        kept = full[np.flatnonzero(keep)]
+        require(np.array_equal(np.asarray(kept.sum(0)).ravel(), pseudo_raw_sum[r]), f"{g}: canonical sum differs")
+        sub = kept[:, positions].tocsr()
+        sub.sort_indices()
+        require(np.array_equal(sub.data, np.rint(sub.data)) and (sub.data >= 0).all() and
+                (sub.data.max(initial=0) < 2**31), f"{g}: non-integer or overflowing counts")
+        require(np.array_equal(np.asarray(sub.sum(0)).ravel(), pseudo_raw_sum[r, positions]), f"{g}: panel sum")
+        np.save(TMP / f"{r:03d}_data.npy", sub.data.astype(np.int32))
+        np.save(TMP / f"{r:03d}_indices.npy", sub.indices.astype(np.int32))
+        np.save(TMP / f"{r:03d}_indptr.npy", sub.indptr.astype(np.int64))
+        sx = np.load(RUN / "singlecell" / g / "cell_sex_gene_counts.npz")
+        require(list(sx["genes"]) == SEX_GENES and sx["found"].all(), f"{g}: sex genes")
+        obs = obs[keep].reset_index(drop=True)
+        obs["cell_total_canonical"] = np.asarray(kept.sum(1)).ravel()
+        obs["lib_panel"] = np.asarray(sub.sum(1)).ravel()
+        for k, gene in enumerate(SEX_GENES):
+            obs[("xist" if gene == "XIST" else "y_" + gene)] = sx["counts"][k][keep]
+        obs["y_sum"] = obs[["y_" + x for x in Y_GENES]].sum(1)
+        obs.insert(2, "library_id", g)
+        obs.insert(3, "sample_id", pairs.bulk_sample_id[r])
+        obs.insert(4, "donor_id", pairs.bulk_sample_id[r])
+        obs.insert(5, "group", pairs.group[r])
+        obs["author_cell_type"] = ""
+        obs["row_sample"] = np.int32(r)
+        obs_blocks.append(obs)
+        nnz_per.append(sub.nnz)
+        print(f"{g} {pairs.bulk_sample_id[r]}: {sub.shape[0]} cells, nnz {sub.nnz}", flush=True)
+        del full, kept, sub
+    total_nnz = int(sum(nnz_per))
+    total_cells = int(qc_cell_counts.sum())
+    data = np.lib.format.open_memmap(TMP / "all_data.npy", mode="w+", dtype=np.int32, shape=(total_nnz,))
+    indices = np.lib.format.open_memmap(TMP / "all_indices.npy", mode="w+", dtype=np.int32, shape=(total_nnz,))
+    indptr = np.empty(total_cells + 1, dtype=np.int64)
+    indptr[0] = 0
+    at, cell_at = 0, 0
+    for r in range(n):
+        d = np.load(TMP / f"{r:03d}_data.npy"); ix = np.load(TMP / f"{r:03d}_indices.npy")
+        ip = np.load(TMP / f"{r:03d}_indptr.npy")
+        data[at:at + len(d)] = d
+        indices[at:at + len(d)] = ix
+        indptr[cell_at + 1:cell_at + len(ip)] = ip[1:] + at
+        at += len(d); cell_at += len(ip) - 1
+    require(at == total_nnz and cell_at == total_cells, "assembly size")
+    cobs = pd.concat(obs_blocks, ignore_index=True)
+    row_sample = cobs.row_sample.to_numpy(np.int32)
+    # Fail-closed re-check on the assembled matrix.
+    require(np.all(np.diff(row_sample) >= 0), "cells must be grouped by row")
+    require(np.array_equal(np.bincount(row_sample, minlength=n), qc_cell_counts), "assembled cell counts")
+    starts = np.concatenate([[0], np.cumsum(qc_cell_counts)])
+    for r in range(n):
+        a, b = indptr[starts[r]], indptr[starts[r + 1]]
+        s_r = np.bincount(indices[a:b], weights=data[a:b].astype(np.float64), minlength=len(positions))
+        require(np.array_equal(s_r, pseudo_raw_sum[r, positions]), f"row {r}: assembled panel sum differs")
+    require(np.all(np.diff(indptr) >= 0) and indptr[-1] == total_nnz, "indptr")
+
+    # ---------------- write
+    OUT.mkdir(parents=True, exist_ok=True)
+    meta_arrays = {
+        "gene_ids": gene_ids, "sample_ids": pairs.bulk_sample_id.to_numpy().astype(str),
+        "donor_ids": pairs.bulk_sample_id.to_numpy().astype(str), "groups": pairs.group.to_numpy().astype(str),
+        "bulk_raw": bulk_raw.astype(np.float64), "pseudo_raw_sum": pseudo_raw_sum.astype(np.float64),
+        "bulk_valid": bulk_valid, "sc_valid": sc_valid, "pair_valid": bulk_valid & sc_valid,
+        "qc_cell_counts": qc_cell_counts.astype(np.int64),
+        "bulk_gsm": pairs.bulk_gsm.to_numpy().astype(str), "sc_gsm": pairs.sc_gsm.to_numpy().astype(str),
+        "sc_title_sample_id": pairs.sc_sample_id.to_numpy().astype(str), "id_match": pairs.id_match.to_numpy().astype(str),
+        "sex_geo": pairs.sc_gender.to_numpy().astype(str), "age_geo": pairs.sc_age.to_numpy().astype(str),
+        "infection_source": pairs["sc_sepsis_infection_source"].to_numpy().astype(str),
+        "collection_site": pairs["sc_sample_collection_site"].to_numpy().astype(str),
+    }
+    panel_gene_ids = gene_ids[positions]
+    tmp = OUT / "cells_panel6k.npz.tmp"
+    with open(tmp, "wb") as h:
+        np.savez_compressed(h, data=data, indices=indices, indptr=indptr,
+                            shape=np.array([total_cells, len(positions)], dtype=np.int64), row_sample=row_sample,
+                            panel_gene_ids=panel_gene_ids, panel_measured=sc_valid[:, positions])
+    os.replace(tmp, OUT / "cells_panel6k.npz")
+    cobs.to_parquet(OUT / "cells_obs.parquet", index=False)
+    pd.DataFrame({"row": np.arange(n), "sample_id": meta_arrays["sample_ids"], "donor_id": meta_arrays["donor_ids"],
+                  "group": meta_arrays["groups"], "n_cells": qc_cell_counts}).to_csv(OUT / "samples.csv", index=False)
+
+    # pairs.csv with identity results
+    p = pairs.rename(columns={"bulk_sample_id": "sample_id"})[
+        ["sample_id", "bulk_gsm", "sc_gsm", "bulk_title", "sc_title", "id_match", "group", "sc_gender", "sc_age",
+         "sc_sepsis_infection_source", "sc_sample_collection_site"]].copy()
+    p.insert(3, "donor_id", p.sample_id)
+    p.insert(4, "row", np.arange(n))
+    p = p.rename(columns={"sc_gender": "sex_geo", "sc_age": "age_geo", "sc_sepsis_infection_source": "infection_source",
+                          "sc_sample_collection_site": "collection_site"})
+    p["timepoint"] = "none (single sample per donor)"
+    p["n_cells_library"] = [summaries[g]["n_cells"] for g in p.sc_gsm]
+    p["n_cells_retained"] = qc_cell_counts
+    for c in ("bulk_XIST_cpm", "bulk_Ysum_cpm", "bulk_sex_score", "bulk_sex_call"):
+        p[c] = bulk_sex.loc[p.bulk_gsm, c].to_numpy()
+    for c in ("sc_XIST_cpm", "sc_Ysum_cpm", "sc_sex_score", "sc_sex_call"):
+        p[c] = sc_sex.loc[p.sc_gsm, c].to_numpy()
+    geo = p.sex_geo.str.lower()
+    p["sex_concordant"] = (p.bulk_sex_call == p.sc_sex_call) & (p.sc_sex_call == geo)
+    p["bulk_possible_mixture"] = ((p.bulk_sex_call == "female") & (p.bulk_Ysum_cpm > 20)) | \
+                                 ((p.bulk_sex_call == "male") & (p.bulk_XIST_cpm > 50))
+    e = expr.set_index("bulk_gsm")
+    for c in ("rho_own", "rho_best", "own_rank_among_sc", "best_is_own", "best_sc_gsm", "centred_own_rank_among_sc",
+              "centred_best_is_own", "reverse_own_rank_among_bulk", "reverse_best_is_own"):
+        p["expr_" + c] = e.loc[p.bulk_gsm, c].to_numpy()
+    for k in RESID_K:
+        for c in ("own_rank_bulk_to_sc", "own_rank_sc_to_bulk", "best_sc_gsm", "r_own", "r_best"):
+            p[f"expr_resid_k{k}_{c}"] = e.loc[p.bulk_gsm, f"resid_k{k}_{c}"].to_numpy()
+    sc_name = dict(zip(table.sc_gsm, table.sc_sample_id))
+
+    def verdict(row) -> str:
+        """pass: sex concordant AND residualised (k=10) own pair ranked 1st in one direction and <=5th in the other.
+        fail: sex discordant, or own pair ranked >5th in both directions. Otherwise borderline."""
+        r1, r2 = row.expr_resid_k10_own_rank_bulk_to_sc, row.expr_resid_k10_own_rank_sc_to_bulk
+        issues = []
+        if not row.sex_concordant:
+            issues.append(f"sex bulk={row.bulk_sex_call} sc={row.sc_sex_call} geo={row.sex_geo.lower()}")
+        if min(r1, r2) > 5:
+            issues.append(f"expression: own pair rank {r1} (bulk->133 sc) and {r2} (sc->207 bulk); bulk best sc = "
+                          f"{sc_name[row.expr_resid_k10_best_sc_gsm]} ({row.expr_resid_k10_best_sc_gsm})")
+        if issues:
+            return "fail: " + "; ".join(issues)
+        if min(r1, r2) == 1 and max(r1, r2) <= 5:
+            return "pass"
+        return f"borderline: own pair rank {r1} (bulk->sc) and {r2} (sc->bulk)"
+    p["identity_check"] = p.apply(verdict, axis=1)
+    p["identity_pass"] = p.identity_check == "pass"
+    p["identity_notes"] = np.where(p.bulk_possible_mixture, "bulk has opposite-sex signal (possible minor admixture)", "")
+    p.to_csv(OUT / "pairs.csv", index=False)
+    require(np.array_equal(p.bulk_gsm.to_numpy(), meta_arrays["bulk_gsm"]), "pairs/features row order")
+    meta_arrays["identity_pass"] = p.identity_pass.to_numpy().astype(bool)
+    meta_arrays["identity_check"] = p.identity_check.to_numpy().astype(str)
+    meta_arrays["sex_bulk_expr"] = p.bulk_sex_call.to_numpy().astype(str)
+    meta_arrays["sex_sc_expr"] = p.sc_sex_call.to_numpy().astype(str)
+    tmp = OUT / "features.npz.tmp"
+    with open(tmp, "wb") as h:
+        np.savez_compressed(h, **meta_arrays)
+    os.replace(tmp, OUT / "features.npz")
+    bulk_sex.join(pd.Series(dict(zip(b_gsm, b_index)), name="sample_id")).to_csv(OUT / "identity_sex_bulk_all.csv")
+    sc_sex.join(table.set_index("sc_gsm")[["sc_sample_id", "sc_gender", "paired"]]).to_csv(OUT / "identity_sex_sc_all.csv")
+    expr.to_csv(OUT / "identity_expression.csv", index=False)
+
+    # unmatched lists
+    unmatched_sc = table[table.paired != "True"][["sc_gsm", "sc_sample_id", "group", "id_match"]]
+    unmatched_bulk = pd.read_csv(RUN / "pairing/bulk_without_sc.csv", dtype=str)
+
+    checks = {
+        "gene_positions_sha256_ok": True,
+        "panel_gene_ids_match_selected_genes_csv": True,
+        "bulk_integer_nonnegative_inside_mask": True,
+        "pseudo_raw_sum_equals_sum_of_retained_cells_full_axis": True,
+        "cells_panel_sums_equal_pseudo_raw_sum_positions_exactly": True,
+        "cells_per_row_equal_qc_cell_counts": True,
+        "no_sc_mass_outside_sc_valid": True,
+        "one_sample_id_per_library": True,
+        "sex_concordant_pairs": f"{int(p.sex_concordant.sum())}/{n}",
+        "expression_best_match_is_own_pair": f"{int(p.expr_best_is_own.sum())}/{n}",
+        "expression_best_match_is_own_pair_centred": f"{int(p.expr_centred_best_is_own.sum())}/{n}",
+        "expression_reverse_best_match_is_own_pair": f"{int(p.expr_reverse_best_is_own.sum())}/{n}",
+        "expression_residualised_k10_top1_bulk_to_sc": f"{int((p.expr_resid_k10_own_rank_bulk_to_sc == 1).sum())}/{n}",
+        "expression_residualised_k10_top1_sc_to_bulk": f"{int((p.expr_resid_k10_own_rank_sc_to_bulk == 1).sum())}/{n}",
+        "expression_residualised_k20_top1_bulk_to_sc": f"{int((p.expr_resid_k20_own_rank_bulk_to_sc == 1).sum())}/{n}",
+        "expression_residualised_k30_top1_bulk_to_sc": f"{int((p.expr_resid_k30_own_rank_bulk_to_sc == 1).sum())}/{n}",
+        "identity_check_pass": f"{int((p.identity_check == 'pass').sum())}/{n}",
+        "identity_check_fail": p[p.identity_check.str.startswith('fail')].sample_id.tolist(),
+        "identity_check_borderline": p[p.identity_check.str.startswith('borderline')].sample_id.tolist(),
+    }
+    manifest = {
+        "schema": "ye2026_sepsis_paired_ft_v1",
+        "written_utc": datetime.now(timezone.utc).isoformat(), "started_utc": t0.isoformat(),
+        "study": "Ye Q et al., Nat Immunol 2026 (doi 10.1038/s41590-025-02345-x); bulk GSE279448, scRNA GSE279452",
+        "rows": n, "row_order": "bulk GSM ascending", "pairs_by_group": p.group.value_counts().to_dict(),
+        "pairs_by_id_match": p.id_match.value_counts().to_dict(),
+        "cells": {"n_cells": total_cells, "nnz": total_nnz, "per_row_min": int(qc_cell_counts.min()),
+                  "per_row_median": float(np.median(qc_cell_counts)), "per_row_max": int(qc_cell_counts.max())},
+        "retained_cells_rule": "flag_conservative_review_pass = genes>=200 & UMIs>=500 & mito<=20% (qc_core, ImMicro definition); MAD flags are review-only columns",
+        "features_semantics": {
+            "bulk_raw": "htseq-count raw gene counts on the canonical axis; 0 where bulk_valid is False (ImMicro file uses NaN there)",
+            "pseudo_raw_sum": "sum of retained cells' UMI counts on the canonical axis; storage 0 where sc_valid is False",
+            "bulk_valid": "harmonization_valid from qc_bulk.harmonize (gene in the htseq table, unique mapping)",
+            "sc_valid": "harmonization_valid from qc_singlecell.canonical_export (gene in the 10x features table)",
+            "pair_valid": "bulk_valid & sc_valid", "donor_ids": "= sample_ids (one sample per donor; no time points)",
+            "groups": "GEO 'group' field: adult_sepsis, ped_sepsis, adult_HC, adult_ICU_ctrl, ped_HC, ped_ICU_ctrl",
+            "extra_keys": "bulk_gsm, sc_gsm, sc_title_sample_id, id_match, sex_geo, age_geo, infection_source, collection_site, identity_pass, identity_check, sex_bulk_expr, sex_sc_expr",
+            "timepoints": "not included: GEO has no visit/time field and each sample ID occurs once per series"},
+        "identity": {"sex_rule": "CPM on the source axis (bulk: htseq assigned genes; sc: retained cells, all RNA features); score=log2(XIST+1)-log2(RPS4Y1+DDX3Y+UTY+KDM5D+1); female>2, male<-2, else ambiguous; opposite-sex signal flag: female call with Y CPM>20 or male call with XIST CPM>50 (bulk)",
+                     "expression_rule": f"log2(CPM+1) over the {int(common.sum())} canonical genes measured in all 207 bulks and all {len(sc_gsms)} sc libraries; top {TOP_N} by the mean of the bulk-mean and sc-mean log CPM; Spearman of each paired bulk vs all {len(sc_gsms)} sc pseudobulks (retained cells); sensitivity: same after subtracting each modality's per-gene mean; reverse: each paired sc vs all 207 bulks",
+                     "expression_residualised_rule": "within each modality: centre log2(CPM+1) (same common genes), remove the top k sample PCs computed on expressed genes (bulk mean >3 and sc mean >1 log2 CPM), keep the 2000 genes with the highest residual variance in both modalities (rank sum), Pearson; paired bulk vs all sc and paired sc vs all 207 bulks; k=10 primary, 20/30 sensitivity. Uses no pairing information.",
+                     "verdict_rule": "pass = sex concordant (bulk, sc, GEO) and residualised k=10 own pair ranked 1st in one direction and <=5th in the other; fail = sex discordant or own pair >5th in both directions; else borderline",
+                     "policy": "reported only; no row dropped on identity results; features.npz carries identity_pass / identity_check"},
+        "checks": checks,
+        "excluded": {"quarantined_sc_libraries_among_pairs": quarantined_pairs,
+                     "sc_libraries_without_bulk": unmatched_sc.to_dict("records"),
+                     "bulk_samples_without_sc": unmatched_bulk[["gsm", "sample_id", "ch_group"]].to_dict("records")},
+        "inputs": {"gene_positions": {"path": str(POSITIONS), "sha256": POSITIONS_SHA},
+                   "selected_genes": {"path": str(SELECTED), "sha256": sha256_file(SELECTED)},
+                   "canonical_genes": {"path": str(REFERENCE / "canonical_genes.tsv"), "sha256": sha256_file(REFERENCE / "canonical_genes.tsv")},
+                   "bulk_harmonized": {"path": str(RUN / "bulk/GSE279448_htseq_counts/harmonized.h5ad"),
+                                       "sha256": sha256_file(RUN / "bulk/GSE279448_htseq_counts/harmonized.h5ad")},
+                   "sources": json.loads((RUN / "SOURCES.json").read_text())["files"]},
+        "code": {name: {"path": str(path), "sha256": sha256_file(path)} for name, path in [
+            ("assemble", Path(__file__).resolve()), ("pipeline", RUN / "code/ye2026_pipeline.py"),
+            ("run_step", RUN / "code/run_step.sh")] + [
+            ("bundle/" + q.name, q) for q in sorted((RUN / "code/strict_qc_v1_code_bundle_v5").glob("*.py"))]},
+        "processing_dir": str(RUN),
+    }
+    manifest["outputs"] = {q.name: {"bytes": q.stat().st_size, "sha256": sha256_file(q)}
+                           for q in sorted(OUT.iterdir()) if q.is_file() and q.name not in ("MANIFEST.json", "QC_REPORT.md")}
+    (OUT / "MANIFEST.json").write_text(json.dumps(manifest, indent=1, default=str) + "\n")
+    shutil.rmtree(TMP)
+    print(json.dumps({"rows": n, "cells": manifest["cells"], "checks": checks}, indent=1))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/20260928/diffusion/data/source_prep/ye2026_sepsis/code/ye2026_findings.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+"""Evidence for study-level findings (CPU only): 10x chemistry, author pre-filtering, sex vs GEO.
+
+Writes RUN/FINDINGS.json and merges it into the deliverable MANIFEST.json as "findings".
+"""
+from __future__ import annotations
+
+import glob
+import gzip
+import json
+import os
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+    raise SystemExit("run with CUDA_VISIBLE_DEVICES=''")
+
+RUN = Path("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/processing/ye2026_sepsis_v1_20260927")
+OUT = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927/data/ye2026_sepsis")
+E = RUN / "extracted/GSE279452"
+
+table = pd.read_csv(RUN / "pairing/sc_gex_libraries_with_bulk_match.csv", dtype=str, keep_default_na=False)
+rows = []
+for r in table.itertuples():
+    bc = [l.strip() for l in gzip.open(E / r.barcodes_file, "rt")]
+    stem = r.barcodes_file.removesuffix(".barcodes.tsv.gz")
+    rec = {"sc_gsm": r.sc_gsm, "n_barcodes": len(bc), "first_barcode": bc[0],
+           "suffixes": sorted({b.split("-")[1] for b in bc})}
+    sid = stem.split("_", 1)[1]  # VDJ files sit under separate VDJ GSMs with the same sample ID
+    for chain in ("TCR", "BCR"):
+        found = sorted(E.glob(f"GSM*_{sid}.{chain}.filtered_contig_annotations.csv.gz"))
+        if len(found) != 1:
+            raise SystemExit(f"{sid}: expected one {chain} contig file, found {len(found)}")
+        vdj = set(pd.read_csv(found[0], usecols=["barcode"]).barcode)
+        rec[f"{chain}_cells"] = len(vdj)
+        rec[f"{chain}_cells_in_gex"] = len(vdj & set(bc))
+    rows.append(rec)
+chem = pd.DataFrame(rows)
+chem["TCR_frac_in_gex"] = chem.TCR_cells_in_gex / chem.TCR_cells.clip(lower=1)
+chem.to_csv(RUN / "chemistry_barcode_evidence.csv", index=False)
+
+libs = json.loads((RUN / "singlecell/SINGLECELL_SUMMARY.json").read_text())["libraries"]
+pre = pd.DataFrame([{**s["author_prefilter_evidence"], "sc_gsm": s["library_id"]} for s in libs])
+sx = pd.read_csv(OUT / "identity_sex_sc_all.csv")
+sxb = pd.read_csv(OUT / "identity_sex_bulk_all.csv")
+geo_b = pd.read_csv(RUN / "pairing/GSE279448_samples.csv", dtype=str).set_index("gsm").ch_gender.str.lower()
+sxb["geo"] = sxb.bulk_gsm.map(geo_b)
+feat_md5 = {__import__("hashlib").md5(gzip.open(E / f, "rb").read()).hexdigest() for f in table.features_file}
+
+findings = {
+    "sc_chemistry": {
+        "geo_statement": "GEX GSMs: '10xGenomics Single Cell 3' Library Gel Bead Kit V3.1'; VDJ GSMs: '10xGenomics Single Cell 5' RNA, VDJ Library Gel Bead Kit'",
+        "first_barcode_prefix_counts": chem.first_barcode.str[:7].value_counts().to_dict(),
+        "barcode_suffixes": sorted({s for x in chem.suffixes for s in x}),
+        "tcr_contig_cells_found_among_gex_barcodes": {"median": float(chem.TCR_frac_in_gex.median()),
+                                                      "min": float(chem.TCR_frac_in_gex.min()),
+                                                      "pooled": float(chem.TCR_cells_in_gex.sum() / chem.TCR_cells.sum())},
+        "conclusion": ("GEX barcodes come from the 737K-august-2016 whitelist (every library's sorted first barcode starts "
+                       "AAACCTG; 3' v3/v3.1 uses the 3M-february-2018 list) and nearly all TCR contig cells are GEX "
+                       "cells. The GEX was therefore captured in the same 5' GEM reaction as the V(D)J libraries: 10x 5' "
+                       "gene expression, not 3' v3.1 as the GEO GEX records state."),
+        "mtx_header": "cellranger-6.1.1 (MatrixMarket metadata_json)",
+        "features_file_identical_across_libraries": len(feat_md5) == 1,
+    },
+    "author_filtering": {
+        "cells_total_133_libraries": int(pre.cells.sum()),
+        "cells_below_500_umi": int(pre.counts_lt_500.sum()),
+        "cells_at_or_below_200_genes": int(pre.genes_le_200.sum()),
+        "cells_at_or_above_20pct_mito": int(pre.mito_ge_20.sum()),
+        "cells_at_or_above_2x_median_genes": int(pre.genes_ge_2x_median.sum()),
+        "conclusion": ("GEO matrices are Cell Ranger cell-called barcodes (no cell under 500 UMIs) but NOT the authors' "
+                       "Seurat-filtered set: cells violating the stated MT%<20, genes>200 and genes<2x median rules remain."),
+    },
+    "sex_vs_geo": {
+        "sc_all_libraries_discordant": sx[(sx.sc_sex_call != sx.sc_gender.str.lower())][["sc_gsm", "sc_sample_id", "sc_gender", "sc_sex_call"]].to_dict("records"),
+        "bulk_all_samples_discordant_or_ambiguous": sxb[(sxb.bulk_sex_call != sxb.geo)][["bulk_gsm", "sample_id", "geo", "bulk_sex_call", "bulk_XIST_cpm", "bulk_Ysum_cpm"]].to_dict("records"),
+    },
+}
+(RUN / "FINDINGS.json").write_text(json.dumps(findings, indent=1, default=str) + "\n")
+manifest = json.loads((OUT / "MANIFEST.json").read_text())
+manifest["findings"] = findings
+manifest["code"]["findings"] = {"path": str(Path(__file__).resolve()),
+                                "sha256": __import__("hashlib").sha256(Path(__file__).read_bytes()).hexdigest()}
+(OUT / "MANIFEST.json").write_text(json.dumps(manifest, indent=1, default=str) + "\n")
+print(json.dumps(findings, indent=1, default=str))

paper-releases/20260928/diffusion/data/source_prep/ye2026_sepsis/code/ye2026_pipeline.py

@@ -0,0 +1,453 @@
+#!/usr/bin/env python3
+"""Ye et al. 2026 sepsis PBMC bulk (GSE279448) + scRNA (GSE279452) processing.
+
+CPU only; never imports torch or initializes CUDA.
+
+Reuses the frozen ImMicro strict-QC code bundle v5 VERBATIM (copied to
+code/strict_qc_v1_code_bundle_v5, sha256 verified against its MANIFEST):
+  * qc_core.extract_archive / scan_mtx  (safe extraction, streaming MTX audit,
+    cell flags: min_genes 200, min_counts 500, max mito 20 %, 5-MAD outliers)
+  * qc_genes.GeneMapper                  (frozen 20,097-gene GENCODE v49 axis,
+    identifier mapping with ambiguity/conflict quarantine)
+  * qc_singlecell.read_axes / canonical_export (canonical sparse H5AD,
+    measured-gene masks, per-sample SUM pseudobulk of all / review-pass cells)
+  * qc_bulk.from_assembled / harmonize  (bulk canonical matrix, NaN +
+    source_feature_present/harmonization_valid layers)
+Only the study-specific glue (GEO title parsing, htseq parsing, per-library
+obs construction) is new and lives in this file.
+
+Subcommands: sources | extract | pairing | bulk | sc
+"""
+from __future__ import annotations
+
+import argparse
+import gzip
+import hashlib
+import json
+import os
+import re
+import sys
+import time
+from collections import defaultdict
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from datetime import datetime, timezone
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+DATALAKE = Path("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc")
+RAW = {"GSE279448": DATALAKE / "datasets/GSE279448", "GSE279452": DATALAKE / "datasets/GSE279452"}
+RUN = DATALAKE / "processing/ye2026_sepsis_v1_20260927"
+BUNDLE = RUN / "code/strict_qc_v1_code_bundle_v5"  # verbatim copy of strict_qc_v1_20260913/code_bundle_v5
+REFERENCE = DATALAKE / "processing/strict_qc_v1_20260913/reference"  # frozen; read only, sha-verified by GeneMapper
+RECEIPTS = DATALAKE / "acquisition/20260927/manifests/download_receipts.jsonl"
+sys.path.insert(0, str(BUNDLE))
+
+import qc_core  # noqa: E402
+import qc_genes  # noqa: E402
+
+GROUP_CODES = {"Adult Sepsis": "adult_sepsis", "Pediatric Sepsis": "ped_sepsis",
+               "Adult Healthy Control": "adult_HC", "Adult ICU Control": "adult_ICU_ctrl",
+               "Pediatric ICU Control": "ped_ICU_ctrl", "Pediatric Healthy Control": "ped_HC"}
+SEX_GENES = {"XIST": "ENSG00000229807", "RPS4Y1": "ENSG00000129824", "DDX3Y": "ENSG00000067048",
+             "UTY": "ENSG00000183878", "KDM5D": "ENSG00000012817"}
+META_FIELDS = ["ch_gender", "ch_age", "ch_group", "ch_sepsis infection_source", "ch_sample collection_site"]
+COUNT_EVIDENCE = ("Published per-GSM 10x Cell Ranger feature-barcode MTX (matrix/features/barcodes); "
+                  "GEO: 10x Single Cell 3' v3.1, 'Cellranger was utilized to calculate the raw counts'")
+
+
+def now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def log(event: dict) -> None:
+    event = {"t": now(), **event}
+    line = json.dumps(event, default=str)
+    print(line, flush=True)
+    with open(RUN / "events.jsonl", "a") as handle:
+        handle.write(line + "\n")
+
+
+def sha256(path: Path) -> str:
+    return qc_core.sha256_file(path)
+
+
+def verify_bundle() -> dict:
+    manifest = json.loads((BUNDLE / "MANIFEST.json").read_text())
+    for name, digest in manifest["files"].items():
+        if sha256(BUNDLE / name) != digest:
+            raise RuntimeError(f"Code bundle file changed: {name}")
+    return manifest
+
+
+# ----------------------------------------------------------------- sources
+def receipts() -> dict:
+    out = {}
+    for line in open(RECEIPTS):
+        rec = json.loads(line)
+        out[rec["local_path"]] = rec
+    return out
+
+
+def cmd_sources(_args) -> None:
+    """sha256 every acquired Ye 2026 file used here and compare with the acquisition receipt."""
+    verify_bundle()
+    known = receipts()
+    records = []
+    for acc, base in RAW.items():
+        for path in sorted(list((base / "raw").glob("*")) + list((base / "metadata").glob("*"))):
+            if not path.is_file() or path.name.endswith((".partial", ".tmp")):
+                continue
+            rec = {"accession": acc, "path": str(path), "bytes": path.stat().st_size, "sha256": sha256(path)}
+            receipt = known.get(str(path))
+            rec["acquisition_receipt"] = bool(receipt)
+            if receipt:
+                rec.update(url=receipt["url"], receipt_sha256=receipt["sha256"], receipt_bytes=receipt["bytes"],
+                           receipt_completed_at=receipt["completed_at"],
+                           matches_receipt=(receipt["sha256"] == rec["sha256"] and receipt["bytes"] == rec["bytes"]))
+                if not rec["matches_receipt"]:
+                    raise RuntimeError(f"Acquired file differs from its receipt: {path}")
+            records.append(rec)
+    qc_core._write_json(RUN / "SOURCES.json", {"created_at_utc": now(), "files": records,
+                                               "acquisition": "paired-datasets-20260927.service (read only; not modified)",
+                                               "receipts": str(RECEIPTS)})
+    log({"stage": "sources", "n_files": len(records),
+         "unreceipted": [r["path"] for r in records if not r["acquisition_receipt"]]})
+
+
+# ----------------------------------------------------------------- extract
+def cmd_extract(args) -> None:
+    for acc, base in RAW.items():
+        if args.acc and acc != args.acc:
+            continue
+        tar = base / "raw" / f"{acc}_RAW.tar"
+        receipt = receipts().get(str(tar))
+        if not receipt:
+            raise RuntimeError(f"No completed acquisition receipt yet for {tar}")
+        if tar.stat().st_size != receipt["bytes"] or sha256(tar) != receipt["sha256"]:
+            raise RuntimeError(f"Tar differs from acquisition receipt: {tar}")
+        dest = RUN / "extracted" / acc
+        receipt = qc_core.extract_archive(tar, dest, RUN / "extracted" / f"{acc}.extraction_receipt.json",
+                                          disk_floor_bytes=50 * 1024**3)
+        log({"stage": "extract", "accession": acc, "members": receipt["member_count"], "complete": receipt["complete"]})
+
+
+# ----------------------------------------------------------------- pairing
+def parse_soft(path: Path) -> pd.DataFrame:
+    samples, cur, section = [], None, None
+    with gzip.open(path, "rt", encoding="utf-8") as fh:
+        for line in fh:
+            line = line.rstrip("\n")
+            if line.startswith("^"):
+                section = line[1:].split(" = ")[0]
+                if section == "SAMPLE":
+                    cur = defaultdict(list)
+                    cur["gsm"] = [line.split(" = ")[1]]
+                    samples.append(cur)
+                continue
+            if section != "SAMPLE" or not line.startswith("!") or " = " not in line:
+                continue
+            key, val = line[1:].split(" = ", 1)
+            if key == "Sample_characteristics_ch1" and ": " in val:
+                k, v = val.split(": ", 1)
+                cur["ch_" + k.strip()].append(v.strip())
+            else:
+                cur[key].append(val)
+    return pd.DataFrame([{k: "|".join(v) for k, v in s.items()} for s in samples]).fillna("")
+
+
+def cmd_pairing(_args) -> None:
+    out = RUN / "pairing"
+    out.mkdir(parents=True, exist_ok=True)
+    bulk = parse_soft(RAW["GSE279448"] / "metadata/GSE279448_family.soft.gz")
+    sc = parse_soft(RAW["GSE279452"] / "metadata/GSE279452_family.soft.gz")
+    bulk.to_csv(out / "GSE279448_samples.csv", index=False)
+    sc.to_csv(out / "GSE279452_samples.csv", index=False)
+    if not bulk.Sample_title.str.match(r"^bulkRNA \S+$").all():
+        raise RuntimeError("Unexpected bulk title format")
+    bulk["sample_id"] = bulk.Sample_title.str.removeprefix("bulkRNA ")
+    files = sc.filter(like="Sample_supplementary_file").apply(lambda r: "|".join(r), axis=1)
+    sc["library_kind"] = np.where(files.str.contains(r"matrix\.mtx"), "GEX_3prime_v3.1_MTX",
+                                  np.where(files.str.contains("contig_annotations"), "VDJ_5prime_contigs", "other"))
+    if (sc.library_kind == "other").any():
+        raise RuntimeError("Unclassified scRNA GSM")
+    sc["sample_id"] = sc.Sample_title.str.removeprefix("scRNA ").str.removesuffix(" (VDJ)")
+    gex = sc[sc.library_kind == "GEX_3prime_v3.1_MTX"].copy()
+    vdj = sc[sc.library_kind == "VDJ_5prime_contigs"].copy()
+    for name, frame in (("bulk", bulk), ("gex", gex)):
+        if not frame.sample_id.is_unique:
+            raise RuntimeError(f"Duplicate {name} sample IDs")
+        if not frame.sample_id.str.upper().is_unique:
+            raise RuntimeError(f"Case-insensitive duplicate {name} sample IDs")
+    for kind in ("barcodes", "features", "matrix"):
+        gex[kind + "_file"] = files[gex.index].str.extract(r"(GSM\d+_[^|/]+\." + kind + r"\.(?:tsv|mtx)\.gz)")[0]
+    if gex[["barcodes_file", "features_file", "matrix_file"]].isna().any().any():
+        raise RuntimeError("GEX GSM missing one of barcodes/features/matrix")
+
+    def normalized(sid: str) -> str:
+        # Case-fold, and insert the 'S' patient-type letter if a source-prefixed ID lacks it.
+        m = re.fullmatch(r"(?i)(abd|res|skin|uri|cns)-(\d+)", sid)
+        return (m.group(1) + "-S" + m.group(2)).upper() if m else sid.upper()
+
+    bulk_by_exact = dict(zip(bulk.sample_id, bulk.index))
+    bulk_by_case = dict(zip(bulk.sample_id.str.upper(), bulk.index))
+    bulk_by_norm = dict(zip(bulk.sample_id.map(normalized), bulk.index))
+    rows, used_bulk = [], set()
+    for i, g in gex.iterrows():
+        sid = g.sample_id
+        if sid in bulk_by_exact:
+            j, how = bulk_by_exact[sid], "exact_title"
+        elif sid.upper() in bulk_by_case:
+            j, how = bulk_by_case[sid.upper()], "case_only_title_difference"
+        elif normalized(sid) in bulk_by_norm:
+            j, how = bulk_by_norm[normalized(sid)], "missing_S_letter_in_sc_title"
+        else:
+            j, how = None, "no_bulk"
+        rec = {"sc_gsm": g.gsm, "sc_title": g.Sample_title, "sc_sample_id": sid, "id_match": how}
+        if j is not None:
+            b = bulk.loc[j]
+            if b.gsm in used_bulk:
+                raise RuntimeError(f"Bulk {b.gsm} matched twice")
+            used_bulk.add(b.gsm)
+            mismatch = [f for f in META_FIELDS if b[f] != g[f]]
+            rec.update({"bulk_gsm": b.gsm, "bulk_title": b.Sample_title, "bulk_sample_id": b.sample_id,
+                        "metadata_mismatch_fields": ";".join(mismatch)})
+        for f in META_FIELDS:
+            rec["sc_" + f[3:].replace(" ", "_")] = g[f]
+        for kind in ("barcodes_file", "features_file", "matrix_file"):
+            rec[kind] = g[kind]
+        rows.append(rec)
+    table = pd.DataFrame(rows)
+    table["paired"] = table.bulk_gsm.notna() & (table.metadata_mismatch_fields.fillna("") == "")
+    # Canonical sample ID for the pair = bulk title ID (the complete, correctly cased form).
+    table["pair_sample_id"] = np.where(table.paired, table.bulk_sample_id, "")
+    table["group"] = table.sc_group.map(GROUP_CODES)
+    table.to_csv(out / "sc_gex_libraries_with_bulk_match.csv", index=False)
+    unmatched_bulk = bulk[~bulk.gsm.isin(used_bulk)][["gsm", "Sample_title", "sample_id"] + META_FIELDS]
+    unmatched_bulk.to_csv(out / "bulk_without_sc.csv", index=False)
+    vdj_check = sorted(set(vdj.sample_id) ^ set(gex.sample_id))
+    summary = {"bulk_gsms": len(bulk), "sc_gsms_total": len(sc), "sc_gex_gsms": len(gex), "sc_vdj_gsms": len(vdj),
+               "vdj_sample_ids_equal_gex_sample_ids": not vdj_check,
+               "pairs_by_id_match": table[table.paired].id_match.value_counts().to_dict(),
+               "pairs_total": int(table.paired.sum()),
+               "pairs_by_group": table[table.paired].group.value_counts().to_dict(),
+               "sc_without_bulk": table[~table.paired].sc_sample_id.tolist(),
+               "sc_without_bulk_by_group": table[~table.paired].group.value_counts().to_dict(),
+               "bulk_without_sc": len(unmatched_bulk),
+               "bulk_without_sc_by_group": unmatched_bulk.ch_group.map(GROUP_CODES).value_counts().to_dict(),
+               "metadata_mismatches_among_matches": int((table.metadata_mismatch_fields.fillna("") != "").sum()),
+               "timepoints": "none: every sample ID occurs once per series; GEO has no visit/time field",
+               "rule": ("sc GEX GSM title 'scRNA <ID>' joined to bulk title 'bulkRNA <ID>': exact ID first, then "
+                        "case-insensitive, then source-prefixed IDs with the missing 'S' patient-type letter restored; "
+                        "every accepted match must also agree on GEO sex, age, group, infection source and "
+                        "collection site. VDJ GSMs are separate 5' VDJ libraries and are not paired.")}
+    qc_core._write_json(out / "PAIRING_SUMMARY.json", summary)
+    log({"stage": "pairing", **{k: summary[k] for k in ("pairs_total", "pairs_by_id_match", "pairs_by_group")}})
+
+
+# ----------------------------------------------------------------- bulk
+def parse_htseq(path: Path):
+    sample, gsm = qc_bulk_sample_label(path)
+    frame = pd.read_csv(path, sep="\t", header=None, dtype={0: str}, keep_default_na=False)
+    if frame.shape[1] != 2:
+        raise ValueError(f"htseq table must have two columns: {path}")
+    ids = frame[0].astype(str)
+    counters = ids.str.startswith("__").to_numpy()
+    values = pd.to_numeric(frame[1], errors="raise").to_numpy(dtype=np.float64)
+    if not ids[~counters].is_unique:
+        raise ValueError(f"Duplicate gene IDs in htseq table: {path}")
+    meta = {"GSM": gsm, "file": str(path)}
+    for gid, value in zip(ids[counters], values[counters]):
+        meta["htseq" + gid] = float(value)
+    assigned = float(values[~counters].sum())
+    meta["htseq_assigned_gene_total"] = assigned
+    meta["htseq_no_feature_fraction_of_assigned_plus_nofeature_plus_ambiguous"] = (
+        meta.get("htseq__no_feature", 0.0) / (assigned + meta.get("htseq__no_feature", 0.0) + meta.get("htseq__ambiguous", 0.0)))
+    return sample, ids[~counters].tolist(), None, values[~counters], meta
+
+
+def qc_bulk_sample_label(path: Path):
+    import qc_bulk
+    return qc_bulk.sample_file_label(path, ".htseq.results")
+
+
+def cmd_bulk(_args) -> None:
+    import qc_bulk
+    verify_bundle()
+    mapper = qc_genes.GeneMapper(REFERENCE)
+    paths = sorted((RUN / "extracted/GSE279448").glob("GSM*.htseq.results.gz"))
+    if len(paths) != 207:
+        raise RuntimeError(f"Expected 207 htseq files, found {len(paths)}")
+    records = [parse_htseq(p) for p in paths]
+    # Keep a source-axis copy (needed for non-protein-coding XIST in sex checks).
+    ids0 = records[0][1]
+    same_axis = all(r[1] == ids0 for r in records)
+    if not same_axis:
+        raise RuntimeError("htseq feature axes differ between samples")
+    (RUN / "bulk").mkdir(exist_ok=True)
+    np.savez_compressed(RUN / "bulk/bulk_source_counts.npz",
+                        gene_ids=np.asarray(ids0), sample_ids=np.asarray([r[0] for r in records]),
+                        gsm=np.asarray([r[4]["GSM"] for r in records]),
+                        counts=np.vstack([r[3] for r in records]))
+    pd.DataFrame([{"sample_id": r[0], **r[4]} for r in records]).to_csv(RUN / "bulk/htseq_counters.csv", index=False)
+    assay = qc_bulk.from_assembled(
+        "GSE279448", "GSE279448_htseq_counts", "htseq_count_raw_gene_counts", records,
+        declared_raw_counts=True, sources=paths,
+        caveats=["GEO: PBMC total RNA (Trizol), 'standard Illumina protocols', NovaSeq 6000, HISAT2 2.0.4 to GRCh38, htseq-count; "
+                 "library kit, polyA/rRNA-depletion and htseq strandedness option are not stated.",
+                 "Five htseq '__' counter rows are kept in sample metadata, not in expression.",
+                 "Bulk-to-single-cell pairing is by published GEO sample titles; see pairing/."],
+        extra={"source_format": "htseq-count two-column per-GSM tables", "identical_feature_axis_all_samples": same_axis})
+    report = qc_bulk.harmonize(assay, mapper, RUN / "bulk" / assay.assay_id)
+    log({"stage": "bulk", "status": report["status"], "n_samples": report["n_samples"],
+         "raw_count_eligible": report["raw_count_eligible"], "canonical_coverage": report["canonical_coverage"]})
+
+
+# ----------------------------------------------------------------- single cell
+def process_library(row: dict) -> dict:
+    import qc_singlecell as qs
+    import scipy.io._fast_matrix_market as fmm
+    from scipy.io import mmread
+
+    fmm.PARALLELISM = 1  # single-threaded MTX reader (host CPU budget)
+
+    qs.COUNT_SOURCE_EVIDENCE["GSE279452"] = COUNT_EVIDENCE  # provenance string only
+    gsm, sid = row["sc_gsm"], row["sc_sample_id"]
+    base = RUN / "extracted/GSE279452"
+    out = RUN / "singlecell" / gsm
+    out.mkdir(parents=True, exist_ok=True)
+    summary_path = out / "summary.json"
+    if summary_path.exists() and json.loads(summary_path.read_text()).get("status") == "PASS":
+        return json.loads(summary_path.read_text())
+    item = {"accession": "GSE279452", "library_id": gsm, "path": str(base / row["matrix_file"]), "format": "mtx",
+            "duplicate_representation": False, "features_path": str(base / row["features_file"]),
+            "barcodes_path": str(base / row["barcodes_file"])}
+    summary = {**item, "sample_id_sc_title": sid, "status": "RUNNING", "output_dir": str(out), "started": now()}
+    qc_core._write_json(summary_path, summary)
+    t0 = time.time()
+    try:
+        mapper = qc_genes.GeneMapper(REFERENCE)
+        ids, symbols, cells, rna, axes = qs.read_axes(item)
+        item["matrix_path"] = axes["matrix_path"]
+        mapping = mapper.map_features(ids, symbols)
+        mapping_summary = mapper.write_rows(mapping, out / "gene_mapping")
+        mito = np.asarray([r["mitochondrial"] for r in mapping])
+        n = len(cells)
+        if len(set(cells)) != n:
+            raise qs.QCError("Duplicate barcodes within library")
+        pair_sid = row.get("pair_sample_id") or sid
+        obs = pd.DataFrame({"barcode": cells, "source_barcode": cells, "raw_10x_barcode": cells,
+                            "author_cell_id": "", "library_id": gsm, "donor_id": pair_sid, "sample_id": pair_sid,
+                            "visit_id": "", "author_retained": "unknown",
+                            "mapping_basis": "one 10x library per GEO GSM; sample ID from GEO title",
+                            "protocol": "10x_3prime_v3.1"})
+        obs.to_csv(out / "cell_metadata.csv.gz", index=False, compression="gzip")
+        metrics = out / "metrics"
+        if (metrics / "qc_summary.json").exists():
+            qc = json.loads((metrics / "qc_summary.json").read_text())
+        else:
+            qc = qc_core.scan_mtx(item["path"], metrics, mito_mask=mito, feature_mask=rna,
+                                  sample_ids=obs.sample_id.to_numpy(), feature_ids=ids,
+                                  feature_symbols=symbols, cell_ids=cells)
+        total = np.load(metrics / "cell_total.npy")
+        detected = np.load(metrics / "cell_detected.npy")
+        mito_pct = np.load(metrics / "cell_mito_percent.npy")
+        pd.DataFrame([{"min_genes": g, "min_abundance": 500, "max_mito_percent": m,
+                       "n_review_pass": int(((detected >= g) & (total >= 500) & (mito_pct <= m)).sum())}
+                      for g in (100, 200, 500) for m in (10, 20, 30)]).to_csv(out / "threshold_sensitivity.csv", index=False)
+        integral = qc["numeric"]["integer_fraction_selected_stored"] == 1
+        item["source_sha256"] = qc["input"].get("sha256", "")
+        item["canonical_identity_sha256"] = mapper.manifest.get("canonical_identity_sha256", "")
+        verified = bool(integral)
+        units = "UMI_counts" if verified else "nonnegative_abundance_source_units_unproven"
+        export = qs.canonical_export(item, out, mapping, mapper.canonical, obs, rna,
+                                     verified_counts=verified, units=units, full_mapping=True)
+        # Source-axis sums (all RNA features, incl. non-protein-coding XIST) for identity checks.
+        qcpass = np.load(metrics / "flag_conservative_review_pass.npy")
+        matrix = mmread(item["path"]).tocsc()
+        if matrix.shape != (len(ids), n):
+            raise qs.QCError("MTX shape changed")
+        all_sum = np.asarray(matrix.sum(axis=1)).ravel()
+        pass_sum = np.asarray(matrix[:, np.flatnonzero(qcpass)].sum(axis=1)).ravel()
+        if not np.isclose(all_sum[rna].sum(), total.sum(), rtol=1e-12):
+            raise qs.QCError("Source-axis sum differs from QC scan")
+        np.savez_compressed(out / "source_axis_pseudobulk.npz", feature_ids=np.asarray(ids),
+                            feature_symbols=np.asarray(symbols), rna=rna, all_cells_sum=all_sum,
+                            qc_pass_sum=pass_sum, n_cells=n, n_qc_pass=int(qcpass.sum()))
+        # Per-cell source counts of sex genes (XIST is not on the protein-coding canonical axis).
+        where = {g: i for i, g in enumerate(ids)}
+        sex_rows = [where.get(g, -1) for g in SEX_GENES.values()]
+        per_cell = np.zeros((len(SEX_GENES), n), dtype=np.float64)
+        csr = matrix.tocsr()
+        for k, r in enumerate(sex_rows):
+            if r >= 0:
+                per_cell[k] = csr[r].toarray().ravel()
+        np.savez_compressed(out / "cell_sex_gene_counts.npz", genes=np.asarray(list(SEX_GENES)),
+                            gene_ids=np.asarray(list(SEX_GENES.values())), found=np.asarray(sex_rows) >= 0,
+                            counts=per_cell)
+        del matrix, csr
+        # Author pre-filtering evidence (GEO: Seurat MT% < 20, genes > 200, genes < 2 x median).
+        median_genes = float(np.median(detected))
+        author = {"cells": n, "genes_le_200": int((detected <= 200).sum()), "mito_ge_20": int((mito_pct >= 20).sum()),
+                  "genes_ge_2x_median": int((detected >= 2 * median_genes).sum()), "median_genes": median_genes,
+                  "counts_lt_500": int((total < 500).sum()), "min_genes": int(detected.min()),
+                  "max_mito_pct": float(mito_pct.max())}
+        summary.update({"status": "PASS", "n_cells": n, "n_features": len(ids),
+                        "n_rna_features": int(rna.sum()), "n_qc_review_pass": int(qcpass.sum()),
+                        "flag_counts": qc["flag_counts"], "numeric": qc["numeric"], "units": units,
+                        "count_space_verified": verified, "count_provenance": COUNT_EVIDENCE,
+                        "canonicalcoverage": mapping_summary, "canonical_export": export,
+                        "author_prefilter_evidence": author, "seconds": round(time.time() - t0, 1),
+                        "finished": now()})
+    except Exception as error:  # noqa: BLE001 - recorded, not hidden
+        summary.update({"status": "QUARANTINED", "error_type": type(error).__name__, "error": str(error)})
+    qc_core._write_json(summary_path, summary)
+    return summary
+
+
+def cmd_sc(args) -> None:
+    verify_bundle()
+    table = pd.read_csv(RUN / "pairing/sc_gex_libraries_with_bulk_match.csv", dtype=str, keep_default_na=False)
+    rows = table.to_dict("records")
+    if args.only_paired:
+        rows = [r for r in rows if r["paired"] == "True"]
+    if args.gsm:
+        rows = [r for r in rows if r["sc_gsm"] in set(args.gsm.split(","))]
+    if args.limit:
+        rows = rows[:args.limit]
+    log({"stage": "sc", "event": "start", "n_libraries": len(rows), "workers": args.workers})
+    done = []
+    with ProcessPoolExecutor(max_workers=args.workers, max_tasks_per_child=1) as pool:
+        futures = {pool.submit(process_library, r): r["sc_gsm"] for r in rows}
+        for future in as_completed(futures):
+            s = future.result()
+            done.append(s)
+            log({"stage": "sc", "library": futures[future], "status": s["status"], "n_cells": s.get("n_cells"),
+                 "n_qc_review_pass": s.get("n_qc_review_pass"), "seconds": s.get("seconds"), "error": s.get("error")})
+    if not args.gsm and not args.limit:
+        qc_core._write_json(RUN / "singlecell/SINGLECELL_SUMMARY.json",
+                            {"created_at_utc": now(), "libraries": sorted(done, key=lambda s: s["library_id"])})
+    log({"stage": "sc", "event": "finish", "pass": sum(s["status"] == "PASS" for s in done), "n": len(done)})
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    sub = parser.add_subparsers(dest="cmd", required=True)
+    sub.add_parser("sources")
+    p = sub.add_parser("extract")
+    p.add_argument("--acc", default="")
+    sub.add_parser("pairing")
+    sub.add_parser("bulk")
+    p = sub.add_parser("sc")
+    p.add_argument("--workers", type=int, default=3)
+    p.add_argument("--limit", type=int, default=0)
+    p.add_argument("--only-paired", action="store_true")
+    p.add_argument("--gsm", default="", help="comma-separated GSM subset")
+    args = parser.parse_args()
+    RUN.mkdir(parents=True, exist_ok=True)
+    {"sources": cmd_sources, "extract": cmd_extract, "pairing": cmd_pairing, "bulk": cmd_bulk, "sc": cmd_sc}[args.cmd](args)
+
+
+if __name__ == "__main__":
+    main()

paper-releases/20260928/diffusion/data/source_provenance/giroux2022/FINDINGS.json

@@ -0,0 +1,332 @@
+{
+ "sc_chemistry": {
+  "geo_statement": "10X Genomics Single Cell 5' v1 chemistry; Cell Ranger count; assembly hg19",
+  "cellranger_version_from_mtx_header": [
+   "3.1.0"
+  ],
+  "first_sorted_barcode_prefix_counts": {
+   "AAACCTG": 41
+  },
+  "barcode_suffixes": [
+   "1"
+  ],
+  "features_table": "32,738 genes (Cell Ranger refdata hg19 1.2.0 style Ensembl IDs), identical content in all 41 libraries",
+  "conclusion": "consistent with GEO: every library's barcodes come from the 737K-august-2016 list (first sorted barcode AAACCTG), which 5' v1 uses; no contradiction found"
+ },
+ "author_filtering": {
+  "geo_statement": "Seurat: cells with > 5% mitochondrial reads or > 2,500 genes removed",
+  "cells_all_41_libraries": 472830,
+  "cells_paired_26_libraries": 284224,
+  "min_umis_any_cell": 500.0,
+  "min_genes_any_cell": 50,
+  "paired_cells_mito_gt_5pct": 88613,
+  "paired_cells_genes_gt_2500": 13168,
+  "paired_cells_author_rule_would_keep": 183798,
+  "paired_cells_retained_imMicro_rule": 276615,
+  "conclusion": "GEO matrices are Cell Ranger filtered barcodes with a 500-UMI floor, NOT the authors' Seurat-filtered cells; the ImMicro rule (>=200 genes, >=500 UMIs, <=20% mito) is used as for ImMicro and Ye 2026"
+ },
+ "bulk_gene_filtering": {
+  "author_table_rows": 26045,
+  "rows_matching_RPL_or_RPS_or_starting_MT_or_MRP": 0,
+  "canonical_genes_matching_pattern": 276,
+  "canonical_genes_lost": 275,
+  "only_measured_pattern_gene": [
+   "MRPL58"
+  ],
+  "panel6k_genes_lost_to_this_filter": 121,
+  "sc_umi_fraction_in_lost_genes_paired_rows": {
+   "median": 0.3573427675868265,
+   "min": 0.2169805649672231,
+   "max": 0.4196018126068366
+  },
+  "chrY_rows_present": [
+   "DDX3Y",
+   "UTY",
+   "KDM5D",
+   "EIF1AY",
+   "USP9Y",
+   "ZFY"
+  ],
+  "conclusion": "The author featureCounts table has no gene whose symbol contains RPL or RPS or starts with MT (ribosomal proteins, MRPL/MRPS, mitochondrial genes and e.g. MTOR were removed by name before deposit; ICT1 = MRPL58 survived under its old symbol). These genes are bulk_valid=False, not zero. Bulk library totals therefore exclude ~36% of the mass that the sc pseudobulk carries on the same genes; compare depth / CPM only on pair_valid genes."
+ },
+ "bulk_depth": {
+  "assigned_reads_per_column": {
+   "min": 652157.0,
+   "median": 13477519.0,
+   "max": 29189295.0
+  },
+  "low_depth_columns_lt_2M": [
+   "7085CA-0",
+   "180E1A-0"
+  ]
+ },
+ "pairing": {
+  "bulk_gsms": 71,
+  "bulk_subjects_geo": 29,
+  "bulk_count_table_columns": 49,
+  "bulk_count_table_subjects": 22,
+  "bulk_columns_matched_to_GSM": 43,
+  "bulk_columns_without_GSM": [
+   "77DA77",
+   "22CBD6",
+   "4F2EAD",
+   "F8FF1A",
+   "56E219",
+   "3F05F3-14"
+  ],
+  "bulk_GSMs_without_count_column": 28,
+  "bulk_GSMs_without_count_column_by_group": {
+   "exposed": 20,
+   "healthy": 5,
+   "mild": 2,
+   "severe": 1
+  },
+  "sc_gsms": 41,
+  "sc_subjects": 18,
+  "geo_level_subject_day_matches": 39,
+  "geo_level_subject_day_matches_by_group": {
+   "mild": 15,
+   "severe": 13,
+   "exposed": 6,
+   "healthy": 5
+  },
+  "geo_level_subjects": 18,
+  "pairs_total": 26,
+  "pairs_subjects": 10,
+  "pairs_by_group": {
+   "mild": 13,
+   "severe": 13
+  },
+  "pairs_by_day": {
+   "0": 10,
+   "14": 9,
+   "7": 7
+  },
+  "sc_by_pair_status": {
+   "paired": 26,
+   "bulk_GSM_has_no_column_in_author_count_table": 13,
+   "no_bulk_GSM_for_this_subject_day": 2
+  },
+  "sc_unpaired": [
+   {
+    "sc_gsm": "GSM6249237",
+    "sample_id": "450905_d7",
+    "group": "mild",
+    "pair_status": "bulk_GSM_has_no_column_in_author_count_table"
+   },
+   {
+    "sc_gsm": "GSM6249239",
+    "sample_id": "7768E4_d2",
+    "group": "exposed",
+    "pair_status": "no_bulk_GSM_for_this_subject_day"
+   },
+   {
+    "sc_gsm": "GSM6249240",
+    "sample_id": "7768E4_d14",
+    "group": "exposed",
+    "pair_status": "bulk_GSM_has_no_column_in_author_count_table"
+   },
+   {
+    "sc_gsm": "GSM6249241",
+    "sample_id": "7768E4_d28",
+    "group": "exposed",
+    "pair_status": "no_bulk_GSM_for_this_subject_day"
+   },
+   {
+    "sc_gsm": "GSM6249243",
+    "sample_id": "0B943B_d3",
+    "group": "mild",
+    "pair_status": "bulk_GSM_has_no_column_in_author_count_table"
+   },
+   {
+    "sc_gsm": "GSM6249262",
+    "sample_id": "61BBAD_d0",
+    "group": "exposed",
+    "pair_status": "bulk_GSM_has_no_column_in_author_count_table"
+   },
+   {
+    "sc_gsm": "GSM6249263",
+    "sample_id": "61BBAD_d7",
+    "group": "exposed",
+    "pair_status": "bulk_GSM_has_no_column_in_author_count_table"
+   },
+   {
+    "sc_gsm": "GSM6249264",
+    "sample_id": "61BBAD_d14",
+    "group": "exposed",
+    "pair_status": "bulk_GSM_has_no_column_in_author_count_table"
+   },
+   {
+    "sc_gsm": "GSM6249267",
+    "sample_id": "80A16A_d0",
+    "group": "exposed",
+    "pair_status": "bulk_GSM_has_no_column_in_author_count_table"
+   },
+   {
+    "sc_gsm": "GSM6249268",
+    "sample_id": "80A16A_d14",
+    "group": "exposed",
+    "pair_status": "bulk_GSM_has_no_column_in_author_count_table"
+   },
+   {
+    "sc_gsm": "GSM6249272",
+    "sample_id": "E0FA1E_dNA",
+    "group": "healthy",
+    "pair_status": "bulk_GSM_has_no_column_in_author_count_table"
+   },
+   {
+    "sc_gsm": "GSM6249273",
+    "sample_id": "3F3322_dNA",
+    "group": "healthy",
+    "pair_status": "bulk_GSM_has_no_column_in_author_count_table"
+   },
+   {
+    "sc_gsm": "GSM6249274",
+    "sample_id": "94D44E_dNA",
+    "group": "healthy",
+    "pair_status": "bulk_GSM_has_no_column_in_author_count_table"
+   },
+   {
+    "sc_gsm": "GSM6249275",
+    "sample_id": "52BA23_dNA",
+    "group": "healthy",
+    "pair_status": "bulk_GSM_has_no_column_in_author_count_table"
+   },
+   {
+    "sc_gsm": "GSM6249276",
+    "sample_id": "655A91_dNA",
+    "group": "healthy",
+    "pair_status": "bulk_GSM_has_no_column_in_author_count_table"
+   }
+  ],
+  "author_cohort_vs_geo_exposure": {
+   "0BF51C": {
+    "author_cohort": "Moderate",
+    "geo_exposure": "Severe"
+   },
+   "0E1F8E": {
+    "author_cohort": "Moderate",
+    "geo_exposure": "Severe"
+   },
+   "180E1A": {
+    "author_cohort": "Moderate",
+    "geo_exposure": "Severe"
+   },
+   "3F05F3": {
+    "author_cohort": "Moderate",
+    "geo_exposure": "Severe"
+   },
+   "40067F": {
+    "author_cohort": "Moderate",
+    "geo_exposure": "Severe"
+   },
+   "82CCF5": {
+    "author_cohort": "Moderate",
+    "geo_exposure": "Severe"
+   },
+   "B85D75": {
+    "author_cohort": "Moderate",
+    "geo_exposure": "Severe"
+   }
+  },
+  "rule": "A pair is one sc GEX GSM and one bulk GSM with the same GEO subject ID and the same GEO sampling day (title '<subject>, <day>, <group>, <serostatus>' = characteristics subject/time); both GSMs must agree on GEO age, sex, exposure group and serostatus; and the bulk GSM must have a column in the author featureCounts table (column '<subject>-<day>' for infected/exposed subjects, '<subject>' for healthy). No expression, age-sex or row-order matching is used to create a pair."
+ },
+ "healthy_leads": [
+  {
+   "bulk_column": "77DA77",
+   "bulk_sex_call": "female",
+   "best_sc_gsm": "GSM6249272",
+   "best_sc_sample": "E0FA1E_dNA",
+   "best_sc_sex_call": "female",
+   "best_sc_geo_sex": "FEMALE",
+   "best_sc_is_unpaired": true,
+   "r_best": 0.420464334761289,
+   "r_second": 0.2496083989065373,
+   "second_sc_sample": "180E1A_d0",
+   "reverse_rank_of_this_bulk_for_best_sc": 1,
+   "reverse_best_bulk_for_best_sc": "77DA77",
+   "geo_healthy_subject_at_same_position_in_author_sheet": "E0FA1E",
+   "position_agrees_with_best_sc_subject": true
+  },
+  {
+   "bulk_column": "22CBD6",
+   "bulk_sex_call": "female",
+   "best_sc_gsm": "GSM6249273",
+   "best_sc_sample": "3F3322_dNA",
+   "best_sc_sex_call": "female",
+   "best_sc_geo_sex": "FEMALE",
+   "best_sc_is_unpaired": true,
+   "r_best": 0.5237721652596927,
+   "r_second": 0.2329536291433593,
+   "second_sc_sample": "2AD75E_d14",
+   "reverse_rank_of_this_bulk_for_best_sc": 1,
+   "reverse_best_bulk_for_best_sc": "22CBD6",
+   "geo_healthy_subject_at_same_position_in_author_sheet": "3F3322",
+   "position_agrees_with_best_sc_subject": true
+  },
+  {
+   "bulk_column": "4F2EAD",
+   "bulk_sex_call": "female",
+   "best_sc_gsm": "GSM6249274",
+   "best_sc_sample": "94D44E_dNA",
+   "best_sc_sex_call": "female",
+   "best_sc_geo_sex": "FEMALE",
+   "best_sc_is_unpaired": true,
+   "r_best": 0.5762409562275047,
+   "r_second": 0.2055064434130179,
+   "second_sc_sample": "450905_d0",
+   "reverse_rank_of_this_bulk_for_best_sc": 1,
+   "reverse_best_bulk_for_best_sc": "4F2EAD",
+   "geo_healthy_subject_at_same_position_in_author_sheet": "94D44E",
+   "position_agrees_with_best_sc_subject": true
+  },
+  {
+   "bulk_column": "F8FF1A",
+   "bulk_sex_call": "male",
+   "best_sc_gsm": "GSM6249275",
+   "best_sc_sample": "52BA23_dNA",
+   "best_sc_sex_call": "male",
+   "best_sc_geo_sex": "MALE",
+   "best_sc_is_unpaired": true,
+   "r_best": 0.6572060268667277,
+   "r_second": 0.2232559108831267,
+   "second_sc_sample": "61BBAD_d14",
+   "reverse_rank_of_this_bulk_for_best_sc": 1,
+   "reverse_best_bulk_for_best_sc": "F8FF1A",
+   "geo_healthy_subject_at_same_position_in_author_sheet": "52BA23",
+   "position_agrees_with_best_sc_subject": true
+  },
+  {
+   "bulk_column": "56E219",
+   "bulk_sex_call": "female",
+   "best_sc_gsm": "GSM6249276",
+   "best_sc_sample": "655A91_dNA",
+   "best_sc_sex_call": "female",
+   "best_sc_geo_sex": "FEMALE",
+   "best_sc_is_unpaired": true,
+   "r_best": 0.709301480946846,
+   "r_second": 0.3301510549216415,
+   "second_sc_sample": "80A16A_d0",
+   "reverse_rank_of_this_bulk_for_best_sc": 1,
+   "reverse_best_bulk_for_best_sc": "56E219",
+   "geo_healthy_subject_at_same_position_in_author_sheet": "655A91",
+   "position_agrees_with_best_sc_subject": true
+  },
+  {
+   "bulk_column": "3F05F3-14",
+   "bulk_sex_call": "male",
+   "best_sc_gsm": "GSM6249243",
+   "best_sc_sample": "0B943B_d3",
+   "best_sc_sex_call": "male",
+   "best_sc_geo_sex": "MALE",
+   "best_sc_is_unpaired": true,
+   "r_best": 0.2104487949476911,
+   "r_second": 0.1687903603213745,
+   "second_sc_sample": "82CCF5_d0",
+   "reverse_rank_of_this_bulk_for_best_sc": 5,
+   "reverse_best_bulk_for_best_sc": "2AD75E-7",
+   "geo_healthy_subject_at_same_position_in_author_sheet": NaN,
+   "position_agrees_with_best_sc_subject": false
+  }
+ ]
+}