Archive 4 checkpoints (1-4)

paper-releases/20260928/diffusion/data/source_prep/imperial_eskd/code/strict_qc_v1_code_bundle_v5/qc_genes.py

@@ -0,0 +1,434 @@
+#!/usr/bin/env python3
+"""Frozen model-axis gene mapping; never transforms or aggregates expression.
+
+Only identity membership is established. An absent feature is missing, not a
+measured zero. Presence in a supplied feature table is not proof that the
+experiment assayed an all-zero feature (some pipelines export padded tables).
+"""
+from __future__ import annotations
+
+import argparse
+from collections import Counter, defaultdict
+import csv
+from datetime import datetime, timezone
+import gzip
+import hashlib
+import json
+from pathlib import Path
+import re
+import shutil
+from typing import Sequence
+
+BASE = Path(__file__).resolve().parents[1]
+DEFAULT_REFERENCE = BASE / "processing/strict_qc_v1_20260913/reference"
+PBISC = Path("/home/sj_server_1/PBISC/immun-pbmc-fm")
+CONTRACT = PBISC / "B048_test/shared/contracts/b048_baseline.json"
+PARENT_REFERENCE = BASE.parent / "reference"
+ENSEMBL_PATTERN = re.compile(r"^(ENSG\d{11})(?:\.(\d+))?(_PAR_Y)?$")
+
+
+def sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for block in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def read_tsv(path: Path) -> list[dict[str, str]]:
+    opener = gzip.open if path.suffix == ".gz" else open
+    with opener(path, "rt", encoding="utf-8-sig", newline="") as handle:
+        return list(csv.DictReader(handle, delimiter="\t"))
+
+
+def write_tsv(path: Path, rows: Sequence[dict], fields: Sequence[str]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", encoding="utf-8", newline="") as handle:
+        writer = csv.DictWriter(handle, fieldnames=fields, delimiter="\t", extrasaction="ignore")
+        writer.writeheader()
+        writer.writerows(rows)
+
+
+def clean_token(value: object) -> str:
+    if value is None:
+        return ""
+    if isinstance(value, bytes):
+        value = value.decode("utf-8", errors="strict")
+    text = str(value).strip()
+    return "" if text in {"", "nan", "None", "<NA>"} else text
+
+
+def stable_ensembl(value: str) -> tuple[str, bool, bool]:
+    """Strip ONLY a numeric gene version. Preserve the locus-bearing PAR suffix."""
+    match = ENSEMBL_PATTERN.fullmatch(value)
+    if not match:
+        return value, False, False
+    return match[1] + (match[3] or ""), bool(match[2]), bool(match[3])
+
+
+def split_hgnc(value: str) -> list[str]:
+    return [x.strip().strip('"') for x in value.split("|") if x.strip().strip('"')]
+
+
+class GeneMapper:
+    """Map features to the exact frozen B048 panel with per-row audit evidence.
+
+    target_index == -1 means excluded/unresolved. Mapped conflicting Ensembl
+    IDs retain their authoritative target and set symbol_conflict=True.
+    Duplicate rows are never collapsed here; target_multiplicity makes later
+    count-only aggregation or a refusal an explicit caller decision.
+    """
+
+    def __init__(self, reference_dir: Path | str = DEFAULT_REFERENCE):
+        self.reference_dir = Path(reference_dir)
+        manifest_path = self.reference_dir / "REFERENCE_MANIFEST.json"
+        self.manifest = json.loads(manifest_path.read_text())
+        for item in self.manifest["frozen_files"]:
+            path = self.reference_dir / item["frozen_name"]
+            if sha256(path) != item["sha256"]:
+                raise ValueError(f"Frozen gene reference hash mismatch: {path}")
+        self._initialize(
+            read_tsv(self.reference_dir / "canonical_genes.tsv"),
+            read_tsv(self.reference_dir / "ensembl109_genes.tsv.gz"),
+            read_tsv(self.reference_dir / "hgnc_complete_set_frozen.tsv"),
+            read_tsv(self.reference_dir / "hgnc_withdrawn_frozen.tsv"),
+        )
+        if len(self.canonical) != self.manifest["canonical_gene_count"]:
+            raise ValueError("Canonical gene count differs from reference manifest")
+
+    @classmethod
+    def from_records(cls, canonical: Sequence[dict], ensembl: Sequence[dict] = (),
+                     hgnc: Sequence[dict] = (), withdrawn: Sequence[dict] = ()) -> "GeneMapper":
+        """Small in-memory constructor for focused identity tests only."""
+        mapper = cls.__new__(cls)
+        mapper.reference_dir = None
+        mapper.manifest = {"canonical_gene_count": len(canonical)}
+        mapper._initialize(canonical, ensembl, hgnc, withdrawn)
+        return mapper
+
+    def _initialize(self, canonical: Sequence[dict], ensembl: Sequence[dict],
+                    hgnc: Sequence[dict], withdrawn: Sequence[dict]) -> None:
+        self.canonical = sorted((dict(r) for r in canonical), key=lambda r: int(r["panel_index"]))
+        self.canonical_size = len(self.canonical)
+        indexes = [int(r["panel_index"]) for r in self.canonical]
+        if indexes != list(range(len(indexes))):
+            raise ValueError("Canonical panel indices must be contiguous and zero based")
+        self.by_id = {r["gene_id"]: r for r in self.canonical}
+        if len(self.by_id) != len(self.canonical):
+            raise ValueError("Duplicate canonical stable Ensembl gene IDs")
+        if any(r.get("gene_biotype") != "protein_coding" for r in self.canonical):
+            raise ValueError("Canonical model axis must contain only protein_coding genes")
+        self.info: dict[str, dict] = {}
+        self.canonical_symbols: dict[str, set[str]] = defaultdict(set)
+        self.approved_symbols: dict[str, set[str]] = defaultdict(set)
+        self.ensembl_symbols: dict[str, set[str]] = defaultdict(set)
+        self.previous_symbols: dict[str, set[str]] = defaultdict(set)
+        self.alias_symbols: dict[str, set[str]] = defaultdict(set)
+        self.withdrawn_symbols = {r.get("WITHDRAWN_SYMBOL", r.get("symbol", "")) for r in withdrawn}
+        self.withdrawn_symbols.discard("")
+        for r in ensembl:
+            gid = r["ensembl_gene_id"]
+            self.info[gid] = {"gene_id": gid, "gene_symbol": r.get("gene_name", ""),
+                              "chromosome": r.get("seqname", ""), "gene_biotype": r.get("gene_biotype", "")}
+            if r.get("gene_name"):
+                self.ensembl_symbols[r["gene_name"]].add(gid)
+        for r in self.canonical:
+            self.info[r["gene_id"]] = r  # Canonical release takes precedence for annotation.
+            if r.get("gene_symbol"):
+                self.canonical_symbols[r["gene_symbol"]].add(r["gene_id"])
+        for r in hgnc:
+            symbol = r.get("symbol", "")
+            if r.get("status") != "Approved":
+                if symbol:
+                    self.withdrawn_symbols.add(symbol)
+                continue
+            genes = {stable_ensembl(g)[0] for g in split_hgnc(r.get("ensembl_gene_id", ""))
+                     if ENSEMBL_PATTERN.fullmatch(g)}
+            if not genes:
+                genes = set(self.canonical_symbols.get(symbol, set()))
+            if not genes:
+                genes = {r.get("hgnc_id", "HGNC_UNMAPPED:" + symbol)}
+            self.approved_symbols[symbol].update(genes)
+            for gid in genes:
+                if gid not in self.info:
+                    self.info[gid] = {"gene_id": gid, "gene_symbol": symbol,
+                                      "chromosome": "MT" if r.get("location") == "mitochondria" else "",
+                                      "gene_biotype": "protein_coding" if r.get("locus_group") == "protein-coding gene" else r.get("locus_type", "")}
+                if "Cytoplasmic ribosomal proteins" in r.get("gene_group", ""):
+                    self.info[gid]["hgnc_cytoplasmic_ribosomal"] = True
+            for previous in split_hgnc(r.get("prev_symbol", "")):
+                self.previous_symbols[previous].update(genes)
+            for alias in split_hgnc(r.get("alias_symbol", "")):
+                self.alias_symbols[alias].update(genes)
+
+    def _symbol(self, symbol: str) -> tuple[set[str], str, list[str]]:
+        if not symbol:
+            return set(), "empty_symbol", []
+        # Multiple GENCODE loci must remain ambiguous even if older HGNC stores
+        # just one locus (notably the distinct X/Y PAR loci in GENCODE v49).
+        canonical = self.canonical_symbols.get(symbol, set())
+        approved = self.approved_symbols.get(symbol, set())
+        exact = canonical | approved
+        if exact:
+            method = "canonical_symbol" if canonical else "approved_symbol"
+            other = (self.previous_symbols.get(symbol, set()) | self.alias_symbols.get(symbol, set())) - exact
+            warnings = ["exact_symbol_also_alias_of:" + ",".join(sorted(other))] if other else []
+            return exact, method, warnings
+        if symbol in self.withdrawn_symbols:
+            return set(), "withdrawn_symbol", []
+        previous = self.previous_symbols.get(symbol, set())
+        aliases = self.alias_symbols.get(symbol, set())
+        if previous or aliases:
+            return previous | aliases, "previous_symbol" if previous else "alias_symbol", []
+        # Ensembl109 is used for all-feature QC annotation, not unchecked
+        # historical symbol-to-model reassignment.
+        legacy = self.ensembl_symbols.get(symbol, set())
+        if legacy:
+            return legacy, "ensembl109_symbol_annotation_only", []
+        return set(), "unmapped_symbol", []
+
+    def map_features(self, ids: Sequence[object], symbols: Sequence[object] | None = None) -> list[dict]:
+        if symbols is not None and len(ids) != len(symbols):
+            raise ValueError("Feature IDs and symbols differ in length")
+        rows: list[dict] = []
+        for index, value in enumerate(ids):
+            raw = clean_token(value)
+            supplied_symbol = clean_token(symbols[index]) if symbols is not None else ""
+            stable, version_stripped, par_y = stable_ensembl(raw)
+            ensembl = bool(ENSEMBL_PATTERN.fullmatch(raw))
+            evidence: list[str] = []
+            target = -1
+            conflict = False
+            candidates: set[str] = set()
+            gid = stable if ensembl else ""
+            if ensembl:
+                evidence.append("numeric_version_stripped" if version_stripped else "unversioned_ensembl")
+                if par_y:
+                    status = "excluded_par_y_identity"
+                    evidence.append("PAR_Y_preserved;assembly_crosswalk_required;never_collapse_to_X")
+                elif stable in self.by_id:
+                    target = int(self.by_id[stable]["panel_index"])
+                    status = "mapped_ensembl"
+                    evidence.append("exact_canonical_stable_id")
+                elif stable in self.info:
+                    status = "excluded_outside_canonical"
+                    evidence.append("known_stable_id_absent_from_model_axis;no_symbol_rescue")
+                else:
+                    status = "unknown_ensembl_id"
+                    evidence.append("unknown_stable_id;no_symbol_rescue")
+                if supplied_symbol:
+                    symbol_ids, method, warning = self._symbol(supplied_symbol)
+                    evidence += warning
+                    candidates = symbol_ids
+                    if symbol_ids and stable not in symbol_ids:
+                        conflict = True
+                        evidence.append("source_id_symbol_conflict:" + ",".join(sorted(symbol_ids)))
+                        if target >= 0:
+                            status = "mapped_ensembl_symbol_conflict"
+                    elif len(symbol_ids) > 1:
+                        evidence.append("source_symbol_ambiguous_but_authoritative_id_retained")
+                    elif not symbol_ids:
+                        evidence.append("source_symbol_unresolved:" + method)
+            else:
+                symbol = supplied_symbol or raw
+                candidates, method, warnings = self._symbol(symbol)
+                evidence = [method] + warnings
+                if raw and supplied_symbol and raw != supplied_symbol:
+                    id_candidates, _, _ = self._symbol(raw)
+                    if id_candidates and candidates and id_candidates != candidates:
+                        conflict = True
+                        candidates |= id_candidates
+                        evidence.append("two_symbol_columns_conflict;reject_union")
+                if len(candidates) > 1:
+                    status = "ambiguous_symbol"
+                elif not candidates:
+                    status = "excluded_withdrawn_symbol" if method == "withdrawn_symbol" else "unmapped_symbol"
+                else:
+                    gid = next(iter(candidates))
+                    if method == "ensembl109_symbol_annotation_only":
+                        status = "excluded_legacy_symbol_annotation_only"
+                    elif gid in self.by_id:
+                        target = int(self.by_id[gid]["panel_index"])
+                        status = "mapped_" + method
+                    else:
+                        status = "excluded_outside_canonical"
+            info = self.info.get(gid, {})
+            chromosome = str(info.get("chromosome", ""))
+            resolved_symbol = str(info.get("gene_symbol", ""))
+            mito = chromosome in {"M", "MT", "chrM", "chrMT"}
+            ribo = bool(info.get("hgnc_cytoplasmic_ribosomal", False)) or (
+                info.get("gene_biotype") == "protein_coding"
+                and bool(re.fullmatch(r"RP[SL](?:\d+[A-Z]*|[AP]\d*)", resolved_symbol))
+            )
+            rows.append({"source_index": index, "source_id": raw, "source_symbol": supplied_symbol,
+                         "stable_id": stable if ensembl else gid, "target_index": target,
+                         "target_gene_id": self.canonical[target]["gene_id"] if target >= 0 else "",
+                         "target_gene_symbol": self.canonical[target]["gene_symbol"] if target >= 0 else "",
+                         "status": status, "evidence": ";".join(evidence),
+                         "candidate_ids": "|".join(sorted(candidates)),
+                         "version_stripped": version_stripped, "par_y_suffix": par_y,
+                         "symbol_conflict": conflict, "resolved_symbol": resolved_symbol,
+                         "chromosome": chromosome, "source_biotype": info.get("gene_biotype", ""),
+                         "mitochondrial": mito, "ribosomal": ribo,
+                         "qc_annotation_resolved": bool(info)})
+        id_counts = Counter(r["source_id"] for r in rows if r["source_id"])
+        stable_counts = Counter(r["stable_id"] for r in rows if r["stable_id"])
+        target_counts = Counter(r["target_index"] for r in rows if r["target_index"] >= 0)
+        for row in rows:
+            row["source_id_multiplicity"] = id_counts.get(row["source_id"], 0)
+            row["stable_id_multiplicity"] = stable_counts.get(row["stable_id"], 0)
+            row["target_multiplicity"] = target_counts.get(row["target_index"], 0)
+        return rows
+
+    def summarize(self, rows: Sequence[dict]) -> dict:
+        targets = Counter(r["target_index"] for r in rows if r["target_index"] >= 0)
+        return {"schema": "strict_gene_mapping_summary_v1", "source_features": len(rows),
+                "canonical_genes": len(self.canonical), "mapped_source_features": sum(targets.values()),
+                "unique_canonical_features_present": len(targets),
+                "canonical_coverage_fraction": len(targets) / len(self.canonical) if self.canonical else 0,
+                "canonical_features_absent": len(self.canonical) - len(targets),
+                "ambiguous_features": sum(r["status"] == "ambiguous_symbol" for r in rows),
+                "unmapped_or_excluded_features": sum(r["target_index"] < 0 for r in rows),
+                "version_stripped_features": sum(r["version_stripped"] for r in rows),
+                "source_id_symbol_conflicts": sum(r["symbol_conflict"] for r in rows),
+                "duplicate_source_id_rows": sum(r["source_id_multiplicity"] > 1 for r in rows),
+                "duplicate_target_groups": sum(n > 1 for n in targets.values()),
+                "duplicate_target_rows": sum(n for n in targets.values() if n > 1),
+                "mitochondrial_features_source_axis": sum(r["mitochondrial"] for r in rows),
+                "ribosomal_features_source_axis": sum(r["ribosomal"] for r in rows),
+                "source_qc_annotation_unresolved_features": sum(not r["qc_annotation_resolved"] for r in rows),
+                "status_counts": dict(sorted(Counter(r["status"] for r in rows).items())),
+                "presence_mask_semantics": "source_feature_table_membership;not_detection_or_proof_of_assay_coverage",
+                "absent_feature_policy": "masked_missing;never_observed_zero",
+                "duplicate_policy": "flag_only;no_expression_aggregation_performed",
+                "expression_transformation": "none",
+                "canonical_file_sha256": self.manifest.get("canonical_panel_file_sha256"),
+                "canonical_identity_sha256": self.manifest.get("canonical_identity_sha256")}
+
+    def write_mapping(self, ids: Sequence[object], symbols: Sequence[object] | None = None,
+                      output_prefix: Path | str | None = None) -> dict:
+        if output_prefix is None:
+            raise ValueError("output_prefix is required")
+        rows = self.map_features(ids, symbols)
+        return self.write_rows(rows, output_prefix)
+
+    def write_rows(self, rows: Sequence[dict], output_prefix: Path | str) -> dict:
+        prefix = str(output_prefix)
+        fields = list(rows[0]) if rows else ["source_index", "source_id", "target_index", "status", "evidence"]
+        write_tsv(Path(prefix + ".mapping.tsv"), rows, fields)
+        summary = self.summarize(rows)
+        Path(prefix + ".summary.json").write_text(json.dumps(summary, indent=2) + "\n")
+        targets = Counter(r["target_index"] for r in rows if r["target_index"] >= 0)
+        mask = [{"panel_index": i, "gene_id": r["gene_id"], "gene_symbol": r["gene_symbol"],
+                 "source_feature_present": i in targets, "source_rows_mapped": targets.get(i, 0),
+                 "missing_semantics": "" if i in targets else "not_in_supplied_feature_table;do_not_treat_as_observed_zero"}
+                for i, r in enumerate(self.canonical)]
+        write_tsv(Path(prefix + ".presence_mask.tsv"), mask,
+                  ["panel_index", "gene_id", "gene_symbol", "source_feature_present", "source_rows_mapped", "missing_semantics"])
+        return summary
+
+
+def freeze_reference(reference_dir: Path | str = DEFAULT_REFERENCE) -> dict:
+    """Freeze existing validated artifacts; no network or reference upgrade."""
+    import pandas as pd  # Only needed once to read the 755 KB canonical parquet.
+
+    destination = Path(reference_dir)
+    destination.mkdir(parents=True, exist_ok=True)
+    contract = json.loads(CONTRACT.read_text())
+    panel_path = Path(contract["gene_panel_path"])
+    panel_hash = sha256(panel_path)
+    if panel_hash != contract["gene_panel_file_sha256"]:
+        raise ValueError("Canonical model panel differs from frozen B048 contract")
+    panel = pd.read_parquet(panel_path)
+    columns = ["gene_id", "gene_symbol", "panel_index"]
+    records = [{column: str(row[column]) for column in columns} for _, row in panel.iterrows()]
+    identity_hash = hashlib.sha256(json.dumps(records, ensure_ascii=False, sort_keys=True,
+                                             separators=(",", ":")).encode()).hexdigest()
+    if identity_hash != contract["gene_order_sha256"]:
+        raise ValueError("Ordered model identity hash differs from frozen B048 contract")
+    if len(panel) != 20097 or not panel.gene_id.is_unique or set(panel.gene_biotype) != {"protein_coding"}:
+        raise ValueError("Canonical model-axis cardinality, uniqueness, or biotype check failed")
+    if panel.panel_index.tolist() != list(range(20097)):
+        raise ValueError("Canonical parquet row order differs from its panel_index")
+    files = [(panel_path, "canonical_var.parquet"), (CONTRACT, "b048_baseline_contract.json"),
+             (PBISC / "model/vae_bulk2sc/method_1/src/method1/gene_alignment.py", "model_gene_alignment_hash_source.py"),
+             (BASE / "README.md", "datalake_readme_at_reference_freeze.md"),
+             (PARENT_REFERENCE / "ensembl/ensembl109_genes.tsv.gz", "ensembl109_genes.tsv.gz"),
+             (PARENT_REFERENCE / "ensembl/ensembl109_panel_stats.json", "ensembl109_panel_stats.json"),
+             (PARENT_REFERENCE / "hgnc/hgnc_complete_set_frozen.tsv", "hgnc_complete_set_frozen.tsv"),
+             (PARENT_REFERENCE / "hgnc/hgnc_withdrawn_frozen.tsv", "hgnc_withdrawn_frozen.tsv")]
+    frozen_files = []
+    for source, name in files:
+        target = destination / name
+        digest = sha256(source)
+        if target.exists() and sha256(target) != digest:
+            raise ValueError(f"Refusing to overwrite changed frozen reference: {target}")
+        if not target.exists():
+            shutil.copy2(source, target)
+        frozen_files.append({"source_path": str(source), "source_resolved_path": str(source.resolve()),
+                             "frozen_name": name, "sha256": digest, "bytes": source.stat().st_size})
+    canonical_path = destination / "canonical_genes.tsv"
+    panel["target_index"] = panel["panel_index"]
+    canonical_columns = ["target_index", "panel_index", "gene_id", "gene_symbol", "gene_biotype", "chromosome", "start", "end"]
+    canonical_text = panel[canonical_columns].to_csv(sep="\t", index=False)
+    if canonical_path.exists() and canonical_path.read_text() != canonical_text:
+        raise ValueError("Refusing to overwrite changed canonical TSV")
+    canonical_path.write_text(canonical_text)
+    frozen_files.append({"source_path": str(panel_path), "frozen_name": canonical_path.name,
+                         "sha256": sha256(canonical_path), "bytes": canonical_path.stat().st_size,
+                         "derivation": "ordered identity/annotation columns from hash-verified canonical parquet"})
+    reference109 = read_tsv(destination / "ensembl109_genes.tsv.gz")
+    old_pc = {r["ensembl_gene_id"] for r in reference109 if r["gene_biotype"] == "protein_coding"}
+    canonical_ids = set(panel.gene_id)
+    duplicate_symbols = panel[panel.gene_symbol.duplicated(False)][canonical_columns].to_dict("records")
+    write_tsv(destination / "canonical_ambiguous_symbols.tsv", duplicate_symbols, canonical_columns)
+    compatibility = {
+        "canonical_genes": len(canonical_ids), "ensembl109_protein_coding_genes_all_contigs": len(old_pc),
+        "intersection": len(canonical_ids & old_pc), "canonical_only": len(canonical_ids - old_pc),
+        "ensembl109_pc_only": len(old_pc - canonical_ids),
+        "canonical_duplicated_symbol_groups": len({r["gene_symbol"] for r in duplicate_symbols}),
+        "canonical_duplicated_symbol_genes": len(duplicate_symbols),
+        "canonical_only_ids": sorted(canonical_ids - old_pc), "ensembl109_pc_only_ids": sorted(old_pc - canonical_ids),
+        "decision": "model_axis_unchanged;Ensembl109_and_HGNC_are_auxiliary_annotation_only;no_reference_upgrade"}
+    (destination / "COMPATIBILITY_AUDIT.json").write_text(json.dumps(compatibility, indent=2) + "\n")
+    manifest = {"schema": "strict_qc_gene_reference_v1", "created_at_utc": datetime.now(timezone.utc).isoformat(),
+                "canonical_label": "PBISC B048 GENCODE v49 protein_coding model panel",
+                "canonical_gene_count": len(panel), "canonical_panel_file_sha256": panel_hash,
+                "canonical_identity_sha256": identity_hash,
+                "identity_hash_serialization": "ordered {gene_id,gene_symbol,panel_index} string records;json ensure_ascii=False sort_keys=True separators=(',',':')",
+                "label_provenance": "local datalake README and PBISC model contract;original full GENCODE49 GTF not re-downloaded",
+                "auxiliary_hgnc_snapshot": "existing local frozen 2023 snapshot;not asserted current",
+                "frozen_files": frozen_files, "compatibility_audit": "COMPATIBILITY_AUDIT.json"}
+    manifest_path = destination / "REFERENCE_MANIFEST.json"
+    if manifest_path.exists():
+        previous = json.loads(manifest_path.read_text())
+        if previous["frozen_files"] != frozen_files:
+            raise ValueError("Frozen reference manifest differs; create a new version instead")
+        return previous
+    manifest_path.write_text(json.dumps(manifest, indent=2) + "\n")
+    return manifest
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--reference-dir", type=Path, default=DEFAULT_REFERENCE)
+    parser.add_argument("--freeze", action="store_true")
+    parser.add_argument("--input-tsv", type=Path)
+    parser.add_argument("--id-column", default="gene_id")
+    parser.add_argument("--symbol-column")
+    parser.add_argument("--output-prefix", type=Path)
+    args = parser.parse_args()
+    if args.freeze:
+        print(json.dumps(freeze_reference(args.reference_dir), indent=2))
+    if args.input_tsv:
+        if not args.output_prefix:
+            parser.error("--output-prefix required with --input-tsv")
+        mapper = GeneMapper(args.reference_dir)
+        records = read_tsv(args.input_tsv)
+        ids = [r[args.id_column] for r in records]
+        symbols = [r[args.symbol_column] for r in records] if args.symbol_column else None
+        print(json.dumps(mapper.write_mapping(ids, symbols, args.output_prefix), indent=2))
+
+
+if __name__ == "__main__":
+    main()

paper-releases/20260928/diffusion/data/source_prep/imperial_eskd/code/strict_qc_v1_code_bundle_v5/qc_singlecell.py

@@ -0,0 +1,667 @@
+"""Organize single-cell files, audit numbers and identities, export sparse H5AD.
+
+No biological inference is performed. Original cells are retained; thresholds
+are reversible annotations. Published metadata is joined on explicit keys.
+"""
+from __future__ import annotations
+
+from collections import Counter
+import csv
+import gc
+import gzip
+import hashlib
+import json
+import os
+from pathlib import Path
+import re
+from typing import Iterator
+
+import h5py
+import numpy as np
+import pandas as pd
+from scipy import sparse
+from scipy.io import mmread
+
+from qc_core import QCError, _h5_column, _h5_index, _strings, _text_open, _write_json, scan_h5, scan_mtx, sha256_file
+from qc_genes import GeneMapper
+
+
+SC_ACCESSIONS = {"GSE132044", "GSE155673", "GSE161610", "GSE162632", "GSE198616",
+                 "GSE201534", "GSE246937", "GSE247707", "GSE253173", "GSE314416"}
+MAX_MTX_ALLOCATION_ESTIMATE = 4 * 1024**3
+COUNT_SOURCE_EVIDENCE = {
+    "GSE132044": "Published protocol benchmark pbmc_hg38_count_matrix; read/UMI units kept separate by published barcode protocol",
+    "GSE155673": "Published 10x covXX RNA matrix/features/barcodes companions",
+    "GSE161610": "Published 10x PB patient feature-barcode count matrices",
+    "GSE162632": "Published Bx-cx-10X expression count matrices",
+    "GSE198616": "Published 10x PBMC/monocyte feature-barcode expression count matrices",
+    "GSE201534": "Published 10x filtered_feature_bc_matrix.h5 with independent MTX representation",
+    "GSE246937": "Published 10x pooled feature-barcode matrices; antibody features excluded from RNA counts",
+    "GSE247707": "Published 10x PBMC_Pooled feature-barcode matrix; author-filtering status separate",
+    "GSE314416": "Published GEX.h5 10x gene-expression counts; separate ADT files omitted",
+}
+
+
+def _stem(path: Path) -> str:
+    return re.sub(r"(?:_?count_?)?matrix\.mtx(?:\.gz)?$", "", path.name, flags=re.I).rstrip("_")
+
+
+def discover_libraries(root: Path, runroot: Path) -> list[dict]:
+    """Find expression sources; prefer 10x H5 when matching MTX also exists."""
+    libraries = []
+    for accession in sorted(SC_ACCESSIONS):
+        paths = sorted({p for base in (root / "datasets" / accession / "raw", runroot / "extracted" / accession)
+                        if base.exists() for p in base.rglob("*") if p.is_file()})
+        h5_sources = [p for p in paths if p.suffix.lower() in (".h5", ".h5ad") and "_adt" not in p.name.lower()]
+        h5_gsm = {re.search(r"GSM\d+", str(p)).group() for p in h5_sources if re.search(r"GSM\d+", str(p))}
+        for path in paths:
+            is_mtx = bool(re.search(r"matrix\.mtx(?:\.gz)?$", path.name, re.I))
+            if path not in h5_sources and not is_mtx:
+                continue
+            if (accession == "GSE247707" and "pbmc" not in path.name.lower()) or (accession == "GSE161610" and re.search(r"(?:_|/)LN\d", str(path))):
+                continue
+            match = re.search(r"GSM\d+", str(path))
+            library = match.group() if match else (_stem(path) if is_mtx else path.stem)
+            if not library:
+                library = path.parent.name
+            item = {"accession": accession, "library_id": library, "path": str(path),
+                    "format": "mtx" if is_mtx else "h5", "duplicate_representation": bool(is_mtx and match and library in h5_gsm)}
+            if is_mtx:
+                prefix = _stem(path)
+                siblings = list(path.parent.iterdir())
+                feature_names = [(prefix + "_" if prefix else "") + part + suffix
+                                 for part in ("features", "genes", "gene") for suffix in (".tsv.gz", ".tsv")]
+                barcode_names = [(prefix + "_" if prefix else "") + part + suffix
+                                 for part in ("barcodes", "cell", "cells") for suffix in (".tsv.gz", ".tsv")]
+                feature = next((p for p in siblings if p.name.lower() in [n.lower() for n in feature_names]), None)
+                barcode = next((p for p in siblings if p.name.lower() in [n.lower() for n in barcode_names]), None)
+                if accession == "GSE155673":
+                    feature = root / "datasets/GSE155673/raw/GSE155673_features.tsv.gz"
+                if accession == "GSE132044":
+                    feature = root / "datasets/GSE132044/raw/GSE132044_pbmc_hg38_gene.tsv.gz"
+                    barcode = root / "datasets/GSE132044/raw/GSE132044_pbmc_hg38_cell.tsv.gz"
+                item["features_path"] = str(feature) if feature else ""
+                item["barcodes_path"] = str(barcode) if barcode else ""
+            libraries.append(item)
+    return sorted(libraries, key=lambda item: (item["duplicate_representation"], item["accession"], item["library_id"]))
+
+
+def read_axes(item: dict) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, dict]:
+    path = Path(item["path"])
+    if item["format"] == "mtx":
+        if not item["features_path"] or not item["barcodes_path"]:
+            raise QCError("Missing paired feature or barcode file")
+        with _text_open(item["features_path"]) as handle:
+            rows = [line.rstrip("\n\r").split("\t") for line in handle if line.strip()]
+        ids = [row[0] for row in rows]
+        symbols = [row[1] if len(row) > 1 else row[0] for row in rows]
+        if item["accession"] == "GSE132044":
+            ids = [value.split("_", 1)[0] for value in ids]
+            symbols = [row[0].split("_", 1)[1] if "_" in row[0] else row[0] for row in rows]
+        rna = np.asarray([len(row) < 3 or row[2] == "Gene Expression" for row in rows])
+        with _text_open(item["barcodes_path"]) as handle:
+            cells = [line.rstrip("\n\r").split("\t")[0] for line in handle if line.strip()]
+        return np.asarray(ids), np.asarray(symbols), np.asarray(cells), rna, {"matrix_path": None, "source": "feature/barcode companion files"}
+    with h5py.File(path, "r", rdcc_nbytes=256 * 1024**2) as handle:
+        if "matrix" in handle:
+            matrix = handle["matrix"]
+            features = matrix["features"]
+            ids = _strings(features["id"])
+            symbols = _strings(features["name"]) if "name" in features else ids
+            rna = _strings(features["feature_type"]) == "Gene Expression" if "feature_type" in features else np.ones(len(ids), bool)
+            cells = _strings(matrix["barcodes"])
+            return ids, symbols, cells, rna, {"matrix_path": "matrix", "source": "10x H5 embedded axes"}
+        matrix_path = item.get("matrix_path", "X")
+        var = handle["raw/var"] if matrix_path.startswith("raw/") else handle["var"]
+        ids = _h5_index(var)
+        symbols = None
+        for name in ("gene", "gene_symbols", "gene_symbol", "feature_name", "symbol"):
+            if name in var:
+                symbols = _h5_column(var, name)
+                break
+        if symbols is None:
+            symbols = ids
+        cells = _h5_index(handle["obs"])
+        return ids, symbols, cells, np.ones(len(ids), bool), {"matrix_path": matrix_path, "source": "H5AD embedded axes"}
+
+
+def _read_csv(path: Path) -> pd.DataFrame:
+    return pd.read_csv(path, dtype=str, keep_default_na=False) if path.exists() else pd.DataFrame()
+
+
+def assign_metadata(item: dict, cells: np.ndarray, runroot: Path) -> tuple[pd.DataFrame, dict]:
+    accession, library = item["accession"], item["library_id"]
+    source_cells = np.asarray(cells, dtype=str)
+    if np.any(np.char.strip(source_cells) == "") or len(np.unique(source_cells)) != len(source_cells):
+        raise QCError("Source library cell identifiers are empty or nonunique")
+    obs = pd.DataFrame({"barcode": source_cells, "source_barcode": source_cells,
+                        "raw_10x_barcode": "", "author_cell_id": "", "library_id": library, "donor_id": "", "sample_id": "", "visit_id": "",
+                        "author_retained": "unknown", "mapping_basis": "unresolved", "protocol": ""})
+    key_representation = "unresolved"
+    audit = runroot / "pairing_audit"
+    mapping_path = audit / (accession + "_cell_map.csv.gz")
+    if mapping_path.exists():
+        # Avoid retaining the complete project mapping across 54 pooled libraries.
+        pieces = []
+        for chunk in pd.read_csv(mapping_path, dtype=str, keep_default_na=False, chunksize=100_000):
+            subset = chunk[chunk.library_id == library]
+            if len(subset):
+                pieces.append(subset)
+        if pieces:
+            mapping = pd.concat(pieces, ignore_index=True)
+            if mapping.duplicated(["library_id", "barcode"]).any():
+                raise QCError("Published cell map has duplicate library+barcode keys")
+            raw_rows = pd.Index(mapping.barcode).get_indexer(source_cells)
+            author_rows = np.full(len(source_cells), -1, dtype=np.int64)
+            if "author_cell_id" in mapping:
+                nonempty = mapping.author_cell_id.astype(str).str.len() > 0
+                if mapping.loc[nonempty].duplicated(["library_id", "author_cell_id"]).any():
+                    raise QCError("Published cell map has duplicate library+author_cell_id keys")
+                indices = np.flatnonzero(nonempty.to_numpy())
+                found = pd.Index(mapping.loc[nonempty, "author_cell_id"]).get_indexer(source_cells)
+                author_rows[found >= 0] = indices[found[found >= 0]]
+            both = (raw_rows >= 0) & (author_rows >= 0)
+            if np.any(both & (raw_rows != author_rows)):
+                raise QCError("Ambiguous raw-barcode/author-cell-ID representations point to different published cells")
+            raw_only = (raw_rows >= 0) & (author_rows < 0)
+            author_only = (author_rows >= 0) & (raw_rows < 0)
+            if raw_only.any() and author_only.any():
+                raise QCError("Mixed raw-barcode and author-cell-ID representations within one source library")
+            if author_only.any():
+                match_column = "author_cell_id"
+                key_representation = "library_id+author_cell_id"
+            else:
+                match_column = "barcode"
+                key_representation = "library_id+barcode" if (raw_rows >= 0).any() else "no_exact_published_key_match"
+            # The source string is never split, stripped, or reconstructed. Both
+            # accepted representations already occur explicitly in author metadata.
+            right = mapping.copy()
+            right["_source_match_key"] = right[match_column]
+            right = right[right._source_match_key.astype(str).str.len() > 0]
+            right = right.rename(columns={"barcode": "raw_10x_barcode"})
+            joined = obs[["library_id", "source_barcode"]].merge(
+                right, left_on=["library_id", "source_barcode"], right_on=["library_id", "_source_match_key"],
+                how="left", validate="one_to_one", sort=False)
+            for column in obs.columns:
+                if column in joined and column not in ("barcode", "source_barcode", "library_id"):
+                    obs[column] = joined[column].fillna("unknown" if column == "author_retained" else "")
+            for column in ("cell_type", "author_cell_id", "author_pool_id"):
+                if column in joined:
+                    obs[column] = joined[column].fillna("")
+    elif accession == "GSE155673":
+        pairs = _read_csv(audit / "D02_covid_pairs.csv")
+        number = re.search(r"cov_?(\d+)", Path(item["path"]).name, re.I)
+        if number and len(pairs):
+            labels = pairs.sc_title.str.extract(r"cov_?(\d+)", expand=False).astype(int)
+            selected = pairs[labels == int(number.group(1))]
+            if len(selected) == 1:
+                row = selected.iloc[0]
+                obs["library_id"] = row.sc_gsm
+                item["published_library_id"] = row.sc_gsm
+                obs["donor_id"], obs["sample_id"] = row.subject, row.sc_title
+                obs["visit_id"] = row.get("day_since_symptoms", "")
+                obs["mapping_basis"] = "published library identity in D02_covid_pairs.csv"
+    elif accession in ("GSE198616", "GSE201534", "GSE161610"):
+        inventory = _read_csv(audit / (accession + "_published_sample_inventory.csv"))
+        selected = inventory[inventory.gsm == library] if len(inventory) else inventory
+        if len(selected) == 1:
+            title = selected.iloc[0].title
+            obs["sample_id"] = title
+            obs["mapping_basis"] = "published unpooled GEO library/sample label; bulk linkage remains separate"
+            if accession == "GSE201534":
+                match = re.fullmatch(r"(.+)_Day(\d+)", title)
+                if match:
+                    obs["donor_id"], obs["visit_id"] = match.group(1), "GEO_Day" + match.group(2)
+            if accession == "GSE161610":
+                obs["donor_id"] = title
+    elif accession == "GSE132044":
+        pairs = _read_csv(audit / "H03_ding_pairs.csv")
+        for _, row in pairs.iterrows():
+            selected = np.char.startswith(cells.astype(str), row.sc_cell_id_prefix)
+            obs.loc[selected, "protocol"] = [value.split(".")[1] if len(value.split(".")) > 1 else "" for value in cells[selected]]
+            # Protocols measure different numeric units; never aggregate across them.
+            obs.loc[selected, "sample_id"] = row.sample_id + "|" + obs.loc[selected, "protocol"]
+            obs.loc[selected, "mapping_basis"] = "published specimen prefix; protocol retained separately"
+    elif accession == "GSE253173":
+        with h5py.File(item["path"], "r") as handle:
+            for source, target in (("LibraryName", "published_LibraryName"), ("Timepoint", "published_Timepoint")):
+                if source in handle["obs"]:
+                    obs[target] = _h5_column(handle["obs"], source)
+        crosswalk = _read_csv(audit / "GSE253173_library_map.csv")
+        if len(crosswalk) and "published_LibraryName" in obs:
+            key = "LibraryName" if "LibraryName" in crosswalk else "published_LibraryName"
+            if crosswalk[key].duplicated().any():
+                raise QCError("DREAM published library crosswalk has duplicate keys")
+            indexed = crosswalk.set_index(key)
+            for column in ("donor_id", "sample_id", "visit_id"):
+                if column in indexed:
+                    obs[column] = obs.published_LibraryName.map(indexed[column]).fillna("")
+            obs.loc[obs.sample_id != "", "mapping_basis"] = "published DREAM library crosswalk"
+    matched = obs.sample_id.astype(str).str.len() > 0
+    return obs, {"n_cells": len(obs), "mapped_sample_cells": int(matched.sum()),
+                 "unresolved_sample_cells": int((~matched).sum()), "full_sample_mapping": bool(matched.all()),
+                 "donor_resolved_cells": int((obs.donor_id.astype(str).str.len() > 0).sum()),
+                 "n_published_samples": int(obs.loc[matched, "sample_id"].nunique()),
+                 "source_key_representation": key_representation,
+                 "join_policy": "exact published keys only; no expression or row-order inference"}
+
+
+def _mtx_dimensions(path: Path) -> tuple[int, int, int]:
+    with _text_open(path) as handle:
+        next(handle)
+        for line in handle:
+            if line.strip() and not line.startswith("%"):
+                return tuple(map(int, line.split()))
+    raise QCError("Missing matrix dimensions")
+
+
+def _mtx_entries(path: Path):
+    """Iterate already-audited coordinates; no matrix allocation."""
+    with _text_open(path) as handle:
+        next(handle)
+        for line in handle:
+            if line.strip() and not line.lstrip().startswith("%"):
+                break  # dimensions
+        for line in handle:
+            if line.strip() and not line.lstrip().startswith("%"):
+                fields = line.split()
+                if len(fields) != 3:
+                    raise QCError("MTX source changed or malformed during export")
+                yield int(fields[0]) - 1, int(fields[1]) - 1, float(fields[2])
+
+
+def _mtx_cell_ordered(path: Path) -> bool:
+    previous = -1
+    for _, cell, _ in _mtx_entries(path):
+        if cell < previous:
+            return False
+        previous = cell
+    return True
+
+
+def _stream_mtx_cells(path: Path, n_features: int, n_cells: int, block_cells: int):
+    start, previous, seen = 0, -1, 0
+    rows, genes, values = [], [], []
+    for gene, cell, value in _mtx_entries(path):
+        if cell < previous or not (0 <= gene < n_features and 0 <= cell < n_cells):
+            raise QCError("MTX coordinate order/bounds changed during streaming export")
+        previous = cell
+        seen += 1
+        while cell >= min(start + block_cells, n_cells):
+            stop = min(start + block_cells, n_cells)
+            yield start, sparse.csr_matrix((values, (rows, genes)), shape=(stop - start, n_features), dtype=np.float64)
+            start = stop
+            rows, genes, values = [], [], []
+        rows.append(cell - start)
+        genes.append(gene)
+        values.append(value)
+    expected = _mtx_dimensions(path)[2]
+    if seen != expected:
+        raise QCError(f"MTX nnz changed during streaming export: {seen} vs {expected}")
+    while start < n_cells:
+        stop = min(start + block_cells, n_cells)
+        yield start, sparse.csr_matrix((values, (rows, genes)), shape=(stop - start, n_features), dtype=np.float64)
+        start = stop
+        rows, genes, values = [], [], []
+
+
+def source_blocks(item: dict, n_features: int, n_cells: int, block_cells: int = 256) -> Iterator[tuple[int, sparse.csr_matrix]]:
+    """Yield cells×source_features sparse blocks; cap full-MTX sparse allocation."""
+    path = Path(item["path"])
+    if item["format"] == "mtx":
+        _, _, nnz = _mtx_dimensions(path)
+        estimate = nnz * 96 + (n_cells + n_features) * 32
+        if estimate > MAX_MTX_ALLOCATION_ESTIMATE:
+            if not _mtx_cell_ordered(path):
+                raise QCError(f"Canonical MTX export resource quarantine: unsorted coordinates and conservative allocation estimate {estimate} exceeds 4 GiB")
+            item["source_iteration"] = "verified cell-column-ordered MTX streaming"
+            yield from _stream_mtx_cells(path, n_features, n_cells, block_cells)
+            return
+        item["source_iteration"] = "bounded sparse MTX load below conservative 4 GiB allocation estimate"
+        matrix = mmread(path).tocsc()
+        if matrix.shape != (n_features, n_cells):
+            raise QCError("MTX dimensions changed after audit")
+        for start in range(0, n_cells, block_cells):
+            yield start, matrix[:, start:start + block_cells].T.tocsr()
+        return
+    with h5py.File(path, "r", rdcc_nbytes=256 * 1024**2) as handle:
+        item["source_iteration"] = "backed HDF5 cell blocks"
+        tenx = "matrix" in handle
+        matrix = handle["matrix" if tenx else item.get("matrix_path", "X")]
+        if isinstance(matrix, h5py.Dataset):
+            for start in range(0, n_cells, block_cells):
+                yield start, sparse.csr_matrix(matrix[start:start + block_cells, :])
+            return
+        encoding = matrix.attrs.get("encoding-type", "")
+        if isinstance(encoding, bytes):
+            encoding = encoding.decode()
+        if not tenx and encoding != "csr_matrix":
+            raise QCError("H5AD canonical export requires cell-major CSR; non-CSR input remains QC-only")
+        # Retain dataset handles: the HDF5 raw chunk cache belongs to each
+        # open dataset. Reopening matrix["data"] per block discards the cache.
+        data_dataset, index_dataset, pointer_dataset = matrix["data"], matrix["indices"], matrix["indptr"]
+        for start in range(0, n_cells, block_cells):
+            stop = min(start + block_cells, n_cells)
+            pointers = np.asarray(pointer_dataset[start:stop + 1], dtype=np.int64)
+            first, last = int(pointers[0]), int(pointers[-1])
+            pointers -= first
+            data = np.asarray(data_dataset[first:last])
+            indices = np.asarray(index_dataset[first:last])
+            yield start, sparse.csr_matrix((data, indices, pointers), shape=(stop - start, n_features))
+
+
+def _h5_array(group, name: str, values) -> None:
+    values = np.asarray(values)
+    if values.dtype.kind in "OUS":
+        dataset = group.create_dataset(name, data=values.astype(object), dtype=h5py.string_dtype("utf-8"))
+        dataset.attrs["encoding-type"], dataset.attrs["encoding-version"] = "string-array", "0.2.0"
+    else:
+        dataset = group.create_dataset(name, data=values)
+        dataset.attrs["encoding-type"], dataset.attrs["encoding-version"] = "array", "0.2.0"
+
+
+def _h5_dataframe(parent, name: str, columns: dict, index: np.ndarray) -> None:
+    group = parent.create_group(name)
+    group.attrs["encoding-type"], group.attrs["encoding-version"] = "dataframe", "0.2.0"
+    group.attrs["_index"] = "_index"
+    group.attrs["column-order"] = np.asarray(list(columns), dtype=h5py.string_dtype())
+    _h5_array(group, "_index", index)
+    for column, values in columns.items():
+        _h5_array(group, column, values)
+
+
+def _h5_scalar(group, name: str, value: str | bool) -> None:
+    if isinstance(value, str):
+        dataset = group.create_dataset(name, data=value, dtype=h5py.string_dtype("utf-8"))
+        dataset.attrs["encoding-type"] = "string"
+    else:
+        dataset = group.create_dataset(name, data=value)
+        dataset.attrs["encoding-type"] = "numeric-scalar"
+    dataset.attrs["encoding-version"] = "0.2.0"
+
+
+def validate_sample_context(obs: pd.DataFrame, aggregation_mask: np.ndarray) -> dict[str, dict]:
+    """Reject contextual collisions; retain missing metadata explicitly as empty.
+
+    A published sample can be valid without a disclosed donor identity. Missing
+    context is not filled from another record; only consistent, published values
+    are recorded in the aggregate metadata.
+    """
+    contexts = {}
+    for sample, rows in obs.loc[aggregation_mask].groupby("sample_id", sort=True):
+        context = {}
+        for field in ("donor_id", "visit_id", "protocol"):
+            values = rows[field].astype(str).str.strip() if field in rows else pd.Series("", index=rows.index)
+            observed = sorted(set(values[~values.isin(["", "unknown", "not_published"])]))
+            if len(observed) > 1:
+                raise QCError(f"Conflicting {field} within published sample {sample!r}: {observed}")
+            context[field] = observed[0] if observed else ""
+            context[field + "_missing_cells"] = int(values.isin(["", "unknown", "not_published"]).sum())
+        contexts[str(sample)] = context
+    return contexts
+
+
+def canonical_export(item: dict, out: Path, mapping: list[dict], canonical: list[dict],
+                     obs: pd.DataFrame, rna: np.ndarray, *, verified_counts: bool, units: str,
+                     full_mapping: bool) -> dict:
+    """Write canonical CSR incrementally; prove mapped/excluded mass accounting."""
+    target = np.asarray([row["target_index"] for row in mapping], dtype=np.int64)
+    target[~rna] = -1
+    present = np.zeros(len(canonical), dtype=bool)
+    present[target[target >= 0]] = True
+    ambiguous_candidate = np.zeros(len(canonical), dtype=bool)
+    canonical_index = {row["gene_id"]: index for index, row in enumerate(canonical)}
+    for row, is_rna in zip(mapping, rna):
+        if is_rna and "ambiguous" in row.get("status", ""):
+            for candidate in row.get("candidate_ids", "").split("|"):
+                if candidate in canonical_index:
+                    ambiguous_candidate[canonical_index[candidate]] = True
+    multiplicity = Counter(target[target >= 0])
+    collision = np.asarray([value >= 0 and multiplicity[value] > 1 for value in target])
+    if not verified_counts:
+        target[collision] = -1
+    harmonization_valid = np.zeros(len(canonical), dtype=bool)
+    harmonization_valid[target[target >= 0]] = True
+    reducer = sparse.csr_matrix((np.ones(np.sum(target >= 0)),
+                                (np.flatnonzero(target >= 0), target[target >= 0])),
+                               shape=(len(mapping), len(canonical)))
+    destination = out / "canonical.h5ad"
+    temporary = out / "canonical.h5ad.partial"
+    qcpass = np.load(out / "metrics/flag_conservative_review_pass.npy", mmap_mode="r")
+    cell_total = np.load(out / "metrics/cell_total.npy", mmap_mode="r")
+    observed_mass = excluded_mass = exported_mass = 0.0
+    mapped = obs.sample_id.astype(str).str.len().to_numpy() > 0
+    author_retained = obs.get("author_retained", pd.Series("unknown", index=obs.index)).astype(str).str.lower().isin(["true", "1", "yes"]).to_numpy()
+    aggregation_mask = mapped & (np.ones(len(obs), bool) if full_mapping else author_retained)
+    samples = sorted(obs.loc[aggregation_mask, "sample_id"].unique()) if verified_counts else []
+    sample_contexts = validate_sample_context(obs, aggregation_mask) if samples else {}
+    sample_index = {value: i for i, value in enumerate(samples)}
+    pseudobulk = np.zeros((2, len(samples), len(canonical)), dtype=np.float64)
+    sample_n = np.zeros((2, len(samples)), dtype=np.int64)
+    sample_source_mass = np.zeros((2, len(samples)), dtype=np.float64)
+    pseudobulk_enabled = bool(samples)
+    non_rna = np.flatnonzero(~rna)
+    with h5py.File(temporary, "w") as handle:
+        handle.attrs["encoding-type"], handle.attrs["encoding-version"] = "anndata", "0.1.0"
+        handle.attrs["source_path"] = item["path"]
+        handle.attrs["numeric_units"] = units
+        handle.attrs["missing_gene_semantics"] = "Zero storage with source_feature_present=False means absent from or unresolved in the supplied feature table; assay coverage is unknown"
+        handle.attrs["duplicate_gene_policy"] = "sum mapped collisions in verified count space" if verified_counts else "exclude all colliding source features"
+        x = handle.create_group("X")
+        x.attrs["encoding-type"], x.attrs["encoding-version"] = "csr_matrix", "0.1.0"
+        x.attrs["shape"] = [len(obs), len(canonical)]
+        data = x.create_dataset("data", shape=(0,), maxshape=(None,), dtype="f8", chunks=(250_000,), compression="gzip", compression_opts=1)
+        indices = x.create_dataset("indices", shape=(0,), maxshape=(None,), dtype="i4", chunks=(250_000,), compression="gzip", compression_opts=1)
+        indptr = x.create_dataset("indptr", shape=(len(obs) + 1,), dtype="i8")
+        indptr[0] = 0
+        auxiliary = handle.create_group("obsm")
+        auxiliary.attrs["encoding-type"], auxiliary.attrs["encoding-version"] = "dict", "0.1.0"
+        if len(non_rna):
+            auxiliary_counts = auxiliary.create_dataset("source_non_rna_counts", shape=(len(obs), len(non_rna)),
+                                                        dtype="f8", chunks=(min(256, len(obs)), len(non_rna)),
+                                                        compression="gzip", compression_opts=1)
+            auxiliary_counts.attrs["encoding-type"], auxiliary_counts.attrs["encoding-version"] = "array", "0.2.0"
+        cursor = 0
+        for start, source in source_blocks(item, len(mapping), len(obs)):
+            stop = start + source.shape[0]
+            source = source.astype(np.float64, copy=False)
+            if len(non_rna):
+                auxiliary_counts[start:stop] = source[:, non_rna].toarray()
+            if not np.all(np.isfinite(source.data)) or np.any(source.data < 0):
+                raise QCError("Export source changed or failed nonnegative finite invariant")
+            numeric_total = np.asarray(source[:, rna].sum(axis=1)).ravel()
+            if not np.allclose(numeric_total, cell_total[start:stop], rtol=1e-10, atol=1e-8):
+                raise QCError("Per-cell source mass disagrees with independent QC scan")
+            transformed = (source @ reducer).tocsr()
+            transformed.sum_duplicates()
+            transformed.eliminate_zeros()
+            transformed.sort_indices()
+            kept = np.asarray(transformed.sum(axis=1)).ravel()
+            removed = np.asarray(source[:, rna & (target < 0)].sum(axis=1)).ravel()
+            if not np.allclose(numeric_total, kept + removed, rtol=1e-10, atol=1e-8):
+                raise QCError("Canonical export mass conservation failed")
+            observed_mass += float(numeric_total.sum())
+            exported_mass += float(kept.sum())
+            excluded_mass += float(removed.sum())
+            end = cursor + transformed.nnz
+            data.resize((end,)); indices.resize((end,))
+            data[cursor:end], indices[cursor:end] = transformed.data, transformed.indices
+            indptr[start + 1:stop + 1] = transformed.indptr[1:] + cursor
+            cursor = end
+            if pseudobulk_enabled:
+                block_samples = obs.sample_id.iloc[start:stop].to_numpy()
+                block_eligible = aggregation_mask[start:stop]
+                for sample in np.unique(block_samples[block_eligible]):
+                    s = sample_index[sample]
+                    all_mask = (block_samples == sample) & block_eligible
+                    for selection, mask in enumerate((all_mask, all_mask & qcpass[start:stop])):
+                        pseudobulk[selection, s] += np.asarray(transformed[mask].sum(axis=0)).ravel()
+                        sample_n[selection, s] += int(mask.sum())
+                        sample_source_mass[selection, s] += float(numeric_total[mask].sum())
+        obs_columns = {column: obs[column].to_numpy() for column in obs.columns}
+        for flag in sorted((out / "metrics").glob("flag_*.npy")):
+            obs_columns[flag.stem] = np.load(flag, mmap_mode="r")
+        for metric in ("cell_total", "cell_detected", "cell_mito_percent"):
+            obs_columns[metric] = np.load(out / "metrics" / (metric + ".npy"), mmap_mode="r")
+        # Source barcodes are unique within this source matrix; library stays a column.
+        _h5_dataframe(handle, "obs", obs_columns, obs.barcode.to_numpy())
+        _h5_dataframe(handle, "var", {"gene_symbol": np.asarray([row["gene_symbol"] for row in canonical]),
+                                      "source_feature_present": present,
+                                      "harmonization_valid": harmonization_valid,
+                                      "source_ambiguous_candidate": ambiguous_candidate}, np.asarray([row["gene_id"] for row in canonical]))
+        for name in ("varm", "obsp", "varp", "layers", "uns"):
+            group = handle.create_group(name)
+            group.attrs["encoding-type"], group.attrs["encoding-version"] = "dict", "0.1.0"
+        if len(non_rna):
+            _h5_array(handle["uns"], "source_non_rna_feature_ids", [mapping[i]["source_id"] for i in non_rna])
+            _h5_array(handle["uns"], "source_non_rna_feature_symbols", [mapping[i]["source_symbol"] for i in non_rna])
+        source_sha = item.get("source_sha256") or sha256_file(item["path"])
+        canonical_sha = item.get("canonical_identity_sha256") or hashlib.sha256(json.dumps(
+            [{"panel_index": str(i), "gene_id": row["gene_id"], "gene_symbol": row["gene_symbol"]}
+             for i, row in enumerate(canonical)], sort_keys=True, separators=(",", ":")).encode()).hexdigest()
+        metadata = {"units": units, "source_path": str(Path(item["path"]).resolve()), "source_sha256": source_sha,
+                    "source_matrix_path": str(item.get("matrix_path") or "MatrixMarket coordinate table"),
+                    "canonical_identity_sha256": canonical_sha,
+                    "raw_count_eligible": verified_counts,
+                    "count_provenance": COUNT_SOURCE_EVIDENCE.get(item.get("accession", ""), "Source count provenance not established") if verified_counts else "Source count provenance not established; integer-valued entries alone are insufficient",
+                    "source_feature_present_semantics": "True if an RNA feature in the supplied source table maps uniquely to this canonical gene before collision quarantine; not assay coverage or expression detection",
+                    "harmonization_valid_semantics": "True if canonical values may be used after mapping and duplicate-collision quarantine; false values are storage zeros, not observed zero expression",
+                    "source_ambiguous_candidate_semantics": "True if a source feature has this canonical gene among its unresolved ambiguous candidates; no expression assigned",
+                    "missing_gene_semantics": "source_feature_present=False means absent from or unresolved in the supplied feature table, not proof of an unmeasured assay feature",
+                    "duplicate_policy": "Sum only in verified count space; otherwise retain pre-quarantine presence and set harmonization_valid=False for collided targets",
+                    "expression_transform": "canonical gene mapping only; source units unchanged; all original cells retained",
+                    "aggregation_context_json": json.dumps(sample_contexts, sort_keys=True)}
+        for name, value in metadata.items():
+            _h5_scalar(handle["uns"], name, value)
+        handle.flush()
+    os.replace(temporary, destination)
+    if pseudobulk_enabled:
+        rows = []
+        with h5py.File(out / "pseudobulk_per_published_sample.h5", "w") as handle:
+            _h5_array(handle, "sample_id", samples)
+            _h5_array(handle, "gene_id", [row["gene_id"] for row in canonical])
+            handle["source_feature_present"] = present
+            handle["harmonization_valid"] = harmonization_valid
+            handle["all_mapped_cells_sum"] = pseudobulk[0]
+            handle["qc_review_pass_cells_sum"] = pseudobulk[1]
+            handle["n_cells"] = sample_n
+            handle["source_total_mass"] = sample_source_mass
+            handle.attrs["units"] = units
+            handle.attrs["aggregation"] = "SUM; no averaging, normalization or donor imputation"
+        for sample, i in sample_index.items():
+            context = sample_contexts[str(sample)]
+            rows.append({"sample_id": sample, **context, "n_cells": int(sample_n[0, i]),
+                         "n_qc_review_pass": int(sample_n[1, i]), "all_source_mass": float(sample_source_mass[0, i]),
+                         "all_canonical_mass": float(pseudobulk[0, i].sum()), "units": units})
+        pd.DataFrame(rows).to_csv(out / "pseudobulk_sample_summary.csv", index=False)
+    return {"path": str(destination), "n_canonical_genes": len(canonical), "n_present": int(present.sum()),
+            "source_iteration": item.get("source_iteration", ""),
+            "n_harmonization_valid": int(harmonization_valid.sum()), "n_ambiguous_candidates": int(ambiguous_candidate.sum()),
+            "canonical_valid_fraction": float(harmonization_valid.mean()),
+            "non_rna_auxiliary_features": len(non_rna), "non_rna_storage": "obsm/source_non_rna_counts; uns/source_non_rna_feature_ids; no cell assignment inferred" if len(non_rna) else None,
+            "canonical_coverage_fraction": float(present.mean()), "excluded_collision_features": int(collision.sum()) if not verified_counts else 0,
+            "source_selected_mass": observed_mass, "canonical_mass": exported_mass, "excluded_mass": excluded_mass,
+            "mass_conservation_pass": bool(np.isclose(observed_mass, exported_mass + excluded_mass, rtol=1e-10, atol=1e-8)),
+            "pseudobulk_enabled": pseudobulk_enabled,
+            "aggregation_population": "all cells with complete published assignment" if full_mapping else "author_retained_mapped_subset",
+            "aggregation_eligible_cells": int(aggregation_mask.sum()) if verified_counts else 0,
+            "aggregation_excluded_unassigned_cells": int((~mapped).sum()),
+            "aggregation_excluded_other_cells": int((mapped & ~aggregation_mask).sum()),
+            "pseudobulk_reason": "verified counts and exact published cell-to-sample assignment for every included cell" if pseudobulk_enabled else "requires verified count units and an explicitly assigned author-retained population"}
+
+
+def run_singlecell(root: str | Path, runroot: str | Path) -> list[dict]:
+    root, runroot = Path(root), Path(runroot)
+    mapper = GeneMapper(runroot / "reference")
+    output = runroot / "singlecell"
+    output.mkdir(parents=True, exist_ok=True)
+    summaries = []
+    for item in discover_libraries(root, runroot):
+        accession, library = item["accession"], item["library_id"]
+        suffix = "__mtx_validation" if item["duplicate_representation"] else ""
+        out = output / accession / (library + suffix)
+        out.mkdir(parents=True, exist_ok=True)
+        summary_path = out / "summary.json"
+        if summary_path.exists():
+            previous = json.loads(summary_path.read_text())
+            if previous.get("status") in ("PASS", "PASS_QC_EXPORT_QUARANTINED", "DUPLICATE_REPRESENTATION_VALIDATED"):
+                summaries.append(previous)
+                continue
+        summary = {**item, "status": "RUNNING", "output_dir": str(out)}
+        _write_json(summary_path, summary)
+        print(json.dumps({"stage": "singlecell", "library": library, "accession": accession, "event": "start"}), flush=True)
+        try:
+            ids, symbols, cells, rna, axes = 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([row["mitochondrial"] for row in mapping])
+            obs, linkage = assign_metadata(item, cells, runroot)
+            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())
+            elif item["format"] == "mtx":
+                qc = scan_mtx(item["path"], metrics, mito_mask=mito, feature_mask=rna,
+                              sample_ids=obs.sample_id.where(obs.sample_id != "", "unresolved_library").to_numpy(),
+                              feature_ids=ids, feature_symbols=symbols, cell_ids=cells)
+            else:
+                qc = scan_h5(item["path"], metrics, matrix_path=axes["matrix_path"], mito_mask=mito, feature_mask=rna,
+                             sample_ids=obs.sample_id.where(obs.sample_id != "", "unresolved_library").to_numpy())
+            total = np.load(metrics / "cell_total.npy", mmap_mode="r")
+            detected = np.load(metrics / "cell_detected.npy", mmap_mode="r")
+            mito_pct = np.load(metrics / "cell_mito_percent.npy", mmap_mode="r")
+            sensitivity = [{"min_genes": genes, "min_abundance": 500, "max_mito_percent": threshold,
+                            "n_review_pass": int(((detected >= genes) & (total >= 500) & (mito_pct <= threshold)).sum())}
+                           for genes in (100, 200, 500) for threshold in (10, 20, 30)]
+            pd.DataFrame(sensitivity).to_csv(out / "threshold_sensitivity.csv", index=False)
+            # The file/format provenance supports counts, then numeric evidence
+            # verifies it. An integer-valued arbitrary H5AD X alone is insufficient.
+            tenx_provenance = accession in COUNT_SOURCE_EVIDENCE and (axes["matrix_path"] == "matrix" or item["format"] == "mtx")
+            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_counts = tenx_provenance and integral
+            units = "UMI_counts" if verified_counts and accession != "GSE132044" else "protocol_specific_read_or_UMI_counts" if verified_counts else "nonnegative_abundance_source_units_unproven"
+            summary.update({"published_library_id": item.get("published_library_id", library),
+                            "n_cells": len(cells), "n_features": len(ids), "n_qc_review_pass": qc["flag_counts"]["conservative_review_pass"],
+                            "numeric": qc["numeric"], "units": units, "count_space_verified": verified_counts,
+                            "count_provenance": COUNT_SOURCE_EVIDENCE[accession] if verified_counts else "count interpretation unavailable; integer values alone insufficient",
+                            "canonicalcoverage": mapping_summary, "author_map_match": linkage,
+                            "source_axes": axes, "biological_interpretation": "none; file and numeric audit only"})
+            if item["duplicate_representation"]:
+                primary = output / accession / library / "metrics"
+                comparison = {name: bool(np.array_equal(np.load(metrics / (name + ".npy")), np.load(primary / (name + ".npy"))))
+                              for name in ("cell_total", "cell_detected", "gene_total", "gene_detected")}
+                comparison["feature_ids"] = (metrics / "feature_ids.tsv").read_bytes() == (primary / "feature_ids.tsv").read_bytes()
+                comparison["cell_ids"] = (metrics / "cell_ids.tsv").read_bytes() == (primary / "cell_ids.tsv").read_bytes()
+                if not all(comparison.values()):
+                    raise QCError(f"Alternate MTX/H5 representation differs: {comparison}")
+                summary.update(status="DUPLICATE_REPRESENTATION_VALIDATED", comparison=comparison,
+                               comparison_limit="axes and exact gene/cell marginals agree; full elementwise identity not asserted")
+            else:
+                try:
+                    export = canonical_export(item, out, mapping, mapper.canonical, obs, rna,
+                                              verified_counts=verified_counts, units=units,
+                                              full_mapping=linkage["full_sample_mapping"])
+                    summary.update(status="PASS", canonical_export=export)
+                except QCError as error:
+                    summary.update(status="PASS_QC_EXPORT_QUARANTINED", export_error=str(error))
+        except Exception as error:
+            summary.update(status="QUARANTINED", error_type=type(error).__name__, error=str(error))
+        _write_json(summary_path, summary)
+        summaries.append(summary)
+        _write_json(output / "SINGLECELL_SUMMARY.json", {"libraries": summaries, "complete": False})
+        print(json.dumps({"stage": "singlecell", "library": library, "event": "finish", "status": summary["status"]}), flush=True)
+        gc.collect()
+    _write_json(output / "SINGLECELL_SUMMARY.json", {"libraries": summaries, "complete": True})
+    return summaries
+
+
+if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument("root", type=Path)
+    parser.add_argument("runroot", type=Path)
+    args = parser.parse_args()
+    run_singlecell(args.root, args.runroot)

paper-releases/20260928/diffusion/data/source_prep/imperial_eskd/code/strict_qc_v1_code_bundle_v5/qc_validate_outputs.py

@@ -0,0 +1,191 @@
+"""Independent bounded inspection of standardized data files and masks."""
+from __future__ import annotations
+
+import argparse
+from datetime import datetime, timezone
+import hashlib
+import json
+from pathlib import Path
+
+import h5py
+import numpy as np
+import pandas as pd
+
+from qc_finalize import stage_coverage
+
+SCAN_CHUNK_ENTRIES = 1_000_000
+
+
+def sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open('rb') as stream:
+        for block in iter(lambda: stream.read(4 * 1024**2), b''):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def inspect_export(path: Path, canonical: list[str]) -> dict:
+    with h5py.File(path, 'r') as h:
+        var, obs, matrix = h['var'], h['obs'], h['X']
+        ids = var[var.attrs.get('_index', '_index')].asstr()[...].tolist()
+        if ids != canonical:
+            raise ValueError('Feature axis differs from frozen canonical identity/order')
+        if 'units' not in h['uns']:
+            raise ValueError('Units unavailable through standard AnnData uns')
+        obs_index = obs[obs.attrs.get('_index', '_index')]
+        shape = tuple(matrix.attrs['shape']) if isinstance(matrix, h5py.Group) else matrix.shape
+        if shape != (len(obs_index), len(canonical)):
+            raise ValueError('X dimensions differ from declared obs/var')
+        if isinstance(matrix, h5py.Group):
+            if matrix.attrs.get('encoding-type') != 'csr_matrix':
+                raise ValueError('Canonical sparse export must use cells-by-genes CSR')
+            for key in ['source_feature_present', 'harmonization_valid']:
+                if key not in var:
+                    raise ValueError(f'Sparse var lacks {key}')
+            present, valid = var['source_feature_present'][...], var['harmonization_valid'][...]
+            if present.shape != (shape[1],) or valid.shape != (shape[1],):
+                raise ValueError('Feature mask dimensions differ from canonical gene axis')
+            if present.dtype.kind != 'b' or valid.dtype.kind != 'b' or np.any(valid & ~present):
+                raise ValueError('Feature masks are not boolean or valid is not subset of present')
+            if not all(name in matrix for name in ['data', 'indices', 'indptr']):
+                raise ValueError('CSR required vectors missing')
+            if any(matrix[name].ndim != 1 for name in ['data', 'indices', 'indptr']):
+                raise ValueError('CSR vectors must be one-dimensional')
+            if matrix['indptr'].dtype.kind not in 'iu' or matrix['indices'].dtype.kind not in 'iu':
+                raise ValueError('CSR indptr and indices must have integer dtypes')
+            if matrix['data'].dtype.kind not in 'iuf':
+                raise ValueError('CSR data must be real numeric abundance')
+            pointers = matrix['indptr'][...]
+            nnz = len(matrix['data'])
+            if len(matrix['indices']) != nnz or len(pointers) != shape[0] + 1 or pointers[0] != 0 or pointers[-1] != nnz:
+                raise ValueError('CSR vector dimensions or endpoints invalid')
+            if np.any(pointers < 0) or np.any(pointers > nnz):
+                raise ValueError('CSR indptr outside data bounds')
+            # Pairwise comparison is safe for unsigned integers; np.diff wraps.
+            if np.any(pointers[1:] < pointers[:-1]):
+                raise ValueError('CSR indptr not monotone')
+            pointers = pointers.astype(np.int64, copy=False)
+            total = 0.0
+            absolute_total = 0.0
+            previous_index = None
+            for start in range(0, nnz, SCAN_CHUNK_ENTRIES):
+                index = matrix['indices'][start:start + SCAN_CHUNK_ENTRIES]
+                values = matrix['data'][start:start + SCAN_CHUNK_ENTRIES]
+                if np.any(index < 0) or np.any(index >= shape[1]) or np.any(~valid[index]):
+                    raise ValueError('Sparse expression references invalid/unmapped gene index')
+                if not np.all(np.isfinite(values)) or np.any(values < 0):
+                    raise ValueError('Sparse abundance contains nonfinite/negative values')
+                first_row = int(np.searchsorted(pointers, start, side='right') - 1)
+                last_row = int(np.searchsorted(pointers, start + len(index) - 1, side='right') - 1)
+                if previous_index is not None and start != pointers[first_row] and index[0] <= previous_index:
+                    raise ValueError('CSR indices are not strictly sorted/unique within a row across chunks')
+                nonincreasing = index[1:] <= index[:-1]
+                boundaries = pointers[first_row + 1:last_row + 1] - start
+                boundaries = boundaries[(boundaries > 0) & (boundaries < len(index))]
+                nonincreasing[boundaries - 1] = False
+                if np.any(nonincreasing):
+                    raise ValueError('CSR indices are not strictly sorted/unique within a row')
+                previous_index = index[-1]
+                if 'raw_count_eligible' in h['uns'] and bool(h['uns/raw_count_eligible'][()]):
+                    if np.any(values != np.floor(values)):
+                        raise ValueError('Count-eligible sparse export contains fractional abundance')
+                total += float(np.sum(values, dtype=np.float64))
+                absolute_total += float(np.sum(np.abs(values), dtype=np.float64))
+            mask_scope = 'gene axis'
+            valid_entries = int(valid.sum())
+        else:
+            layers = h['layers']
+            for key in ['source_feature_present', 'harmonization_valid']:
+                if key not in layers or layers[key].shape != shape or layers[key].dtype.kind != 'b':
+                    raise ValueError(f'Invalid dense per-sample {key} layer')
+            valid_entries, total, absolute_total = 0, 0.0, 0.0
+            for start in range(0, shape[0], 32):
+                values = matrix[start:start + 32]
+                present = layers['source_feature_present'][start:start + 32]
+                valid = layers['harmonization_valid'][start:start + 32]
+                if np.any(valid & ~present) or np.any(~np.isfinite(values[valid])):
+                    raise ValueError('Dense mask subset/finite-value invariant failed')
+                if not np.all(np.isnan(values[~valid])):
+                    raise ValueError('Dense unavailable/quarantined feature must remain NaN')
+                if 'raw_count_eligible' in h['uns'] and bool(h['uns/raw_count_eligible'][()]):
+                    counted = values[valid]
+                    if np.any(counted < 0) or np.any(counted != np.floor(counted)):
+                        raise ValueError('Count-eligible dense export contains negative/fractional abundance')
+                valid_entries += int(valid.sum())
+                total += float(np.sum(values[valid], dtype=np.float64))
+                absolute_total += float(np.sum(np.abs(values[valid]), dtype=np.float64))
+            nnz, mask_scope = None, 'sample by gene'
+        return {'path': str(path), 'shape': [int(value) for value in shape], 'stored_sparse_entries': nnz,
+                'valid_mask_entries': valid_entries, 'mask_scope': mask_scope,
+                'numeric_sum_source_units': total, 'numeric_absolute_sum_source_units': absolute_total, 'bytes': path.stat().st_size,
+                'sha256': sha256(path), 'status': 'PASS'}
+
+
+def validate(runroot: Path, root: Path | None = None) -> dict:
+    runroot = Path(runroot)
+    root = Path(root) if root is not None else runroot.parent.parent
+    canonical = pd.read_csv(runroot / 'reference/canonical_genes.tsv', sep='\t', dtype=str)['gene_id'].tolist()
+    def stage_records(name: str) -> list[dict]:
+        path = runroot / name
+        value = json.loads(path.read_text()) if path.is_file() else []
+        return value if isinstance(value, list) else []
+    bulk_records, sc_records = stage_records('BULK_RESULTS.json'), stage_records('SINGLECELL_RESULTS.json')
+    coverage = stage_coverage(root, runroot, bulk_records, sc_records)
+    expected_totals = {}
+    for row in sc_records:
+        export = row.get('canonical_export', {})
+        if export.get('path') and export.get('canonical_mass') is not None:
+            expected_totals[export['path']] = (float(export['canonical_mass']), 'singlecell_producer_canonical_mass')
+    for row in bulk_records:
+        if not row.get('harmonized_path'):
+            continue
+        metrics_path = Path(row['harmonized_path']).parent / 'source_gene_metrics.csv'
+        if metrics_path.exists() and row.get('nonfinite_values', 0) == 0:
+            metrics = pd.read_csv(metrics_path)
+            required = {'target_index', 'duplicate_target_quarantined', 'absolute_mass_across_samples'}
+            if required.issubset(metrics):
+                quarantined = metrics.duplicate_target_quarantined.astype(str).str.lower().isin(['true', '1'])
+                selected = (metrics.target_index >= 0) & ~quarantined
+                expected_totals[row['harmonized_path']] = (float(metrics.loc[selected, 'absolute_mass_across_samples'].sum()), 'bulk_source_feature_absolute_mass')
+    results = []
+    expected = sorted({row['path'] for row in coverage['expected_exports']})
+    for path in expected:
+        try:
+            checked = inspect_export(Path(path), canonical)
+            if path in expected_totals:
+                expected_mass, basis = expected_totals[path]
+                actual = checked['numeric_absolute_sum_source_units']
+                if not np.isclose(actual, expected_mass, rtol=1e-10, atol=1e-8):
+                    raise ValueError(f'Independent exported value total differs from producer/source record: {actual} vs {expected_mass}')
+                checked.update(producer_value_total_verified=True, expected_absolute_mass=expected_mass, value_total_basis=basis)
+            else:
+                checked['producer_value_total_verified'] = False
+            results.append(checked)
+        except Exception as error:
+            results.append({'path': str(path), 'status': 'FAIL', 'error': str(error)})
+        print(json.dumps(results[-1]), flush=True)
+    coverage_failures = list(coverage['issues'])
+    if not coverage['required_exports_complete'] and not coverage_failures:
+        coverage_failures.append({'code': 'exports_incomplete_due_to_failed_or_quarantined_records',
+                                  'problem': 'Terminal processing includes missing/failed/quarantined required exports'})
+    report = {'checked_at': datetime.now(timezone.utc).isoformat(),
+              'scope': 'Independent file-layout, every-value/index, mask and canonical-axis audit; not biological interpretation',
+              'files': len(results), 'passed': sum(r['status'] == 'PASS' for r in results),
+              'failed': sum(r['status'] == 'FAIL' for r in results) + len(coverage_failures), 'results': results,
+              'stage_coverage': coverage, 'coverage_failures': coverage_failures,
+              'expected_export_files': len(expected),
+              'validation_pass': bool(results and all(row['status'] == 'PASS' for row in results) and not coverage_failures),
+              'auditor_sha256': sha256(Path(__file__))}
+    out = runroot / 'reports/INDEPENDENT_VALIDATION.json'
+    out.parent.mkdir(exist_ok=True)
+    out.write_text(json.dumps(report, indent=2) + '\n')
+    return report
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('runroot', type=Path)
+    parser.add_argument('--root', type=Path)
+    args = parser.parse_args()
+    result = validate(args.runroot, args.root)
+    raise SystemExit(1 if result['failed'] else 0)

paper-releases/20260928/diffusion/data/source_prep/imperial_eskd/code/strict_qc_v1_code_bundle_v5/strict_qc_driver.py

@@ -0,0 +1,207 @@
+#!/usr/bin/env python3
+"""Resumable, resource-bounded orchestration for the paired PBMC audit."""
+from __future__ import annotations
+
+import argparse
+import fcntl
+import gzip
+import hashlib
+import json
+import os
+from pathlib import Path
+import shutil
+import signal
+import subprocess
+import sys
+import time
+from datetime import datetime, timezone
+
+from qc_core import extract_archive, sha256_file
+
+
+def now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def atomic_json(path: Path, value: object) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_suffix(path.suffix + '.tmp')
+    temporary.write_text(json.dumps(value, indent=2, default=str) + '\n')
+    os.replace(temporary, path)
+
+
+class Driver:
+    def __init__(self, root: Path, runroot: Path):
+        self.root, self.runroot = root.resolve(), runroot.resolve()
+        runroot.mkdir(parents=True, exist_ok=True)
+        self.state = {'state': 'running', 'started_at': now(), 'pid': os.getpid(), 'stage': None,
+                      'completed_stages': [], 'errors': []}
+
+    def event(self, event: str, **values: object) -> None:
+        record = {'time': now(), 'event': event, **values}
+        with (self.runroot / 'events.jsonl').open('a') as stream:
+            stream.write(json.dumps(record, default=str) + '\n')
+        print(json.dumps(record, default=str), flush=True)
+        self.state['updated_at'] = now()
+        atomic_json(self.runroot / 'STATUS.json', self.state)
+
+    def guard(self) -> None:
+        fields = dict(line.split(':', 1) for line in Path('/proc/meminfo').read_text().splitlines())
+        available = int(fields['MemAvailable'].split()[0]) * 1024
+        if available < 22 * 1024**3:
+            raise RuntimeError('Global MemAvailable below 22 GiB; preserving partial outputs')
+        if shutil.disk_usage(self.runroot).free < 100 * 1024**3:
+            raise RuntimeError('Free disk below 100 GiB; preserving partial outputs')
+
+    def verify_sources(self) -> None:
+        manifest = json.loads((self.root / 'SOURCE_MANIFEST.json').read_text())
+        receipts = {}
+        for line in (self.root / 'manifests/download_receipts.jsonl').read_text().splitlines():
+            row = json.loads(line)
+            receipts[row['id']] = row
+        output = self.runroot / 'SOURCE_VERIFICATION.json'
+        prior = json.loads(output.read_text()) if output.exists() else {}
+        frozen = []
+        for number, item in enumerate(manifest['files'], 1):
+            self.guard()
+            path = (self.root / item['path']).resolve()
+            if not path.is_relative_to(self.root) or not path.is_file():
+                raise ValueError(f'Invalid or missing acquisition path: {path}')
+            stat = path.stat()
+            receipt = receipts[item['id']]
+            if stat.st_size != item['expected_bytes']:
+                raise ValueError(f'Source size changed: {path}')
+            previous = next((r for r in prior.get('files', []) if r['id'] == item['id']), None)
+            if previous and previous['mtime_ns'] == stat.st_mtime_ns and previous['sha256'] == receipt['sha256']:
+                digest = previous['sha256']
+            else:
+                digest = sha256_file(path)
+            if digest != receipt['sha256']:
+                raise ValueError(f'Source SHA256 changed: {path}')
+            frozen.append({'id': item['id'], 'path': str(path), 'bytes': stat.st_size,
+                           'mtime_ns': stat.st_mtime_ns, 'sha256': digest})
+            if number % 20 == 0:
+                self.event('source_progress', files=number, total=len(manifest['files']))
+        atomic_json(output, {'verified_at': now(), 'complete': True, 'files': frozen,
+                             'manifest_sha256': sha256_file(self.root / 'SOURCE_MANIFEST.json')})
+        self.event('source_verified', files=len(frozen), bytes=sum(r['bytes'] for r in frozen))
+
+    def expand_gzip(self, path: Path, destination: Path) -> None:
+        self.guard()
+        receipt_path = destination.with_suffix(destination.suffix + '.expansion.json')
+        source_hash = sha256_file(path)
+        if destination.exists():
+            if not receipt_path.exists():
+                raise ValueError(f'Expansion destination lacks provenance: {destination}')
+            previous = json.loads(receipt_path.read_text())
+            if previous['source_sha256'] != source_hash or sha256_file(destination) != previous['sha256']:
+                raise ValueError(f'Expansion output changed: {destination}')
+            return
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        temporary = destination.with_suffix(destination.suffix + '.partial')
+        digest, size = hashlib.sha256(), 0
+        with gzip.open(path, 'rb') as source, temporary.open('wb') as target:
+            for chunk in iter(lambda: source.read(4 * 1024**2), b''):
+                self.guard()
+                target.write(chunk)
+                digest.update(chunk)
+                size += len(chunk)
+            target.flush()
+            os.fsync(target.fileno())
+        os.replace(temporary, destination)
+        atomic_json(receipt_path, {'source': str(path), 'source_sha256': source_hash,
+                                   'path': str(destination), 'bytes': size, 'sha256': digest.hexdigest(),
+                                   'completed_at': now()})
+
+    def extract(self) -> None:
+        self.verify_sources()
+        reports = []
+        for dataset in sorted((self.root / 'datasets').iterdir()):
+            if not dataset.is_dir():
+                continue
+            self.guard()
+            target = self.runroot / 'extracted' / dataset.name
+            target.mkdir(parents=True, exist_ok=True)
+            for source in sorted((dataset / 'raw').glob('*')):
+                if source.name.endswith(('.tar', '.tar.gz', '.zip')):
+                    destination = target / source.name.replace('.', '_')
+                    self.event('archive_start', accession=dataset.name, path=str(source))
+                    report = extract_archive(source, destination, disk_floor_bytes=100 * 1024**3)
+                    reports.append(report)
+                    self.event('archive_complete', accession=dataset.name, members=report['member_count'])
+                elif source.name.endswith('.h5ad.gz'):
+                    self.event('gzip_start', accession=dataset.name, path=str(source))
+                    self.expand_gzip(source, target / source.name[:-3])
+                    self.event('gzip_complete', accession=dataset.name)
+            # Nested archives are common in GEO; each source receives an isolated destination.
+            seen = set()
+            for _ in range(5):
+                candidates = [f for f in target.rglob('*') if f.is_file() and
+                              f.name.endswith(('.tar.gz', '.tar', '.zip.gz', '.zip')) and str(f) not in seen]
+                if not candidates:
+                    break
+                for source in candidates:
+                    self.guard()
+                    seen.add(str(source))
+                    if source.name.endswith('.zip.gz'):
+                        self.expand_gzip(source, source.with_suffix(''))
+                        continue
+                    destination = source.parent / (source.name.replace('.', '_') + '_expanded')
+                    self.event('nested_archive_start', accession=dataset.name, path=str(source))
+                    report = extract_archive(source, destination, disk_floor_bytes=100 * 1024**3)
+                    reports.append(report)
+            self.event('dataset_expanded', accession=dataset.name)
+        atomic_json(self.runroot / 'EXTRACTION.json', {'complete': True, 'completed_at': now(), 'archives': reports})
+
+    def run(self, stages: list[str]) -> int:
+        if subprocess.run(['systemctl', '--user', 'is-active', '--quiet', 'ml-memory-guard.service']).returncode:
+            raise RuntimeError('Host memory guard is not active')
+        lock = (self.runroot / 'processing.lock').open('a')
+        fcntl.flock(lock.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+        try:
+            for stage in stages:
+                self.guard()
+                self.state['stage'] = stage
+                self.event('stage_start', stage=stage)
+                if stage == 'extract':
+                    self.extract()
+                elif stage == 'bulk':
+                    from qc_bulk import run_bulk
+                    results = run_bulk(self.root, self.runroot)
+                    atomic_json(self.runroot / 'BULK_RESULTS.json', results)
+                elif stage == 'singlecell':
+                    from qc_singlecell import run_singlecell
+                    results = run_singlecell(self.root, self.runroot)
+                    atomic_json(self.runroot / 'SINGLECELL_RESULTS.json', results)
+                elif stage == 'report':
+                    from qc_finalize import finalize
+                    finalize(self.root, self.runroot)
+                else:
+                    raise ValueError(f'Unknown stage: {stage}')
+                self.state['completed_stages'].append(stage)
+                self.event('stage_complete', stage=stage)
+            self.state['state'] = 'completed_selected_stages'
+            self.state['stage'] = None
+            self.event('run_complete', stages=stages)
+            return 0
+        except BaseException as error:
+            self.state['state'] = 'interrupted' if isinstance(error, KeyboardInterrupt) else 'failed'
+            self.state['errors'].append({'type': type(error).__name__, 'error': str(error), 'stage': self.state['stage']})
+            self.event('run_stopped', error=repr(error))
+            raise
+        finally:
+            lock.close()
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--root', type=Path, required=True)
+    parser.add_argument('--runroot', type=Path, required=True)
+    parser.add_argument('--stages', default='extract,bulk,singlecell,report')
+    args = parser.parse_args()
+    signal.signal(signal.SIGTERM, lambda *_: (_ for _ in ()).throw(KeyboardInterrupt()))
+    raise SystemExit(Driver(args.root, args.runroot).run(args.stages.split(',')))
+
+
+if __name__ == '__main__':
+    main()