Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261002T124820Z-crosscohort-liu-default/diffusion/dataset/server_1/dependency/9f09c3778e1ee97c/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/pbisc-diffusion/updates/20261002T124820Z-crosscohort-liu-default/diffusion/dataset/server_1/dependency/cacc70e2bf7a0b8c/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()

paper-releases/pbisc-diffusion/updates/20261002T124820Z-crosscohort-liu-default/diffusion/dataset/server_1/dependency/eee279f6185909b7/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/pbisc-diffusion/updates/20261002T124820Z-crosscohort-liu-default/diffusion/dataset/server_1/model8/plans/paired_crosscohort_20261002/README.md

@@ -0,0 +1,124 @@
+# Cross-cohort fine-tuning benchmark (leave-one-cohort-out), 2026-10-02
+
+**Question.** Can the final model (f01 6k · 1× · E16), fine-tuned on paired bulk–sc data of *other* cohorts, generate
+cells from the real bulk of a cohort it has never seen, with no pair from that cohort? Requested by the user on
+2026-10-02; fine-tuning modes LoRA r16, LoRA r64 and full; recipe size K = 1000 and 2000. The metrics are the
+within-cohort benchmark's (`plans/paired_finetune_intradataset_20260927`).
+
+## Design
+
+**Cohorts** (the within-cohort benchmark's five; same QC, identity checks, usable rows and cells):
+
+| cohort | bulk | usable pairs | donors | role |
+|---|---|---:|---:|---|
+| ImMicro | PBMC | 107 | 107 | train and test |
+| Ye 2026 sepsis | PBMC | 82 | 82 | train and test |
+| Imperial ESKD COVID | PBMC | 157 | 57 | train and test |
+| Giroux 2022 | PBMC | 24 | 9 | train and test |
+| Ji 2025 ChILI | whole blood | 33 | 20 | test only |
+
+**Splits.** Each split trains one model:
+- **`ho_<X>`, X a PBMC cohort:** the model trains on every usable pair of the other three PBMC cohorts. It is tested on every usable pair of X.
+- **`ho_ji2025_chili`:** the model trains on all four PBMC cohorts. This is also the candidate "pan-cohort" model to release.
+
+Ji is not used for training. Its bulk is whole blood while its single cells are PBMC, so its pairs teach a different mapping than every other cohort's.
+
+**Leakage.** No sample, cell, condition or calibration value of the held-out cohort is read when a split's training inputs are built. Both `prepare_loco.py` and the trainer assert this.
+
+**Training** (`tools/ft_sdd_multi.py`). The loss, optimiser and EMA are the same as `ft_sdd.py`.
+- **Learning rate:** LoRA 5e-4 (r16 with α 16, r64 with α 64); full fine-tune 5e-5.
+- **Steps and early stopping:** evaluation every 250 steps, patience 8, cap 20,000 steps.
+- **Batches are cohort-balanced.** Each cell picks a training cohort uniformly, then a pair, then a cell. Otherwise Imperial (146 training pairs) would dominate and Giroux (24) would barely count.
+- **Inner validation:** 10 % of each training cohort's donors per group, always the same donors (ImMicro 12, sepsis 9, Imperial 5 donors / 11 rows, Giroux 0). The early-stopping loss is the mean over cohorts, so it is cohort-balanced too.
+
+**Conditions.**
+- **Fixed-depth real bulk at recipe size K.** Counts = CPM / 1e6 × K × 3,869.6, and `recipe_k` = K.
+- **Same K for training and testing.** K = 1000 is the protocol so far; its arrays equal the within-cohort benchmark's byte for byte.
+- **K = 2000 tests a different input depth.** It changes the gene features log1p(raw · K / total); the depth-per-cell scalar is unchanged.
+
+**Arms scored per held-out cohort.** All arms score the cohort's usable samples against the same frozen reference.
+
+| arm | target pairs used | what it is |
+|---|---|---|
+| `zs_K1000`, `zs_K2000` | 0 | zero-shot, real bulk |
+| `xcal_K1000`, `xcal_K2000` | 0 | zero-shot + **cross-cohort** gene-wise calibration (α from the training cohorts' pairs, cohort-balanced). This is the control for "LOCO only learns a per-gene correction" |
+| `loco_{lora16,lora64,full}_K{1000,2000}` | 0 | fine-tuned on the other cohorts |
+| within-cohort `zs__cal`, `real_lora__raw`, `real_full__raw` | all (5-fold) | reference ceilings from the within-cohort benchmark (read, not rerun) |
+
+**Metrics** (`score_ft.py`, one call per arm):
+- composition L1 (scANVI, frozen f01common);
+- precision / coverage (and depth-matched);
+- pseudobulk r;
+- disease logFC r with the bulk-broadcast baseline and partial r;
+- top-50 DEG overlap.
+
+Giroux's disease metrics exclude the 196 sex-linked genes, as in the deck. Composition gets a paired Wilcoxon over samples against `zs_K1000` and against the within-cohort LoRA.
+
+## Running (both servers)
+
+- `queues/loco_20261002.txt` has 45 units in priority order:
+  1. K = 1000 LoRA r16 for all 5 splits;
+  2. its cross-cohort calibration control;
+  3. LoRA r64 and full at K = 1000;
+  4. K = 2000 zero-shot, calibration and the three modes.
+- **`tools/run_loco_queue.sh`** runs the same queue on both hosts. A host claims a unit (atomic `mkdir` in `claims/` on server_1) only after its GPU gate passes, so no unit runs twice.
+  - server_1 walks the queue forward and server_2 backward.
+  - server_2 copies finished runs and outputs back to the same absolute paths on server_1.
+  - A failed unit is marked FAILED and not retried; two failures in a row stop the queue.
+  - Every GPU step goes through `ml-run`. On server_1 it alternates on the shared lock with the scSemiProfiler CV queue.
+- **`tools/score_pending.sh`** (`loco-score-s1`, server_1, CPU) scores each arm as soon as it exists. A failed call leaves `<out>.FAILED` and is not retried.
+- **`tools/aggregate_loco.py`** writes `scores/AGGREGATE.md` and `scores/aggregate.csv`.
+
+Units: `loco-queue-s1` and `loco-score-s1` on server_1, `loco-queue-s2` on server_2. Started 2026-10-02 20:35 KST. server_2 waits at its gate while another user's vLLM occupies its GPU (96 %, 91 GB).
+
+**GPU time (estimate):**
+- A training run takes ~16 min at the 20k cap (LoRA, ~21 steps/s) and somewhat more for full fine-tuning.
+- Sampling one split's test set takes 2–11 min.
+- Total ≈ 12 GPU h: 30 fine-tunes ≈ 8 h, 45 sampling sets ≈ 4 h.
+- On server_1 alone, sharing the lock with the scSemiProfiler CV queue, expect about 1–1.5 days.
+
+## Update 2026-10-02 21:45: Liu 2021 is in every training pool (user decision)
+
+**What changed.** The user asked to add Liu 2021 (GSE161918) as a training-only cohort, to stop all training, and to make Liu the default. The first queue (`queues/loco_20261002.txt`, splits `ho_*`) was stopped at 21:30. Its 3 finished units (K = 1000, LoRA r16, held out Giroux / Ji / sepsis) are kept as a no-Liu reference. The ImMicro unit had trained for a few seconds; it is marked `STOPPED` and has no checkpoint.
+
+**Liu 2021.**
+- Built by `processing/liu2021_v1_20261002/` → `plans/paired_finetune_intradataset_20260927/data/liu2021/`, using the same QC bundle, gene axis and identity checks as the other cohorts. See its `QC_REPORT.md`.
+- **Bulk is PBMC:** unsorted PBMC, TruSeq, htseq.
+- **Single cells:** unsorted fraction only; hashtag and demuxlet singlets.
+- **Size:** 65 pairs, 44 subjects; 58 usable rows from 41 subjects.
+- Never a test cohort: its single cells are in the pretraining corpus.
+
+**Training exclusion** (`tools/prepare_loco_extra.py`, `EXCLUDE`, read from the processing run's `hto_negative_sensitivity.csv`).
+- Rule: 14 rows lost > 30 % of their unsorted cells to hashtag-negative calls (weak pools B2 HTO3 and B3 HTO5); they are not trained on.
+- Why: negatives carry about 20 points fewer classical monocytes, so these rows' retained cells over-represent monocytes against the all-cell bulk.
+- Liu's pool is 44 rows from 37 donors: 40 training rows plus 4 inner-validation donors.
+
+**Splits `hoL_<X>`.** Each is `ho_<X>`'s pool plus Liu. Test samples and test files are unchanged. The cross-cohort calibration is refitted on the enlarged pool.
+
+| split | training rows | inner-val rows | test |
+|---|---:|---:|---:|
+| hoL_immicro | 283 | 24 | 107 |
+| hoL_ye2026_sepsis | 305 | 27 | 82 |
+| hoL_imperial_eskd | 232 | 25 | 157 |
+| hoL_giroux2022 | 354 | 36 | 24 |
+| hoL_ji2025_chili | 378 | 36 | 33 |
+
+**Queue.** `queues/loco_liu_20261002.txt` has 45 units in the same order as before. It was launched at 21:45 on server_1 (forward) and server_2 (backward, waiting at its gate). Arms are scored as `locoL_<tag>_K<K>` and `xcalL_K<K>`.
+
+**No-Liu reference so far** (K = 1000, LoRA r16; `scores/AGGREGATE.md`):
+
+| held out | coverage, zs → LOCO (within-cohort LoRA) | comp. L1, zs → LOCO (within) | logFC r, zs → LOCO (within) |
+|---|---|---|---|
+| Giroux | 0.29 → 0.81 (0.93) | 0.337 → 0.347, p 0.83 (0.258) | 0.34 → 0.30 (0.46) |
+| Sepsis | 0.07 → 0.29 (0.83) | 0.509 → 0.538, p 0.18 (0.362) | −0.02 → 0.09 (0.53) |
+| Ji | 0.06 → 0.31 (0.86) | 0.725 → 0.494, p 6e-4 (0.504) | 0.07 → 0.09 (0.48) |
+
+Pairs from other cohorts recover part of the cell realism. In Ji they also fix composition, as much as Ji's own pairs. They barely move the disease signal, which so far needs the cohort's own pairs.
+
+## Files
+
+- `tools/prepare_loco.py` → `data/<cohort>/`, `splits/`, `PREPARE.json` (CPU; run 2026-10-02 20:31, all checks true)
+- `tools/ft_sdd_multi.py`: trainer (CPU smoke and 20-step GPU smoke passed)
+- `runs/<split>/K<K>/<tag>/` (RUN.json, history.json with per-cohort inner-val loss, checkpoint)
+- `generated/<cohort>/{zs_K2000.npz, <split>/xcal_K<K>.npz, <split>/K<K>_<tag>.npz}` + receipts
+- `scores/<cohort>/<arm>/`, `scores_nosex/giroux2022/<arm>/`