Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261002T124820Z-crosscohort-liu-default/diffusion/dataset/server_1/dependency/59703cc49f583b6b/run_step.sh

@@ -0,0 +1,46 @@
+#!/usr/bin/env bash
+# Run one CPU-only Liu 2021 step as a bounded transient systemd user unit (never GPU work).
+# Limits: MemoryMax 40G (MemoryHigh 38G), no swap, <= 8 CPUs, nice 10, idle IO, positive OOM score, no restart,
+# CUDA hidden, <= 8 BLAS/OpenMP threads.  Before launching it waits until /proc/meminfo MemAvailable >= 80 GiB
+# (other jobs share this host; a GPU training job stops itself below 32 GiB and the guard acts below 18 GiB).
+# Usage: run_step.sh <step> [args]
+#   step: rds (R export) | assemble | findings | prepare | <pipeline subcommand: sources|pairing|bulk|sc|...>
+set -euo pipefail
+RUN=/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/processing/liu2021_v1_20261002
+PY=/home/sj_server_1/miniforge3/envs/scanvi/bin/python
+RS=/home/sj_server_1/miniforge3/envs/r_env/bin/Rscript
+PREP_PY=/home/sj_server_1/miniforge3/envs/cxg_corpus/bin/python
+PREP=/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927/tools/prepare_dataset.py
+step="$1"; shift || true
+tag="$step"
+case "$step" in
+  rds) cmd=("$RS" "$RUN/code/liu2021_rds_export.R" "$@") ;;
+  assemble) cmd=("$PY" "$RUN/code/liu2021_assemble.py" "$@") ;;
+  findings) cmd=("$PY" "$RUN/code/liu2021_findings.py" "$@") ;;
+  sanity) cmd=("$PY" "$RUN/code/liu2021_sanity.py" "$@") ;;
+  htosens) cmd=("$PY" "$RUN/code/liu2021_hto_sensitivity.py" "$@") ;;
+  finalize) cmd=("$PY" "$RUN/code/liu2021_finalize.py" "$@") ;;
+  fullcells) cmd=("$PY" "$RUN/code/liu2021_full_cells.py" "$@") ;;
+  prepare) cmd=("$PREP_PY" "$PREP" --dataset liu2021 "$@") ;;
+  *) cmd=("$PY" "$RUN/code/liu2021_pipeline.py" "$step" "$@") ;;
+esac
+systemctl --user is-active --quiet ml-memory-guard.service || { echo "ml-memory-guard not active; refusing" >&2; exit 3; }
+need_kib=$((80 * 1024 * 1024))
+for _ in $(seq 1 240); do
+  avail=$(awk '/^MemAvailable:/{print $2}' /proc/meminfo)
+  if [ "$avail" -ge "$need_kib" ]; then break; fi
+  echo "$(date -Is) MemAvailable $((avail / 1024 / 1024)) GiB < 80 GiB; waiting" >> "$RUN/logs/${tag}.log"
+  sleep 60
+done
+avail=$(awk '/^MemAvailable:/{print $2}' /proc/meminfo)
+[ "$avail" -ge "$need_kib" ] || { echo "MemAvailable stayed below 80 GiB; not launching" >&2; exit 4; }
+echo "$(date -Is) launch $step MemAvailable $((avail / 1024 / 1024)) GiB" >> "$RUN/logs/${tag}.log"
+unit="liu-${tag}-$(date +%H%M%S)"
+exec systemd-run --user --wait --collect --quiet --unit="$unit" --slice=app.slice \
+  -p MemoryHigh=38G -p MemoryMax=40G -p MemorySwapMax=0 -p CPUQuota=800% \
+  -p OOMPolicy=kill -p OOMScoreAdjust=500 -p Nice=10 -p IOSchedulingClass=idle \
+  --working-directory="$RUN" \
+  -E CUDA_VISIBLE_DEVICES= -E OMP_NUM_THREADS=8 -E OPENBLAS_NUM_THREADS=8 -E MKL_NUM_THREADS=8 \
+  -E NUMEXPR_NUM_THREADS=8 -E PYTHONDONTWRITEBYTECODE=1 -E PYTHONUNBUFFERED=1 \
+  -p StandardOutput="append:$RUN/logs/${tag}.log" -p StandardError="append:$RUN/logs/${tag}.log" \
+  "${cmd[@]}"

paper-releases/pbisc-diffusion/updates/20261002T124820Z-crosscohort-liu-default/diffusion/dataset/server_1/dependency/7f3e5772147e5dda/liu2021_rds_export.R

@@ -0,0 +1,126 @@
+#!/usr/bin/env Rscript
+# Liu et al., Cell 2021 (GSE161918): export the author Seurat object's RNA gene-expression counts and the full cell
+# metadata, unchanged, for the Python strict-QC pipeline (CPU only; no GPU, no Seurat computation).
+#
+# Input : datasets/GSE161918/raw/GSE161918_AllBatches_SeuratObj.rds.gz (GEO supplementary file; a gzip of a
+#         gzip-compressed RDS, so it is read through gzcon(gzfile()) without writing a decompressed copy).
+# Output: processing/liu2021_v1_20261002/rds_export/
+#   STRUCTURE.json            object class/version, assays and slot dimensions, metadata column summary, checks
+#   cell_metadata.csv.gz      object@meta.data with the cell name as column `cell` (all columns, unchanged)
+#   rna_genes.txt             RNA assay rownames (counts slot), in order
+#   rna_cells.txt             RNA assay colnames (counts slot), in order (== rownames(meta.data), checked)
+#   rna_counts_p.int32 / rna_counts_i.int32 / rna_counts_x.int32
+#                             the dgCMatrix (genes x cells, CSC) arrays of the RNA counts slot, little endian;
+#                             as a cells x genes matrix these are CSR (indptr = p, indices = i, data = x).
+#                             x is written as int32 only after checking every value is a non-negative integer < 2^31.
+#   rna_meta_features.csv.gz  RNA assay meta.features (if any columns)
+#   other_assay_features.json feature names of every non-RNA assay (ADT/HTO), recorded only
+args <- commandArgs(trailingOnly = TRUE)
+src <- "/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/datasets/GSE161918/raw/GSE161918_AllBatches_SeuratObj.rds.gz"
+out <- "/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/processing/liu2021_v1_20261002/rds_export"
+if (Sys.getenv("CUDA_VISIBLE_DEVICES", unset = "unset") != "") stop("run with CUDA_VISIBLE_DEVICES=''")
+suppressPackageStartupMessages({
+  library(Matrix)
+  library(SeuratObject)
+  library(jsonlite)
+  library(data.table)
+})
+setDTthreads(as.integer(Sys.getenv("OMP_NUM_THREADS", "4")))
+dir.create(out, showWarnings = FALSE, recursive = TRUE)
+t0 <- Sys.time()
+msg <- function(...) cat(format(Sys.time(), "%H:%M:%S"), ..., "\n", sep = " ")
+
+msg("reading", src)
+con <- gzcon(gzfile(src, "rb"))
+obj <- readRDS(con)
+close(con)
+msg("read done; class", class(obj)[1], "; mem", format(object.size(obj), units = "GB"))
+gc()
+
+info <- list(source = src, read_seconds = as.numeric(difftime(Sys.time(), t0, units = "secs")),
+             class = class(obj), r_version = R.version.string,
+             seuratobject_package = as.character(packageVersion("SeuratObject")))
+info$object_version <- tryCatch(as.character(obj@version), error = function(e) NA)
+info$project_name <- tryCatch(obj@project.name, error = function(e) NA)
+info$assays <- list()
+for (a in names(obj@assays)) {
+  A <- obj@assays[[a]]
+  rec <- list(class = class(A)[1])
+  for (s in c("counts", "data", "scale.data")) {
+    v <- tryCatch(slot(A, s), error = function(e) NULL)
+    if (!is.null(v)) rec[[s]] <- list(class = class(v)[1], dim = dim(v))
+  }
+  rec$key <- tryCatch(A@key, error = function(e) NA)
+  rec$meta_features_columns <- tryCatch(colnames(A@meta.features), error = function(e) NULL)
+  info$assays[[a]] <- rec
+}
+info$active_assay <- tryCatch(obj@active.assay, error = function(e) NA)
+info$reductions <- names(obj@reductions)
+info$graphs <- tryCatch(names(obj@graphs), error = function(e) NULL)
+info$misc_names <- tryCatch(names(obj@misc), error = function(e) NULL)
+info$commands <- tryCatch(names(obj@commands), error = function(e) NULL)
+md <- obj@meta.data
+info$n_cells_meta <- nrow(md)
+info$meta_columns <- lapply(md, function(col) {
+  u <- unique(col)
+  list(class = class(col)[1], n_unique = length(u), n_na = sum(is.na(col)),
+       values = if (length(u) <= 60) as.character(sort(u, na.last = TRUE)) else as.character(head(u, 8)))
+})
+msg("meta.data", nrow(md), "x", ncol(md))
+fwrite(cbind(data.table(cell = rownames(md)), as.data.table(md)), file.path(out, "cell_metadata.csv.gz"))
+
+# ---------------- RNA counts slot
+rna <- obj@assays[["RNA"]]
+m <- slot(rna, "counts")
+stopifnot(inherits(m, "dgCMatrix"))
+stopifnot(identical(colnames(m), rownames(md)))
+x <- m@x
+chk <- list(nnz = length(x), dim = dim(m), x_min = min(x), x_max = max(x),
+            x_all_integer = all(x == round(x)), x_any_zero_stored = any(x == 0),
+            x_all_finite = all(is.finite(x)))
+msg("counts", paste(dim(m), collapse = " x "), "nnz", length(x), "integer", chk$x_all_integer)
+stopifnot(chk$x_all_finite, chk$x_min >= 0, chk$x_all_integer, chk$x_max < 2^31)
+# consistency with the author metadata columns (when present)
+ncount <- Matrix::colSums(m)
+nfeat <- diff(m@p)
+if ("nCount_RNA" %in% colnames(md)) {
+  chk$nCount_RNA_equals_colSums <- isTRUE(all(md$nCount_RNA == ncount))
+  chk$nCount_RNA_max_abs_diff <- max(abs(md$nCount_RNA - ncount))
+}
+if ("nFeature_RNA" %in% colnames(md)) {
+  chk$nFeature_RNA_equals_stored_entries <- isTRUE(all(md$nFeature_RNA == nfeat))
+  chk$nFeature_RNA_max_abs_diff <- max(abs(md$nFeature_RNA - nfeat))
+}
+chk$gene_names_unique <- !anyDuplicated(rownames(m))
+chk$cell_names_unique <- !anyDuplicated(colnames(m))
+info$rna_counts_checks <- chk
+writeLines(rownames(m), file.path(out, "rna_genes.txt"))
+writeLines(colnames(m), file.path(out, "rna_cells.txt"))
+w <- function(v, name) {
+  f <- file(file.path(out, name), "wb")
+  writeBin(v, f, size = 4L, endian = "little")
+  close(f)
+}
+w(as.integer(m@p), "rna_counts_p.int32")
+w(as.integer(m@i), "rna_counts_i.int32")
+w(as.integer(x), "rna_counts_x.int32")
+rm(x)
+mf <- rna@meta.features
+if (ncol(mf) > 0) fwrite(cbind(data.table(feature = rownames(mf)), as.data.table(mf)), file.path(out, "rna_meta_features.csv.gz"))
+# the normalised data slot is NOT exported; record whether it differs from counts (it should: log-normalised)
+d <- tryCatch(slot(rna, "data"), error = function(e) NULL)
+if (!is.null(d) && inherits(d, "dgCMatrix")) {
+  info$rna_data_slot <- list(dim = dim(d), nnz = length(d@x), identical_to_counts = identical(d@x, m@x),
+                             x_max = max(d@x), x_all_integer = all(d@x == round(d@x)))
+}
+rm(d, m)
+gc()
+other <- list()
+for (a in setdiff(names(obj@assays), "RNA")) {
+  A <- obj@assays[[a]]
+  other[[a]] <- rownames(A)
+}
+write_json(other, file.path(out, "other_assay_features.json"), auto_unbox = TRUE)
+info$seconds_total <- as.numeric(difftime(Sys.time(), t0, units = "secs"))
+write_json(info, file.path(out, "STRUCTURE.json"), auto_unbox = TRUE, pretty = TRUE, digits = NA, null = "null", na = "null")
+msg("done in", round(info$seconds_total), "s")

paper-releases/pbisc-diffusion/updates/20261002T124820Z-crosscohort-liu-default/diffusion/dataset/server_1/dependency/8e68b8329137c8ad/liu2021_pipeline.py

@@ -0,0 +1,690 @@
+#!/usr/bin/env python3
+"""Liu et al., Cell 2021 (GSE161918, NIH COVID-19 CITE-seq): PBMC bulk RNA-seq + PBMC CITE-seq GEX processing.
+
+CPU only; never imports torch or initializes CUDA.
+
+Reuses the frozen strict-QC code bundle v5 VERBATIM (copied to code/strict_qc_v1_code_bundle_v5, sha256 verified
+against its MANIFEST), exactly as the Giroux 2022 / Imperial ESKD / Ye 2026 builds:
+  * qc_genes.GeneMapper                       frozen 20,097-gene GENCODE v49 axis; ID-first mapping with
+                                              ambiguity/conflict quarantine
+  * qc_core.scan_h5                           per-sample streaming audit and cell flags (min genes 200,
+                                              min counts 500, max mito 20 %, 5-MAD review flags)
+  * qc_singlecell.read_axes/canonical_export  canonical sparse H5AD, measured masks, SUM pseudobulk
+  * qc_bulk.BulkInput/harmonize               bulk canonical matrix with NaN + presence/valid layers
+Study-specific glue only (this file):
+  * the single cells come from the authors' Seurat object (GEO GSE161918_AllBatches_SeuratObj.rds.gz), exported
+    unchanged by code/liu2021_rds_export.R (RNA counts slot + full meta.data).  Each author sample (author
+    `sample_id` = batch + subject + timepoint) is cut out of the pooled object into a small per-sample source H5AD
+    (raw X, same values) so the bundle runs per library, exactly as for Imperial ESKD;
+  * cells kept for a sample: unsorted fraction only (author `Sorted` == "N"; the bulk is unsorted PBMC, while the
+    sorted fractions are FACS-enriched B/T/monocyte/innate (batch 1) or non-naive T/B (batches 2-3) cells), author
+    HTO demultiplexing singlets only (`HTO_classification.global` == "Singlet"; HTO "Doublet" and "Negative" cells
+    are dropped), demuxlet singlets only (`DROPLET.TYPE` == "SNG");
+  * the Seurat RNA rownames are make.unique() of the Cell Ranger hg19-1.2.0 symbols with '_' -> '-' (Seurat feature
+    naming).  They equal, position by position, that reference's genes table (reference_crosswalk/, proof in
+    CROSSWALK.json), so Ensembl IDs are restored positionally and the bundle maps by ID with the original 10x
+    symbol as the checked secondary field (the Giroux / Imperial semantics);
+  * pairing: author bulk count-table column <-> GEO bulk GSM (title) <-> sc author sample by subject + timepoint.
+
+Subcommands: sources | pairing | bulk | sc
+"""
+from __future__ import annotations
+
+import argparse
+import csv
+import gzip
+import json
+import os
+import re
+import shutil
+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
+
+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")
+GEO = DATALAKE / "datasets/GSE161918"
+RDS = GEO / "raw/GSE161918_AllBatches_SeuratObj.rds.gz"
+SOFT = GEO / "metadata/GSE161918_family.soft.gz"
+BULK_TABLES = {"B1_bulkRNAseq_countmtx.csv": GEO / "raw/GSE161918_B1bulkRNAseq_countmtx.csv.gz",
+               "B2_B3_bulkRNAseq_countmtx.csv": GEO / "raw/GSE161918_B2GSE161918_B3bulkRNAseq_countmtx.csv.gz"}
+PAIRMAPS = DATALAKE / "analyses/paired_inventory_20260927/new_pairmaps"
+HTO_META = PAIRMAPS / "GSE161918_allbatches.HTOandTimepointMetadata.csv.gz"   # GEO suppl. file, cached copy (read only)
+RUN = DATALAKE / "processing/liu2021_v1_20261002"
+EXPORT = RUN / "rds_export"
+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
+RECEIPTS = DATALAKE / "acquisition/20260927/manifests/download_receipts.jsonl"
+# Cell Ranger hg19-1.2.0 genes table (32,738 genes): GEO GSE206283 per-GSM filtered_feature_bc_matrix, extracted and
+# receipt-verified by the Giroux 2022 build (all 41 copies identical); copied here unchanged.
+CROSSWALK_SRC = DATALAKE / ("processing/giroux2022_v1_20260928/extracted/GSE206283/GSM6249265/"
+                            "scRNA_59-0_filtered_feature_bc_matrix/features.tsv.gz")
+CROSSWALK = RUN / "reference_crosswalk/cellranger_hg19-1.2.0_features__from_GSE206283_GSM6249265.tsv.gz"
+ACCESSION = "GSE161918"
+sys.path.insert(0, str(BUNDLE))
+
+import qc_core  # noqa: E402
+import qc_genes  # noqa: E402
+
+SEX_GENES = {"XIST": "ENSG00000229807", "RPS4Y1": "ENSG00000129824", "DDX3Y": "ENSG00000067048",
+             "UTY": "ENSG00000183878", "KDM5D": "ENSG00000012817"}
+COUNT_EVIDENCE = ("GSE161918 author Seurat object (Seurat 3.1.0) RNA assay counts slot: Cell Ranger 3.1.0 UMI counts, "
+                  "hg19-1.2.0 reference, 10x 5' Next GEM v1.1 CITE-seq gene-expression library. Every stored value "
+                  "is a positive integer; per cell the column sum equals the author nCount_RNA and the stored-entry "
+                  "count equals nFeature_RNA (checked in R and again per cell here); the data slot is log-normalised "
+                  "and is NOT used.")
+# Sample-level clinical fields of the author metadata (must be constant within an author sample).
+SAMPLE_LEVEL = ["Batch", "Donor", "Subject", "Timepoint", "Class", "Age", "Gender", "Ward", "Status", "symptom_type",
+                "hospital_days", "day_from_symptom_onset_to_hospitalization", "number_of_days_hospitalized",
+                "computed_ethnicity", "ever_admitted_to_icu", "severity", "days_of_symptoms_onset", "condition",
+                "outcome", "DDimer", "CRP", "material_type", "sample_bsi_id", "sample_alt_id", "sample_label", "batch",
+                "days_since_hospitalized", "days_since_onset", "severity.outcome", "PC1", "PC1_cat", "cond_group",
+                "onset_group", "intubation_vent", "PC1_onset_group", "sample_name", "Sorted", "BatchSort"]
+CELL_COLUMNS = ["cell", "Batch", "BatchSort", "Sorted", "Donor", "Subject", "Timepoint", "sample_id", "sample_name",
+                "Sample", "BARCODE", "barcodeBatch", "HTO_classification.global", "hash.ID", "autoHashcalls",
+                "HTO_maxID", "DROPLET.TYPE", "SNG.BEST.GUESS", "Pool", "nCount_RNA", "nFeature_RNA", "percent.mito",
+                "celltypeQC", "coursecelltype", "mergedcelltype", "WCTcoursecelltype", "WCTmergedcelltype",
+                "adjustedcelltype"]
+# GEO series design (read from the soft file and asserted below): CHI014 = technical control in every batch;
+# HDML_bc / HDVO_bc = buffy-coat freezing test; SHD8 = excluded by the authors (lymphoma-like B cells).
+# Per the task, technical controls (CHI*, HD_*) are excluded from pairs; they stay in the identity null pool.
+CONTROL_COLUMN = re.compile(r"^(CHI-?014(_B\d)?|HD_(ML|VO)_(bc|PBMC))$")
+CONTROL_SC_SUBJECT = re.compile(r"^(CHI014|HD(ML|VO)_(bc|PBMC))$")
+
+
+def now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def log(event: dict) -> None:
+    line = json.dumps({"t": now(), **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 require(ok: bool, msg: str) -> None:
+    if not ok:
+        raise RuntimeError(msg)
+
+
+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
+
+
+def make_unique(names: list[str]) -> list[str]:
+    """R base::make.unique(sep='.'), as Seurat applies to duplicated 10x feature names."""
+    seen, counter, out = set(), {}, []
+    for name in names:
+        if name not in seen:
+            out.append(name)
+            seen.add(name)
+            counter[name] = 0
+            continue
+        k = counter[name] + 1
+        while f"{name}.{k}" in seen:
+            k += 1
+        counter[name] = k
+        out.append(f"{name}.{k}")
+        seen.add(f"{name}.{k}")
+    return out
+
+
+def restored_feature_axis() -> tuple[list[str], list[str], dict]:
+    """(ids, symbols) for the Seurat RNA rows: Ensembl IDs and 10x symbols of the hg19-1.2.0 table, by position."""
+    rows = [line.rstrip("\n").split("\t") for line in gzip.open(CROSSWALK, "rt")]
+    ids, symbols, types = [r[0] for r in rows], [r[1] for r in rows], sorted({r[2] for r in rows})
+    seurat = [line.rstrip("\n") for line in open(EXPORT / "rna_genes.txt")]
+    expected = make_unique([s.replace("_", "-") for s in symbols])
+    mismatch = [i for i, (a, b) in enumerate(zip(expected, seurat)) if a != b]
+    require(len(seurat) == len(ids) and not mismatch, f"Seurat rownames differ from hg19-1.2.0 order at {mismatch[:5]}")
+    require(len(set(ids)) == len(ids) and all(re.fullmatch(r"ENSG\d{11}", i) for i in ids), "crosswalk IDs")
+    require(types == ["Gene Expression"], f"unexpected feature types {types}")
+    renamed = [{"position": i, "seurat_name": seurat[i], "tenx_symbol": symbols[i], "ensembl_id": ids[i]}
+               for i in range(len(ids)) if seurat[i] != symbols[i]]
+    proof = {"features": len(ids), "feature_types": types, "positions_compared": len(ids),
+             "rule": ("Seurat CreateSeuratObject feature names = make.unique(10x symbol with '_' replaced by '-'); "
+                      "this equals rna_genes.txt (the counts-slot rownames) at every position, so the Ensembl ID of "
+                      "row i is the hg19-1.2.0 genes-table ID of row i"),
+             "ordered_match_after_underscore_and_make_unique": True,
+             "renamed_positions": renamed}
+    return ids, symbols, proof
+
+
+# ----------------------------------------------------------------- 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:
+    verify_bundle()
+    known = receipts()
+    records = []
+    for path in [RDS, *BULK_TABLES.values(), SOFT]:
+        rec = {"path": str(path), "bytes": path.stat().st_size, "sha256": sha256(path)}
+        receipt = known.get(str(path))
+        rec["acquisition_receipt"] = bool(receipt)
+        require(bool(receipt), f"no acquisition receipt for {path}")
+        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"])
+        require(rec["matches_receipt"], f"acquired file differs from its receipt: {path}")
+        records.append(rec)
+    pm = json.loads((PAIRMAPS / "summary.json").read_text())
+    liu = [s for s in pm["studies"] if s["study"] == "liu_covid"][0]
+    hto = {"path": str(HTO_META), "bytes": HTO_META.stat().st_size, "sha256": sha256(HTO_META),
+           "url": liu["hto_source_url"],
+           "summary_json_sha256": pm["source_sha256"].get(str(HTO_META), ""),
+           "note": "GEO supplementary file cached by the 2026-09-27 pairing audit (read only); used only as an "
+                   "independent cross-check of the Seurat object's (subject, hashtag) -> timepoint / sorted labels"}
+    hto["matches_summary_json"] = hto["sha256"] == hto["summary_json_sha256"]
+    structure = json.loads((EXPORT / "STRUCTURE.json").read_text())
+    chk = structure["rna_counts_checks"]
+    require(chk["x_all_integer"] and chk["x_min"] >= 1 and chk["nCount_RNA_equals_colSums"] and
+            chk["nFeature_RNA_equals_stored_entries"] and chk["gene_names_unique"] and chk["cell_names_unique"],
+            "R export checks failed")
+    export = [{"path": str(p), "bytes": p.stat().st_size, "sha256": sha256(p)} for p in sorted(EXPORT.iterdir())
+              if p.is_file()]
+    # reference crosswalk: copy the hg19-1.2.0 genes table unchanged and prove the positional identity
+    CROSSWALK.parent.mkdir(exist_ok=True)
+    if not CROSSWALK.exists():
+        shutil.copyfile(CROSSWALK_SRC, CROSSWALK)
+    require(sha256(CROSSWALK) == sha256(CROSSWALK_SRC), "crosswalk copy differs from its source")
+    _, _, proof = restored_feature_axis()
+    gsrc = json.loads((DATALAKE / "processing/giroux2022_v1_20260928/SOURCES.json").read_text())["files"]
+    tar = [f for f in gsrc if f["path"].endswith("GSE206283_RAW.tar")][0]
+    proof.update({"file": {"path": str(CROSSWALK), "sha256": sha256(CROSSWALK), "bytes": CROSSWALK.stat().st_size},
+                  "copied_from": str(CROSSWALK_SRC),
+                  "origin": {"geo_archive": tar["path"], "url": tar.get("url", ""), "sha256": tar["sha256"],
+                             "matches_receipt": tar.get("matches_receipt"),
+                             "note": "Giroux 2022 GEO per-GSM Cell Ranger 3.1.0 hg19 matrices; all 41 features.tsv "
+                                     "copies are byte-identical (Giroux FINDINGS sc_chemistry)"},
+                  "paper_statement": "GEO GSE161918 data processing: 'Genome_build: hg19 (cellranger version 1.2.0)'; "
+                                     "mapping CellRanger 3.1.0",
+                  "created_utc": now()})
+    qc_core._write_json(RUN / "reference_crosswalk/CROSSWALK.json", proof)
+    qc_core._write_json(RUN / "SOURCES.json", {
+        "created_at_utc": now(), "files": records, "hto_metadata": hto, "rds_export": export,
+        "rds_export_code": {"path": str(RUN / "code/liu2021_rds_export.R"), "sha256": sha256(RUN / "code/liu2021_rds_export.R")},
+        "rds_structure_checks": chk, "crosswalk": str(RUN / "reference_crosswalk/CROSSWALK.json"),
+        "acquisition": "paired-datasets-20260927 acquisition (read only; not modified)", "receipts": str(RECEIPTS)})
+    log({"stage": "sources", "n_files": len(records), "hto_matches_summary": hto["matches_summary_json"],
+         "crosswalk_positions": proof["positions_compared"], "renamed": len(proof["renamed_positions"])})
+
+
+# ----------------------------------------------------------------- pairing
+def parse_soft(path: Path) -> pd.DataFrame:
+    samples, cur, section, series = [], None, None, defaultdict(list)
+    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 not line.startswith("!") or " = " not in line:
+                continue
+            key, val = line[1:].split(" = ", 1)
+            if section == "SERIES":
+                series[key].append(val)
+            if section != "SAMPLE":
+                continue
+            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)
+    frame = pd.DataFrame([{k: "|".join(v) for k, v in s.items()} for s in samples]).fillna("")
+    frame.attrs["series"] = {k: "|".join(v) for k, v in series.items()}
+    return frame
+
+
+BULK_TITLE = re.compile(r"^Batch ?(\d) bulk ?RNAseq (\S+)\s*$")
+
+
+def geo_timepoint(label: str) -> str:
+    m = re.fullmatch(r"Timepoint (\d)", label)
+    return f"T{m.group(1)}" if m else ("HC" if label.startswith("Healthy Control") else label)
+
+
+def read_bulk_header(path: Path) -> list[str]:
+    with gzip.open(path, "rt", newline="") as handle:
+        header = next(csv.reader(handle))
+    require(len(set(header)) == len(header) and all(h.strip() for h in header), f"bad bulk header {path}")
+    require(header[0] == "V2", f"unexpected first header field {header[0]!r} in {path}")
+    return header[1:]
+
+
+def read_cells() -> pd.DataFrame:
+    cells = pd.read_csv(EXPORT / "cell_metadata.csv.gz", dtype=str, keep_default_na=False)
+    order = [line.rstrip("\n") for line in open(EXPORT / "rna_cells.txt")]
+    require(cells.cell.tolist() == order, "meta.data rows differ from the counts-slot column order")
+    cells.insert(0, "col_index", np.arange(len(cells), dtype=np.int64))
+    return cells
+
+
+def cmd_pairing(_args) -> None:
+    out = RUN / "pairing"
+    out.mkdir(parents=True, exist_ok=True)
+    soft = parse_soft(SOFT)
+    design = soft.attrs["series"]["Series_overall_design"]
+    for token in ("CHI014", "SHD8", "HDML_bc", "HDVO_bc"):
+        require(token in design, f"GEO series design no longer mentions {token}")
+    soft.to_csv(out / "GSE161918_samples.csv", index=False)
+    bulk = soft[soft.Sample_title.str.contains("bulk", case=False)].copy()
+    parsed = bulk.Sample_title.str.extract(BULK_TITLE)
+    require(parsed.notna().all().all(), f"unparsed bulk titles {bulk.Sample_title[parsed.isna().any(axis=1)].tolist()}")
+    bulk["geo_batch"], bulk["title_name"] = "B" + parsed[0], parsed[1]
+    bulk["table_file"] = bulk.Sample_description.str.split("|").str[-1]
+    require(bulk.table_file.isin(list(BULK_TABLES)).all(), "bulk GSM description does not name a count table")
+    bulk["geo_timepoint"] = bulk.ch_timepoint.map(geo_timepoint)
+    require((bulk.Sample_source_name_ch1 == "Peripheral Blood Mononuclear Cells").all(), "bulk source is not PBMC")
+    require((bulk["ch_unsorted or sorted t/b cells"] == "Unsorted").all(), "a bulk GSM is not unsorted")
+    # ---- author count-table columns -> GSM
+    cols = []
+    for table, path in BULK_TABLES.items():
+        for c in read_bulk_header(path):
+            cols.append({"bulk_column": c, "table_file": table})
+    cols = pd.DataFrame(cols)
+    require(cols.bulk_column.is_unique, "a column name appears in both bulk tables")
+    # a leading 'P' before an HGR subject is a typo (GEO GSM4929238 title 'HGR0000074', HTO metadata HGR0000074 T0)
+    cols["column_key"] = cols.bulk_column.str.replace(r"^P(HGR\d+_T\d)$", r"\1", regex=True)
+    cols["column_correction"] = np.where(cols.column_key != cols.bulk_column,
+                                         "leading 'P' removed (typo; GEO title and HTO metadata name the subject without it)", "")
+    tp = cols.column_key.str.extract(r"^(.+)_(T\d)$")
+    cols["subject"] = tp[0].fillna(cols.column_key)
+    cols["column_timepoint"] = tp[1].fillna("")
+    gsm_of = {}
+    for i, c in cols.iterrows():
+        cand = bulk[(bulk.table_file == c.table_file) &
+                    ((bulk.title_name == c.column_key) | (bulk.title_name == c.subject))]
+        require(len(cand) == 1, f"bulk column {c.bulk_column}: {len(cand)} candidate GSMs")
+        gsm_of[i] = cand.index[0]
+    cols["bulk_gsm"] = [bulk.loc[gsm_of[i], "gsm"] for i in cols.index]
+    require(cols.bulk_gsm.is_unique and set(cols.bulk_gsm) == set(bulk.gsm), "bulk column <-> GSM is not 1:1")
+    b = bulk.set_index("gsm")
+    cols["bulk_title"] = cols.bulk_gsm.map(b.Sample_title)
+    cols["geo_batch"] = cols.bulk_gsm.map(b.geo_batch)
+    cols["geo_timepoint_characteristic"] = cols.bulk_gsm.map(b.ch_timepoint)
+    cols["geo_timepoint"] = cols.bulk_gsm.map(b.geo_timepoint)
+    cols["timepoint"] = np.where(cols.column_timepoint != "", cols.column_timepoint, cols.geo_timepoint)
+    cols["timepoint_conflict"] = np.where((cols.column_timepoint != "") & (cols.column_timepoint != cols.geo_timepoint),
+                                          "column name " + cols.column_timepoint + " vs GEO characteristic '" +
+                                          cols.geo_timepoint_characteristic + "'", "")
+    cols["kind"] = np.where(cols.bulk_column.str.fullmatch(CONTROL_COLUMN.pattern), "technical_control",
+                            np.where(cols.geo_timepoint_characteristic.str.contains("excluded"), "author_excluded",
+                                     np.where(cols.timepoint == "HC", "HC", "COVID")))
+    # ---- single cells (author Seurat object)
+    cells = read_cells()
+    cells["selected"] = ((cells.Sorted == "N") & (cells["HTO_classification.global"] == "Singlet") &
+                         (cells["DROPLET.TYPE"] == "SNG"))
+    keep_cols = ["col_index", *CELL_COLUMNS, "selected"]
+    cells[keep_cols].to_parquet(out / "sc_cell_obs.parquet", index=False)
+    # independent cross-check against GEO's HTO/timepoint metadata: (batch, donor_hashtag) -> timepoint (and sorted, B1)
+    hto = pd.read_csv(HTO_META, dtype=str, keep_default_na=False).rename(columns={"Unnamed: 0": "row"})
+    hto["key"] = hto.Batch + "|" + hto.x
+    require(hto.key.is_unique, "HTO metadata keys not unique")
+    hk = hto.set_index("key")
+    ck = cells.Batch + "|" + cells.Donor + "_" + cells.autoHashcalls
+    found = ck.isin(hk.index)
+    tp_ok = found & (ck.map(hk.Timepoint) == cells.Timepoint)
+    b1 = cells.Batch == "B1"
+    sort_ok = ~b1 | (ck.map(hk.Sorted) == cells.Sorted)
+    hto_check = {
+        "cells": int(len(cells)), "cells_key_found": int(found.sum()),
+        "timepoint_agrees": int(tp_ok.sum()), "timepoint_agrees_selected": int((tp_ok & cells.selected).sum()),
+        "batch1_sorted_agrees": int((sort_ok & b1 & found).sum()), "batch1_cells": int(b1.sum()),
+        "selected_cells": int(cells.selected.sum()),
+        "selected_key_not_found": cells.loc[cells.selected & ~found, "Donor"].value_counts().to_dict(),
+        "selected_timepoint_disagrees": (cells.loc[cells.selected & found & ~tp_ok, "sample_id"].value_counts().to_dict()),
+        "key": "Batch + '|' + Donor + '_' + autoHashcalls (the hashtag that defines the author Sample)"}
+    # ---- sc samples (author sample_id; every sample-level field must be constant within the unsorted fraction)
+    uns = cells[cells.Sorted == "N"]
+    grouped = uns.groupby("sample_id", sort=True)
+    varying = {c: int((grouped[c].nunique() > 1).sum()) for c in SAMPLE_LEVEL if c in uns}
+    require(sum(v for k, v in varying.items()) == 0, f"sample-level fields vary within a sample: {varying}")
+    sc = grouped[[c for c in SAMPLE_LEVEL if c in uns]].first()
+    allc = cells.groupby("sample_id")
+    sc["n_cells_object"] = allc.size()
+    sc["n_sorted_dropped"] = allc.Sorted.agg(lambda s: int((s == "Y").sum()))
+    sc["n_unsorted"] = grouped.size()
+    for lab in ("Singlet", "Doublet", "Negative"):
+        sc[f"n_unsorted_hto_{lab.lower()}"] = grouped["HTO_classification.global"].agg(lambda s, lab=lab: int((s == lab).sum()))
+    sc["n_unsorted_not_demuxlet_singlet"] = grouped["DROPLET.TYPE"].agg(lambda s: int((s != "SNG").sum()))
+    sc["n_selected"] = grouped.selected.sum().astype(int)
+    sc["hashtags"] = grouped.autoHashcalls.agg(lambda s: "|".join(sorted(set(s))))
+    sc = sc.reset_index().rename(columns={"sample_id": "sc_sample"})
+    require((sc.sample_name == sc.Subject + "_" + sc.Timepoint).all(), "sample_name != Subject_Timepoint")
+    sc["kind"] = np.where(sc.Subject.str.fullmatch(CONTROL_SC_SUBJECT.pattern), "technical_control", sc.Class)
+    sc.to_csv(out / "sc_samples.csv", index=False)
+    # ---- pairs: same subject and same timepoint, controls excluded
+    pairable_b = cols[cols.kind.isin(["HC", "COVID"])]
+    pairable_s = sc[sc.kind.isin(["HC", "COVID"])]
+    m = pairable_s.merge(pairable_b, left_on=["Subject", "Timepoint"], right_on=["subject", "timepoint"], how="inner",
+                         suffixes=("", "_bulk"))
+    require(m.sc_sample.is_unique and m.bulk_column.is_unique, "a pair is not 1:1")
+    require((m.Class == np.where(m.timepoint == "HC", "HC", "COVID")).all(), "sc Class differs from the bulk GEO label")
+    require((m.Batch == m.geo_batch).all(), "sc batch differs from the bulk GSM batch")
+    m["id_match"] = np.where(m.column_correction != "", "subject_timepoint; bulk column name corrected",
+                             np.where(m.timepoint_conflict != "", "subject_timepoint; GEO bulk timepoint characteristic differs",
+                                      "exact_subject_timepoint"))
+    m["sample_id"] = m.Subject + "_" + m.Timepoint
+    m = m.sort_values("bulk_gsm").reset_index(drop=True)
+    m.to_csv(out / "pairs_primary.csv", index=False)
+    paired_sc, paired_b = set(m.sc_sample), set(m.bulk_column)
+
+    def sc_reason(r) -> str:
+        if r.kind == "technical_control":
+            return "technical control (CHI014 / HD buffy-coat test donor); excluded by task rule"
+        hit = cols[(cols.subject == r.Subject)]
+        return "no bulk column for this subject and timepoint" + (
+            f" (subject bulk timepoints: {','.join(hit.timepoint)})" if len(hit) else "")
+    sc_un = sc[~sc.sc_sample.isin(paired_sc)].copy()
+    sc_un["reason"] = sc_un.apply(sc_reason, axis=1) if len(sc_un) else []
+    sc_un.to_csv(out / "sc_without_bulk.csv", index=False)
+
+    def b_reason(r) -> str:
+        if r.kind == "technical_control":
+            return "technical control column (CHI014 / HD buffy-coat test); excluded by task rule"
+        if r.kind == "author_excluded":
+            n = int((cells.Subject == r.subject).sum())
+            return f"GEO: '{r.geo_timepoint_characteristic}'; the author Seurat object holds {n} cells of this subject"
+        return "no sc sample with this subject and timepoint"
+    cols["paired"] = cols.bulk_column.isin(paired_b)
+    cols["unpaired_reason"] = [("" if p else b_reason(r)) for p, (_, r) in zip(cols.paired, cols.iterrows())]
+    cols.to_csv(out / "bulk_count_columns.csv", index=False)
+    summary = {
+        "bulk_gsms": int(len(bulk)), "bulk_columns": int(len(cols)),
+        "bulk_columns_by_table": cols.table_file.value_counts().to_dict(),
+        "bulk_columns_by_kind": cols.kind.value_counts().to_dict(),
+        "bulk_column_corrections": cols[cols.column_correction != ""][["bulk_column", "column_key", "bulk_gsm", "bulk_title"]].to_dict("records"),
+        "bulk_timepoint_conflicts": cols[cols.timepoint_conflict != ""][["bulk_column", "bulk_gsm", "bulk_title", "timepoint_conflict"]].to_dict("records"),
+        "bulk_material": "GEO source 'Peripheral Blood Mononuclear Cells', characteristic 'Unsorted' for all 73 bulk GSMs",
+        "sc_cells_object": int(len(cells)), "sc_cells_unsorted": int((cells.Sorted == "N").sum()),
+        "sc_cells_selected": int(cells.selected.sum()),
+        "sc_cells_by_batchsort_hto": pd.crosstab(cells.BatchSort, cells["HTO_classification.global"]).to_dict(),
+        "sc_droplet_type": cells["DROPLET.TYPE"].value_counts().to_dict(),
+        "sc_samples_unsorted": int(len(sc)), "sc_samples_by_kind": sc.kind.value_counts().to_dict(),
+        "hto_metadata_cross_check": hto_check,
+        "pairs_total": int(len(m)), "pairs_subjects": int(m.Subject.nunique()),
+        "pairs_by_group": m.Class.value_counts().to_dict(), "pairs_by_timepoint": m.Timepoint.value_counts().to_dict(),
+        "pairs_by_batch": m.Batch.value_counts().to_dict(), "pairs_by_id_match": m.id_match.value_counts().to_dict(),
+        "subjects_by_group": m.groupby("Class").Subject.nunique().to_dict(),
+        "sc_without_bulk": sc_un[["sc_sample", "kind", "reason"]].to_dict("records"),
+        "bulk_without_sc": cols[~cols.paired][["bulk_column", "bulk_gsm", "kind", "unpaired_reason"]].to_dict("records"),
+        "rule": ("A pair is one author bulk count-table column and one author sc sample (unsorted fraction) with the "
+                 "same subject and the same timepoint label (T0-T3, or HC). Bulk column <-> GEO GSM by the GEO title "
+                 "name within the same count table (1:1, all 73). Column subject/timepoint from the column name "
+                 "(one typo corrected: PHGR0000074_T0); the sc subject/timepoint are the author metadata Subject and "
+                 "Timepoint (hashtag-defined; cross-checked against the GEO HTO/timepoint table). Technical controls "
+                 "(CHI014, HD_ML/HD_VO) are not paired. No expression, age-sex or order matching creates a pair."),
+    }
+    qc_core._write_json(out / "PAIRING_SUMMARY.json", json.loads(json.dumps(summary, default=lambda x: x.item() if hasattr(x, "item") else str(x))))
+    log({"stage": "pairing", **{k: summary[k] for k in ("pairs_total", "pairs_subjects", "pairs_by_group",
+                                                        "pairs_by_timepoint", "pairs_by_id_match")},
+         "hto_check": {k: hto_check[k] for k in ("selected_cells", "timepoint_agrees_selected")}})
+
+
+# ----------------------------------------------------------------- bulk
+def read_bulk_table(path: Path):
+    header = read_bulk_header(path)
+    ids, rows = [], []
+    with gzip.open(path, "rt", newline="") as handle:
+        reader = csv.reader(handle)
+        next(reader)
+        for line_number, fields in enumerate(reader, start=2):
+            if len(fields) != len(header) + 1:
+                raise ValueError(f"{path.name} line {line_number}: expected symbol + {len(header)} values")
+            ids.append(fields[0])
+            rows.append([float(x) for x in fields[1:]])  # float() raises on any non-numeric token
+    return header, ids, np.asarray(rows, dtype=np.float64)
+
+
+def cmd_bulk(_args) -> None:
+    import qc_bulk
+    verify_bundle()
+    mapper = qc_genes.GeneMapper(REFERENCE)
+    parts = [read_bulk_table(p) for p in BULK_TABLES.values()]
+    ids = parts[0][1]
+    require(all(p[1] == ids for p in parts), "the two bulk tables have different gene rows")
+    require(len(set(ids)) == len(ids), "duplicate gene symbols in the bulk table")
+    require(not any(i.startswith("__") for i in ids), "htseq counter rows present")
+    samples = [c for p in parts for c in p[0]]
+    values = np.concatenate([p[2] for p in parts], axis=1).T.copy()       # samples x genes
+    require(np.isfinite(values).all() and (values >= 0).all() and np.array_equal(values, np.rint(values)),
+            "bulk values must be nonnegative integers")
+    cols = pd.read_csv(RUN / "pairing/bulk_count_columns.csv", dtype=str, keep_default_na=False).set_index("bulk_column")
+    require(list(cols.index) == samples, "bulk column order differs from pairing")
+    (RUN / "bulk").mkdir(exist_ok=True)
+    np.savez_compressed(RUN / "bulk/bulk_source_counts.npz", gene_ids=np.asarray(ids), sample_ids=np.asarray(samples),
+                        gsm=np.asarray([cols.loc[s, "bulk_gsm"] for s in samples]), counts=values)
+    meta = [{"bulk_column": s, "GSM": cols.loc[s, "bulk_gsm"], "subject": cols.loc[s, "subject"],
+             "timepoint": cols.loc[s, "timepoint"], "table_file": cols.loc[s, "table_file"], "kind": cols.loc[s, "kind"],
+             "assigned_gene_total": float(values[j].sum())} for j, s in enumerate(samples)]
+    assay = qc_bulk.BulkInput(
+        ACCESSION, "GSE161918_htseq", "htseq_count_raw_gene_counts", ids, samples, values,
+        symbols=None, present=None, declared_raw_counts=True, sources=list(BULK_TABLES.values()), sample_metadata=meta,
+        caveats=["GEO: PBMC (100,000 cells per sample, unsorted) in Trizol, miRNeasy micro kit, Illumina TruSeq library, "
+                 "STAR alignment, htseq-count 0.9.1 with the UCSC hg19 annotation; strandedness option not stated.",
+                 "Two author tables (batch 1; batches 2+3) with identical 55,765 gene-symbol rows, concatenated by "
+                 "column (23 + 50 = 73 columns = 73 GEO bulk GSMs). Genes are UCSC hg19 symbols (no Ensembl IDs), "
+                 "mapped to the canonical axis by symbol only. htseq '__' counter rows are not in the tables.",
+                 "Technical-control columns (CHI-014, CHI014_B2/B3, HD_ML/HD_VO bc/PBMC) and the author-excluded "
+                 "SHD8 are harmonised but never paired; see pairing/."],
+        extra={"source_format": "CSV (gzip), header 'V2' + sample names, rows = gene symbol + integer values",
+               "source_gene_rows": len(ids)})
+    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"],
+         "duplicate_target_groups_summed": report["duplicate_target_groups_summed_counts"]})
+
+
+# ----------------------------------------------------------------- single cell
+def write_source_h5ad(path: Path, X, barcodes: np.ndarray, ids: list[str], symbols: list[str]) -> None:
+    """Minimal AnnData H5AD holding one author sample's cells unchanged (int32 UMI counts as exported)."""
+    import h5py
+    import qc_singlecell as qs
+    tmp = path.with_suffix(".partial")
+    with h5py.File(tmp, "w") as h:
+        h.attrs["encoding-type"], h.attrs["encoding-version"] = "anndata", "0.1.0"
+        x = h.create_group("X")
+        x.attrs["encoding-type"], x.attrs["encoding-version"] = "csr_matrix", "0.1.0"
+        x.attrs["shape"] = [X.shape[0], X.shape[1]]
+        x.create_dataset("data", data=X.data)
+        x.create_dataset("indices", data=X.indices.astype(np.int32))
+        x.create_dataset("indptr", data=X.indptr.astype(np.int64))
+        qs._h5_dataframe(h, "obs", {}, np.asarray(barcodes, dtype=object))
+        qs._h5_dataframe(h, "var", {"gene_symbols": np.asarray(symbols, dtype=object)}, np.asarray(ids, dtype=object))
+        for name in ("obsm", "varm", "obsp", "varp", "layers", "uns"):
+            g = h.create_group(name)
+            g.attrs["encoding-type"], g.attrs["encoding-version"] = "dict", "0.1.0"
+    os.replace(tmp, path)
+
+
+def export_arrays():
+    p = np.fromfile(EXPORT / "rna_counts_p.int32", dtype="<i4").astype(np.int64)
+    i = np.memmap(EXPORT / "rna_counts_i.int32", dtype="<i4", mode="r")
+    x = np.memmap(EXPORT / "rna_counts_x.int32", dtype="<i4", mode="r")
+    require(len(i) == len(x) == p[-1] and p[0] == 0 and bool((np.diff(p) >= 0).all()), "exported CSR arrays")
+    return p, i, x
+
+
+def process_sample(sample: str) -> dict:
+    import scipy.sparse as sp
+    import qc_singlecell as qs
+
+    qs.COUNT_SOURCE_EVIDENCE[ACCESSION] = COUNT_EVIDENCE  # provenance string only
+    out = RUN / "singlecell" / sample
+    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())
+    summary = {"accession": ACCESSION, "library_id": sample, "status": "RUNNING", "output_dir": str(out),
+               "started": now(), "source": str(RDS)}
+    qc_core._write_json(summary_path, summary)
+    t0 = time.time()
+    try:
+        axis = json.loads((RUN / "singlecell/feature_axis.json").read_text())
+        ids, symbols = axis["ids"], axis["symbols"]
+        n_var = len(ids)
+        mapper = qc_genes.GeneMapper(REFERENCE)
+        mapping = mapper.map_features(ids, symbols)
+        mito = np.asarray([r["mitochondrial"] for r in mapping])
+        obs_all = pd.read_parquet(RUN / "pairing/sc_cell_obs.parquet", filters=[("sample_id", "==", sample)])
+        so = obs_all[obs_all.selected].sort_values("col_index")
+        require(len(so) > 0, f"{sample}: no selected cells")
+        p, ind, val = export_arrays()
+        cols = so.col_index.to_numpy(np.int64)
+        starts, stops = p[cols], p[cols + 1]
+        lengths = stops - starts
+        gather = np.concatenate([np.arange(a, b, dtype=np.int64) for a, b in zip(starts, stops)])
+        indptr = np.concatenate([[0], np.cumsum(lengths)]).astype(np.int64)
+        M = sp.csr_matrix((np.asarray(val[gather]), np.asarray(ind[gather]), indptr), shape=(len(so), n_var))
+        M.sort_indices()
+        require(np.array_equal(M.data, np.rint(M.data)) and (M.data > 0).all(), f"{sample}: non-integer or non-positive stored values")
+        row_sum = np.asarray(M.sum(axis=1, dtype=np.float64)).ravel()
+        require(np.array_equal(row_sum, so.nCount_RNA.astype(float).to_numpy()), f"{sample}: row sums differ from nCount_RNA")
+        require(np.array_equal(np.diff(M.indptr), so.nFeature_RNA.astype(np.int64).to_numpy()), f"{sample}: stored entries differ from nFeature_RNA")
+        src = out / "source_subset.h5ad"
+        barcodes = so.cell.to_numpy()
+        write_source_h5ad(src, M, barcodes, ids, symbols)
+        item = {"accession": ACCESSION, "library_id": sample, "path": str(src), "format": "h5",
+                "duplicate_representation": False, "matrix_path": "X"}
+        rid, rsym, cells, rna, axes = qs.read_axes(item)
+        require(list(rid) == ids and list(rsym) == symbols and np.array_equal(cells, barcodes), f"{sample}: axes changed")
+        cell_obs = pd.DataFrame({
+            "barcode": barcodes, "source_barcode": barcodes, "raw_10x_barcode": so.BARCODE.to_numpy(),
+            "author_cell_id": barcodes, "library_id": sample, "donor_id": so.Subject.to_numpy(),
+            "sample_id": sample, "visit_id": so.Timepoint.to_numpy(), "author_retained": "true",
+            "mapping_basis": ("author Seurat object: demuxlet SNP subject + hashtag (autoHashcalls) timepoint; unsorted "
+                              "fraction (Sorted == N); HTO_classification.global == Singlet; DROPLET.TYPE == SNG"),
+            "protocol": "10x_5prime_NextGEM_v1.1_CITE-seq_GEX", "author_hashtag": so.autoHashcalls.to_numpy(),
+            "author_batch": so.Batch.to_numpy()})
+        cell_obs.to_csv(out / "cell_metadata.csv.gz", index=False, compression="gzip")
+        metrics = out / "metrics"
+        if (metrics / "qc_summary.json").exists():
+            shutil.rmtree(metrics)  # an interrupted earlier attempt; the scan refuses to overwrite
+        qc = qc_core.scan_h5(src, metrics, matrix_path="X", mito_mask=mito, feature_mask=rna,
+                             sample_ids=cell_obs.sample_id.to_numpy())
+        total = np.load(metrics / "cell_total.npy")
+        detected = np.load(metrics / "cell_detected.npy")
+        mito_pct = np.load(metrics / "cell_mito_percent.npy")
+        require(np.array_equal(total, row_sum), f"{sample}: qc cell_total differs from row sums")
+        pd.DataFrame([{"min_genes": g, "min_abundance": 500, "max_mito_percent": mm,
+                       "n_review_pass": int(((detected >= g) & (total >= 500) & (mito_pct <= mm)).sum())}
+                      for g in (100, 200, 500) for mm 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, cell_obs, rna,
+                                     verified_counts=verified, units=units, full_mapping=True)
+        qcpass = np.load(metrics / "flag_conservative_review_pass.npy")
+        all_sum = np.asarray(M.sum(axis=0, dtype=np.float64)).ravel()
+        pass_sum = np.asarray(M[np.flatnonzero(qcpass)].sum(axis=0, dtype=np.float64)).ravel()
+        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=len(so), n_qc_pass=int(qcpass.sum()))
+        where = {g: k for k, g in enumerate(ids)}
+        sex_rows = [where.get(g, -1) for g in SEX_GENES.values()]
+        Mc = M.tocsc()
+        per_cell = np.zeros((len(SEX_GENES), len(so)), dtype=np.float64)
+        for k, r in enumerate(sex_rows):
+            if r >= 0:
+                per_cell[k] = Mc[:, 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)
+        author_mito = so["percent.mito"].astype(float).to_numpy()
+        summary.update({
+            "status": "PASS", "n_cells": int(len(so)), "n_features": n_var, "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,
+            "canonical_export": export,
+            "author_checks": {"row_sum_equals_nCount_RNA": True, "stored_entries_equal_nFeature_RNA": True,
+                              "n_obs_sample_all": int(len(obs_all)), "n_selected": int(len(so)),
+                              "author_percent_mito_max": float(author_mito.max()),
+                              "mito_pct_vs_author_percent_mito_x100_max_abs_diff": float(np.max(np.abs(mito_pct - 100 * author_mito))),
+                              "min_nFeature_RNA": int(detected.min()), "min_nCount_RNA": float(total.min()),
+                              "median_nCount_RNA": float(np.median(total)), "median_nFeature_RNA": float(np.median(detected)),
+                              "source_subset_sha256": item["source_sha256"]},
+            "seconds": round(time.time() - t0, 1), "finished": now()})
+        src.unlink()   # reproducible from rds_export; its sha is recorded above
+        del M, Mc
+    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()
+    ids, symbols, proof = restored_feature_axis()
+    (RUN / "singlecell").mkdir(exist_ok=True)
+    seurat = [line.rstrip("\n") for line in open(EXPORT / "rna_genes.txt")]
+    qc_core._write_json(RUN / "singlecell/feature_axis.json", {"seurat_rownames": seurat, "ids": ids, "symbols": symbols})
+    mapper = qc_genes.GeneMapper(REFERENCE)
+    mapping = mapper.map_features(ids, symbols)
+    mapping_summary = mapper.write_rows(mapping, RUN / "singlecell/gene_mapping")
+    sc = pd.read_csv(RUN / "pairing/sc_samples.csv", dtype=str, keep_default_na=False)
+    samples = sc.sc_sample.tolist()
+    if args.sample:
+        want = set(args.sample.split(","))
+        samples = [s for s in samples if s in want]
+    log({"stage": "sc", "event": "start", "samples": len(samples), "workers": args.workers,
+         "mapping": {k: mapping_summary[k] for k in ("unique_canonical_features_present", "status_counts")}})
+    done = []
+    with ProcessPoolExecutor(max_workers=args.workers) as pool:
+        futures = {pool.submit(process_sample, s): s for s in samples}
+        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.sample:
+        qc_core._write_json(RUN / "singlecell/SINGLECELL_SUMMARY.json",
+                            {"created_at_utc": now(), "gene_mapping": mapping_summary,
+                             "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")
+    sub.add_parser("pairing")
+    sub.add_parser("bulk")
+    p = sub.add_parser("sc")
+    p.add_argument("--workers", type=int, default=6)
+    p.add_argument("--sample", default="", help="comma-separated sample subset (smoke test)")
+    args = parser.parse_args()
+    RUN.mkdir(parents=True, exist_ok=True)
+    {"sources": cmd_sources, "pairing": cmd_pairing, "bulk": cmd_bulk, "sc": cmd_sc}[args.cmd](args)
+
+
+if __name__ == "__main__":
+    main()

paper-releases/pbisc-diffusion/updates/20261002T124820Z-crosscohort-liu-default/diffusion/dataset/server_1/dependency/bfebe0cd9337a2da/liu2021_sanity.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+"""Sanity checks for the Liu 2021 build, computed the same way for giroux2022 and ye2026_sepsis (CPU only).
+
+For every usable row (folds.csv fold >= 0): Pearson r between log1p(CPM) of the bulk and log1p(CPM) of the sc
+pseudobulk (retained cells), over that row's pair_valid genes, CPM taken over the same pair_valid genes in both
+assays.  Also retained cells per row and UMIs per retained cell.  Writes processing/.../SANITY.json.
+"""
+from __future__ import annotations
+
+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=''")
+TASK = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927")
+RUN = Path("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/processing/liu2021_v1_20261002")
+DATASETS = ["liu2021", "giroux2022", "ye2026_sepsis", "imperial_eskd"]
+
+
+def summarise(v: np.ndarray) -> dict:
+    v = np.asarray(v, dtype=float)
+    return {"n": int(v.size), "median": float(np.median(v)), "min": float(v.min()), "max": float(v.max()),
+            "q25": float(np.quantile(v, 0.25)), "q75": float(np.quantile(v, 0.75))}
+
+
+def main() -> None:
+    out = {"definition": ("per usable row (folds.csv fold >= 0): Pearson r of log1p(CPM) bulk vs log1p(CPM) sc "
+                          "pseudobulk (pseudo_raw_sum, retained cells) over the row's pair_valid genes; CPM over the "
+                          "same pair_valid genes in both assays; NaN bulk outside bulk_valid is never used"),
+           "datasets": {}}
+    for ds in DATASETS:
+        d = TASK / "data" / ds
+        f = np.load(d / "features.npz", allow_pickle=False)
+        folds = pd.read_csv(d / "folds.csv")
+        if not np.array_equal(folds.sample_id.astype(str).to_numpy(), f["sample_ids"].astype(str)):
+            raise SystemExit(f"{ds}: folds.csv order differs from features.npz")
+        use = folds.fold.to_numpy() >= 0
+        rs, umi_med = [], []
+        for r in np.flatnonzero(use):
+            pv = f["pair_valid"][r].astype(bool)
+            b = f["bulk_raw"][r][pv].astype(float)
+            s = f["pseudo_raw_sum"][r][pv].astype(float)
+            if not (np.isfinite(b).all() and np.isfinite(s).all()):
+                raise SystemExit(f"{ds} row {r}: non-finite value on pair_valid genes")
+            lb = np.log1p(b / b.sum() * 1e6)
+            ls = np.log1p(s / s.sum() * 1e6)
+            rs.append(float(np.corrcoef(lb, ls)[0, 1]))
+        obs = pd.read_parquet(d / "cells_obs.parquet", columns=["row_sample", "raw_gex_total", "cell_total_canonical"])
+        per_row = obs.groupby("row_sample").raw_gex_total.median()
+        cells = f["qc_cell_counts"][use]
+        rec = {"rows": int(len(use)), "usable_rows": int(use.sum()),
+               "pearson_log1p_cpm_bulk_vs_pseudobulk": summarise(rs),
+               "pair_valid_genes_per_row": summarise(f["pair_valid"][use].sum(1)),
+               "retained_cells_per_usable_row": summarise(cells),
+               "retained_cells_total_usable_rows": int(cells.sum()),
+               "umi_per_cell_source_median_all_cells_usable_rows": float(np.median(obs.raw_gex_total[np.isin(obs.row_sample, np.flatnonzero(use))])),
+               "umi_per_cell_canonical_median_all_cells_usable_rows": float(np.median(obs.cell_total_canonical[np.isin(obs.row_sample, np.flatnonzero(use))])),
+               "umi_per_cell_source_median_of_row_medians": float(np.median(per_row.loc[np.flatnonzero(use)]))}
+        if ds == "liu2021":
+            rec["per_row"] = pd.DataFrame({"sample_id": f["sample_ids"][use].astype(str), "batch": f["batch"][use].astype(str),
+                                           "r": rs, "cells": cells,
+                                           "umi_median": per_row.loc[np.flatnonzero(use)].to_numpy()}).round(4).to_dict("records")
+            byb = pd.DataFrame(rec["per_row"]).groupby("batch")
+            rec["by_batch"] = {b: {"rows": int(len(g)), "r_median": float(g.r.median()), "cells_median": float(g.cells.median()),
+                                   "umi_median_of_row_medians": float(g.umi_median.median())} for b, g in byb}
+        out["datasets"][ds] = rec
+        print(ds, json.dumps({k: v for k, v in rec.items() if k not in ("per_row",)}, default=float))
+    (RUN / "SANITY.json").write_text(json.dumps(out, indent=1, default=float) + "\n")
+
+
+if __name__ == "__main__":
+    main()