Archive 4 checkpoints (1-4)

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

@@ -0,0 +1,381 @@
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "tools"))
+from rare_metrics import (aggregate_donors, abundance_summary, bootstrap_mae,
+                          call_marker_state, validate_marker_coverage, validate_design)
+from build_figure5 import analyze_unit, require_complete_strict
+from rare_cache_builder import _stream_poisson, build_arm, sha256
+from figure5_panels import render, validate_plot_data
+from export_rare_visuals import choose_donor_draws, build_visuals
+
+
+def test_missing_mandatory_marker_fails_closed():
+    state = {"name": "C1Q", "kind": "markers", "genes": ["C1QA", "C1QB", "C1QC"],
+             "k": 2, "require_any": [["CD38", "HLA-DRA"]], "exclude": ["CR2"]}
+    with pytest.raises(ValueError, match="C1QC"):
+        validate_marker_coverage(state, ["C1QA", "C1QB", "CD38", "HLA-DRA", "CR2"])
+    with pytest.raises(ValueError, match="CR2"):
+        validate_marker_coverage(state, ["C1QA", "C1QB", "C1QC", "CD38", "HLA-DRA"])
+
+
+def test_multimarker_codetection_needs_all_rule_parts():
+    state = {"name": "C1Q", "kind": "markers", "genes": ["C1QA", "C1QB", "C1QC"],
+             "k": 2, "require_any": [["CD38", "HLA-DRA"]], "exclude": ["CR2"]}
+    genes = ["C1QA", "C1QB", "C1QC", "CD38", "HLA-DRA", "CR2"]
+    counts = np.array([[1, 1, 0, 1, 0, 0], [1, 1, 0, 0, 0, 0],
+                       [1, 1, 0, 1, 0, 1]])
+    assert call_marker_state(counts, genes, state).tolist() == [True, False, False]
+
+
+def test_longitudinal_samples_aggregate_to_actual_donor_and_zero_is_included():
+    rows = pd.DataFrame([
+        dict(sample_id="a_t0", donor_id="a", obs_parent=10, obs_state=2, gen_parent=10, gen_state=0),
+        dict(sample_id="a_t1", donor_id="a", obs_parent=10, obs_state=2, gen_parent=10, gen_state=0),
+        dict(sample_id="b_t0", donor_id="b", obs_parent=10, obs_state=1, gen_parent=10, gen_state=1),
+    ])
+    donor = aggregate_donors(rows)
+    assert len(donor) == 2
+    assert donor.set_index("donor_id").loc["a", "gen_pct"] == 0
+    summary = abundance_summary(rows)
+    assert summary["n_samples"] == 3 and summary["n_donors"] == 2
+    assert summary["generated_zero_samples"] == 2
+    assert summary["gen_pct"] == pytest.approx(100 / 30)
+    assert summary["mae_sample_pp"] == pytest.approx((20 + 20 + 0) / 3)
+
+
+def test_zero_parent_has_undefined_conditional_rate_and_zero_overall_rate():
+    rows = pd.DataFrame([dict(sample_id="s", donor_id="d", obs_parent=4, obs_state=0,
+                              gen_parent=0, gen_state=0, obs_total=10, gen_total=10)])
+    donor = aggregate_donors(rows)
+    assert np.isnan(donor.iloc[0].gen_pct)
+    assert donor.iloc[0].gen_overall_pct == 0
+    assert np.isnan(abundance_summary(rows)["gen_pct"])
+
+
+def test_donor_bootstrap_is_deterministic_and_clusters_samples():
+    rows = pd.DataFrame([
+        dict(sample_id="a0", donor_id="a", obs_parent=10, obs_state=1, gen_parent=10, gen_state=0),
+        dict(sample_id="a1", donor_id="a", obs_parent=10, obs_state=1, gen_parent=10, gen_state=0),
+        dict(sample_id="b0", donor_id="b", obs_parent=10, obs_state=3, gen_parent=10, gen_state=2),
+    ])
+    assert bootstrap_mae(rows, seed=7, n_boot=100) == bootstrap_mae(rows, seed=7, n_boot=100)
+
+
+def test_longitudinal_donor_can_change_clinical_group_without_becoming_two_donors():
+    rows = pd.DataFrame([
+        dict(sample_id="d0", donor_id="d", group="mild", obs_parent=10, obs_state=1,
+             gen_parent=10, gen_state=0),
+        dict(sample_id="d14", donor_id="d", group="severe", obs_parent=10, obs_state=3,
+             gen_parent=10, gen_state=1),
+    ])
+    donor = aggregate_donors(rows)
+    assert len(donor) == 1
+    assert donor.iloc[0].group == "mixed"
+    assert donor.iloc[0].obs_state == 4
+
+
+def test_strict_design_rejects_duplicate_training_donors():
+    with pytest.raises(ValueError, match="unique donor"):
+        validate_design({"design": "strict5pair", "train_sample_ids": ["a0", "a1", "b", "c", "d"],
+                         "train_donor_ids": ["a", "a", "b", "c", "d"]})
+    assert validate_design({"design": "legacy_5donor", "train_sample_ids": ["a0", "a1"],
+                            "train_donor_ids": ["a", "a"]}) == "diagnostic"
+
+
+def test_strict_cache_requires_bound_support_manifest(tmp_path):
+    sample_ids = ["test"]
+    np.savez(tmp_path / "cache.npz", markers=np.array([[1, 1, 0]], dtype=np.int32),
+             marker_symbols=np.array(["C1QA", "C1QB", "C1QC"]),
+             lib_measured=np.array([10]), sample_id=np.array(sample_ids),
+             aifi_l1=np.array(["Monocyte"]), aifi_l2=np.array(["CD14 monocyte"]),
+             receipt="test")
+    pd.DataFrame([dict(sample_id=f"train{i}", donor_id=f"d{i}", group="case")
+                  for i in range(5)] +
+                 [dict(sample_id="test", donor_id="dt", group="case")]).to_csv(
+                     tmp_path / "metadata.csv", index=False)
+    unit = dict(cohort="toy", unit="draw0", design="strict5pair",
+                train_sample_ids=[f"train{i}" for i in range(5)],
+                train_donor_ids=[f"d{i}" for i in range(5)],
+                test_sample_ids=["test"], sample_metadata="metadata.csv",
+                observed_cache="cache.npz", generated_caches={"lora5": "cache.npz"},
+                cell_budget=1, depth_target=10)
+    state = dict(name="C1Q", kind="markers", genes=["C1QA", "C1QB", "C1QC"],
+                 parent=["Monocyte"], k=2)
+    with pytest.raises(ValueError, match="support_manifest"):
+        analyze_unit(unit, tmp_path, [state])
+    support = dict(cohort="toy", unit="draw0_n5", train_sample_ids=unit["train_sample_ids"],
+                   train_donor_ids=unit["train_donor_ids"], test_sample_ids=["test"],
+                   test_donor_ids=["dt"], schema="pbisc.paper.strict-support.v1")
+    import hashlib
+    import json
+    support["sha256"] = hashlib.sha256(json.dumps(
+        support, sort_keys=True, separators=(",", ":"), allow_nan=False).encode()).hexdigest()
+    (tmp_path / "support.json").write_text(__import__("json").dumps(support))
+    unit["support_manifest"] = "support.json"
+    score = tmp_path / "score"
+    labels = score / "arms/lora5/labels"
+    labels.mkdir(parents=True)
+    generated = tmp_path / "source.npz"
+    generated.write_bytes(b"source content")
+    cells = labels.parent / "generated_cells.parquet"
+    cells.write_bytes(b"scored cells")
+    label_path = labels / "labels.parquet"
+    label_path.write_bytes(b"scored labels")
+    source_sha = sha256(generated)
+    score_summary = score / "summary.json"
+    score_summary.write_text(json.dumps({
+        "schema": "paired_ft_scores.v1", "dataset": "toy", "donors": ["test"],
+        "per_arm": {"lora5": {"npz": str(generated), "npz_sha256": source_sha,
+                              "receipt_verified": True,
+                              "poisson": {"seed": 20260916,
+                                          "rule": "whole NPZ, rows in NPZ order"}}}}))
+    binding = score.parent / "scoring_support.json"
+    binding.write_text(json.dumps({
+        "schema": "pbisc.paper.strict-score-binding.v1",
+        "support_sha256": support["sha256"], "cohort": "toy", "unit": "draw0_n5",
+        "test_sample_ids": ["test"], "test_donor_ids": ["dt"]}))
+    rec = dict(schema="pbisc.figure5.marker-cache.v1", cohort="toy", unit="draw0_n5",
+               arm="lora5", support_sha256=support["sha256"], poisson_seed=20260916,
+               benchmark_umi_reproduced=True, cells=1, generated_npz=str(generated),
+               generated_npz_sha256=source_sha, score_summary=str(score_summary),
+               score_summary_sha256=sha256(score_summary), score_generated_cells=str(cells),
+               score_generated_cells_sha256=sha256(cells),
+               score_labels_sha256=sha256(label_path),
+               scoring_support=str(binding), scoring_support_sha256=sha256(binding))
+    np.savez(tmp_path / "cache.npz", markers=np.array([[1, 1, 0]], dtype=np.int32),
+             marker_symbols=np.array(["C1QA", "C1QB", "C1QC"]),
+             lib_measured=np.array([10]), sample_id=np.array(["test"]),
+             aifi_l1=np.array(["Monocyte"]), aifi_l2=np.array(["CD14 monocyte"]),
+             receipt=json.dumps(rec))
+    unit["generated_cache_sha256"] = {"lora5": sha256(tmp_path / "cache.npz")}
+    unit["observed_cache_sha256"] = sha256(tmp_path / "cache.npz")
+    rows, summary, provenance = analyze_unit(unit, tmp_path, [state])
+    assert len(rows) == len(summary) == 1
+    assert provenance["support_sha256"] == support["sha256"]
+    assert rows[0]["gen_state"] == 1
+    rec["arm"] = "wrong_arm"
+    np.savez(tmp_path / "cache.npz", markers=np.array([[1, 1, 0]], dtype=np.int32),
+             marker_symbols=np.array(["C1QA", "C1QB", "C1QC"]),
+             lib_measured=np.array([10]), sample_id=np.array(["test"]),
+             aifi_l1=np.array(["Monocyte"]), aifi_l2=np.array(["CD14 monocyte"]),
+             receipt=json.dumps(rec))
+    unit["generated_cache_sha256"]["lora5"] = sha256(tmp_path / "cache.npz")
+    unit["observed_cache_sha256"] = sha256(tmp_path / "cache.npz")
+    with pytest.raises(ValueError, match="receipt mismatch: arm"):
+        analyze_unit(unit, tmp_path, [state])
+    rec["arm"] = "lora5"
+    np.savez(tmp_path / "cache.npz", markers=np.array([[1, 1, 0]], dtype=np.int32),
+             marker_symbols=np.array(["C1QA", "C1QB", "C1QC"]),
+             lib_measured=np.array([10]), sample_id=np.array(["test"]),
+             aifi_l1=np.array(["Monocyte"]), aifi_l2=np.array(["CD14 monocyte"]),
+             receipt=json.dumps(rec))
+    unit["generated_cache_sha256"]["lora5"] = sha256(tmp_path / "cache.npz")
+    unit["observed_cache_sha256"] = sha256(tmp_path / "cache.npz")
+    binding.write_text(json.dumps({
+        "schema": "pbisc.paper.strict-score-binding.v1",
+        "support_sha256": "wrong", "cohort": "toy", "unit": "draw0_n5",
+        "test_sample_ids": ["test"], "test_donor_ids": ["dt"]}))
+    with pytest.raises(ValueError, match="scoring support"):
+        analyze_unit(unit, tmp_path, [state])
+    binding.unlink()
+    with pytest.raises(ValueError, match="scoring support"):
+        analyze_unit(unit, tmp_path, [state])
+
+
+def test_chunked_cache_readout_matches_whole_npz_poisson_and_scored_row_order():
+    rates = np.arange(24, dtype=float).reshape(6, 4) / 8
+    selected = np.array([4, 1, 5])
+    full = np.random.default_rng(20260916).poisson(rates)
+    markers, libs, umis = _stream_poisson(
+        rates, selected, np.array([True, False, True, True]),
+        np.array([2, 0]), np.array([1, 3]), chunk_rows=2)
+    np.testing.assert_array_equal(markers, full[selected][:, [2, 0]])
+    np.testing.assert_array_equal(libs, full[selected][:, [0, 2, 3]].sum(1))
+    np.testing.assert_array_equal(umis, full[selected][:, [1, 3]].sum(1))
+
+
+def test_strict_figure_requires_every_cohort_and_five_draws():
+    with pytest.raises(ValueError, match="missing strict"):
+        require_complete_strict([{"cohort": "ye2026_sepsis", "unit": "draw0"}])
+
+
+def _complete_units():
+    return [dict(cohort=c, unit=f"draw{i}", design="strict5pair",
+                 generated_caches={a: f"{a}.npz" for a in
+                                   ("lora", "pairedcal", "scsemi", "raw", "refcal")},
+                 cell_budget=500, depth_target=1000)
+            for c in ("ye2026_sepsis", "imperial_eskd", "giroux2022", "ji2025_chili")
+            for i in range(5)]
+
+
+def test_strict_figure_rejects_missing_arm_and_mixed_budget_or_depth():
+    units = _complete_units()
+    assert require_complete_strict(units) is None
+    units[0]["generated_caches"].pop("refcal")
+    with pytest.raises(ValueError, match="arms"):
+        require_complete_strict(units)
+    units = _complete_units()
+    units[1]["depth_target"] = 500
+    with pytest.raises(ValueError, match="depth_target"):
+        require_complete_strict(units)
+    units = _complete_units()
+    units[1]["cell_budget"] = 400
+    with pytest.raises(ValueError, match="cell_budget"):
+        require_complete_strict(units)
+    units = _complete_units()
+    units[1]["design"] = "legacy_5donor"
+    with pytest.raises(ValueError, match="strict5pair"):
+        require_complete_strict(units)
+
+
+def test_strict_renderer_uses_new_arm_names_and_has_nonempty_panels(tmp_path):
+    src = tmp_path / "source_data"
+    src.mkdir()
+    arms = ("raw", "refcal", "pairedcal", "scsemi", "lora")
+    sample = pd.DataFrame([
+            dict(cohort="ye2026_sepsis", unit="draw0", arm=a, donor_id="donorA",
+             state="C1Q-high monocyte (reference)", state_kind="markers",
+             obs_parent=10, obs_state=2, gen_parent=10, gen_state=i,
+             obs_codetection=.2, gen_codetection=i/10)
+        for i, a in enumerate(arms)])
+    donor = sample.assign(obs_pct=20, gen_pct=[i*10 for i in range(5)])
+    summary = sample.assign(evidence_tier="strict", obs_pct=20, spearman_donor=float('nan'),
+                            mae_donor_pp=[20, 10, 10, 10, 0])
+    sample.to_csv(src / "rare_per_sample.csv", index=False)
+    donor.to_csv(src / "rare_per_donor.csv", index=False)
+    summary.to_csv(src / "rare_summary.csv", index=False)
+    assert validate_plot_data(sample, donor, summary, "strict") == list(arms)
+    render(tmp_path)
+    assert (tmp_path / "figures/fig5_rare_states_strict.png").stat().st_size > 1000
+    with pytest.raises(ValueError, match="visual"):
+        render(tmp_path, require_complete=True)
+    import json
+    reports = tmp_path / "reports"
+    reports.mkdir(exist_ok=True)
+    (reports / "rare_provenance.json").write_text(json.dumps(
+        {"units": [{"evidence_tier": "strict"}] * 20, "visuals": {"status": "complete"}}))
+    (reports / "rare_visual_provenance.json").write_text(json.dumps(
+        {"schema": "pbisc.figure5.marker-visuals.v1", "status": "complete",
+         "examples": [{"status": "available"}] * 3}))
+    for ext in ("pdf", "svg", "png"):
+        (tmp_path / "figures" / f"fig5_rare_visuals_strict.{ext}").write_bytes(b"fixture")
+    render(tmp_path, require_complete=True)
+
+
+def test_donor_draw_selection_is_stable_and_shared_across_methods():
+    units = [
+        dict(cohort="ye2026_sepsis", unit=f"draw{i}",
+             test_sample_ids=["s1", "s2"], sample_metadata="unused")
+        for i in (0, 1, 2)]
+    metadata = pd.DataFrame(dict(sample_id=["s1", "s2"], donor_id=["d1", "d2"]))
+    first = choose_donor_draws(units, "ye2026_sepsis", metadata)
+    assert first == choose_donor_draws(list(reversed(units)), "ye2026_sepsis", metadata)
+    assert set(first) == {"d1", "d2"}
+    assert all(v in {"draw0", "draw1", "draw2"} for v in first.values())
+
+
+def test_tiny_cpu_visual_export_uses_real_reference_and_marker_heatmap(tmp_path):
+    import json
+    from export_rare_visuals import EXAMPLES
+    states = json.loads((Path(__file__).resolve().parents[2] /
+                         "rare_states_screen_20261004/tools/states.json").read_text())
+    names = {ex["state"] for ex in EXAMPLES}
+    needed = sorted({g for s in states if s["name"] in names
+                     for g in s.get("genes", []) +
+                     [g for group in s.get("require_any", []) for g in group] + s.get("exclude", [])})
+    units = []
+    for cohort, l1, l2 in [("ye2026_sepsis", "Monocyte", "CD14 monocyte"),
+                           ("imperial_eskd", "T cell", "Memory CD4 T cell")]:
+        root = tmp_path / cohort
+        root.mkdir()
+        sample = f"{cohort}_sample"
+        pd.DataFrame([dict(sample_id=sample, donor_id=f"{cohort}_donor",
+                           group="case")]).to_csv(root / "meta.csv", index=False)
+        rng = np.random.default_rng(7)
+        matrix = rng.poisson(1.5, size=(32, len(needed))).astype(np.int32)
+        kwargs = dict(markers=matrix, marker_symbols=np.array(needed),
+                      lib_measured=np.full(32, 1000), sample_id=np.array([sample] * 32),
+                      aifi_l1=np.array([l1] * 32), aifi_l2=np.array([l2] * 32))
+        np.savez(root / "observed.npz", **kwargs)
+        caches = {}
+        for arm in ("raw", "refcal", "pairedcal", "scsemi", "lora"):
+            np.savez(root / f"{arm}.npz", **kwargs)
+            caches[arm] = str(root / f"{arm}.npz")
+        units.append(dict(cohort=cohort, unit="draw0", design="strict5pair",
+                          test_sample_ids=[sample], sample_metadata=str(root / "meta.csv"),
+                          observed_cache=str(root / "observed.npz"),
+                          generated_caches=caches, cell_budget=25, depth_target=1000))
+    result = build_visuals(units, tmp_path, require_complete=False, validate_sources=False,
+                           cells_per_sample=25)
+    assert result["status"] == "complete"
+    assert (tmp_path / "figures/fig5_rare_visuals_strict.png").stat().st_size > 1000
+    cells = pd.read_csv(tmp_path / "source_data/rare_visual_cells.csv")
+    heat = pd.read_csv(tmp_path / "source_data/rare_visual_heatmap.csv")
+    assert set(cells.arm) == {"observed", "raw", "refcal", "pairedcal", "scsemi", "lora"}
+    assert not heat.empty
+    assert set(cells.projection_fit_source) == {"observed_only"}
+
+
+def test_cache_builder_checks_scored_umi_and_preserves_scored_row_order(tmp_path):
+    import json
+    rates = np.arange(12, dtype=float).reshape(3, 4) / 4
+    source = tmp_path / "generated.npz"
+    np.savez_compressed(source, generated_counts=rates,
+                        gene_ids=np.array(["g0", "g1", "g2", "g3"]),
+                        sample_ids=np.array(["test"]), bulk_index=np.zeros(3, dtype=int))
+    source.with_suffix(".log").write_text(json.dumps({"output_sha256": sha256(source)}))
+    score = tmp_path / "score"
+    work = score / "arms/lora5"
+    (work / "labels").mkdir(parents=True)
+    full = np.random.default_rng(20260916).poisson(rates)
+    selected = np.array([2, 0])
+    pd.DataFrame(dict(npz_row=selected, donor=["test", "test"],
+                      umi_scoring_genes=full[selected][:, [1, 3]].sum(1))).to_parquet(
+                          work / "generated_cells.parquet")
+    pd.DataFrame(dict(sample_id=["test|generated"] * 2, aifi_l1=["Monocyte"] * 2,
+                      aifi_l2=["CD14 monocyte"] * 2)).to_parquet(work / "labels/labels.parquet")
+    (score / "summary.json").write_text(json.dumps({
+        "schema": "paired_ft_scores.v1", "dataset": "toy", "donors": ["test"],
+        "arms": ["lora5"], "per_arm": {"lora5": {
+            "npz": str(source), "npz_sha256": sha256(source),
+            "receipt_verified": True,
+            "poisson": {"seed": 20260916, "rule": "whole NPZ, rows in NPZ order"}}}}))
+    support = {"cohort": "toy", "unit": "draw0_n5", "test_sample_ids": ["test"],
+               "test_donor_ids": ["donor"], "sha256": "support"}
+    with pytest.raises(ValueError, match="scoring support"):
+        build_arm(source, score, "lora5", support, tmp_path / "markers.npz",
+                  np.array(["g0", "g1", "g2", "g3"]), np.array([1, 0, 1, 1], bool),
+                  ["A", "B"], np.array([2, 0]), np.array([1, 3]))
+    binding = score.parent / "scoring_support.json"
+    binding.write_text(json.dumps({
+        "schema": "pbisc.paper.strict-score-binding.v1",
+        "support_sha256": "support", "cohort": "toy", "unit": "draw0_n5",
+        "test_sample_ids": ["test"], "test_donor_ids": ["donor"]}))
+    output = tmp_path / "markers.npz"
+    receipt = build_arm(source, score, "lora5",
+                        support, output,
+                        np.array(["g0", "g1", "g2", "g3"]), np.array([1, 0, 1, 1], bool),
+                        ["A", "B"], np.array([2, 0]), np.array([1, 3]))
+    assert receipt["benchmark_umi_reproduced"]
+    with np.load(output) as cache:
+        np.testing.assert_array_equal(cache["markers"], full[selected][:, [2, 0]])
+    wrong = json.loads((score / "summary.json").read_text())
+    wrong["per_arm"]["lora5"]["npz_sha256"] = "0" * 64
+    (score / "summary.json").write_text(json.dumps(wrong))
+    with pytest.raises(ValueError, match="scorer arm provenance"):
+        build_arm(source, score, "lora5",
+                  support, output,
+                  np.array(["g0", "g1", "g2", "g3"]), np.array([1, 0, 1, 1], bool),
+                  ["A", "B"], np.array([2, 0]), np.array([1, 3]))
+    wrong = json.loads(binding.read_text())
+    wrong["test_donor_ids"] = ["other"]
+    binding.write_text(json.dumps(wrong))
+    with pytest.raises(ValueError, match="scoring support"):
+        build_arm(source, score, "lora5", support, output,
+                  np.array(["g0", "g1", "g2", "g3"]), np.array([1, 0, 1, 1], bool),
+                  ["A", "B"], np.array([2, 0]), np.array([1, 3]))

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

@@ -0,0 +1,42 @@
+import importlib.util
+from pathlib import Path
+import unittest
+import numpy as np
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+class ReferenceCalibrationTests(unittest.TestCase):
+    def function(self):
+        path = ROOT / "tools/prepare_controls.py"
+        self.assertTrue(path.exists(), "external-reference condition builder is not implemented")
+        spec = importlib.util.spec_from_file_location("prepare_controls", path)
+        mod = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(mod)
+        return mod.external_multiplier
+
+    def test_external_reference_changes_shape_without_any_target_sc(self):
+        fn = self.function()
+        alpha = fn(np.array([[80., 20.], [60., 40.]]), np.ones((2, 2), bool),
+                   np.array([[10., 90.], [30., 70.]]), np.ones(2, bool))
+        np.testing.assert_allclose(alpha, [2 / 7, 8 / 3])
+
+    def test_unmeasured_reference_gene_is_not_estimated(self):
+        fn = self.function()
+        alpha = fn(np.array([[80., 20.]]), np.ones((1, 2), bool),
+                   np.array([[10., 90.]]), np.array([True, False]))
+        self.assertEqual(alpha[1], 1.)
+
+    def test_missing_bulk_measurement_cannot_invent_signal(self):
+        fn = self.function()
+        alpha = fn(np.array([[80., 20.], [100., 0.]]), np.array([[True, True], [True, False]]),
+                   np.array([[10., 90.]]), np.ones(2, bool))
+        self.assertEqual(alpha[1], 1.)
+
+    def test_zero_total_rejected(self):
+        with self.assertRaises(ValueError):
+            self.function()(np.zeros((1, 2)), np.ones((1, 2), bool), np.ones((1, 2)), np.ones(2, bool))
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,48 @@
+"""Small CPU checks for the Figure 2 P/C rescore."""
+
+import importlib.util
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+
+SCRIPT = Path(__file__).parents[1] / "tools" / "rescore_pretrain_ablations.py"
+spec = importlib.util.spec_from_file_location("rescore_pretrain_ablations", SCRIPT)
+mod = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(mod)
+
+
+def test_missing_genes_fail_closed():
+    assert mod.gene_columns(["a", "b", "c"], ["c", "a"]).tolist() == [2, 0]
+    with pytest.raises(ValueError, match="missing"):
+        mod.gene_columns(["a", "b"], ["a", "c"])
+
+
+def test_zero_and_reference_distributions():
+    r = np.arange(30, dtype=np.float32).reshape(10, 3)
+    same = mod.score_pc(r, r.copy(), k=2)
+    assert same["coverage"] == 1.0
+    assert same["precision"] == 1.0
+    distant = mod.score_pc(r, r + 10000, k=2)
+    assert distant["coverage"] == 0.0
+    assert distant["precision"] == 0.0
+    zeros = mod.score_pc(np.zeros((10, 3), np.float32), np.zeros((10, 3), np.float32), k=2)
+    assert zeros["coverage"] == 1.0
+    assert zeros["precision"] == 1.0
+
+
+def test_disjoint_balanced_split_and_hash():
+    labels = np.repeat(["d1", "d2"], 12)
+    a, b = mod.balanced_real_split(labels, ["d1", "d2"], 5, 3)
+    assert len(a) == len(b) == 10
+    assert not set(a).intersection(b)
+    assert mod.sha_array(a) == mod.sha_array(a.copy())
+
+
+def test_streamed_npz_keeps_requested_row_and_gene_order(tmp_path):
+    path = tmp_path / "small.npz"
+    matrix = np.arange(30, dtype=np.float32).reshape(6, 5)
+    np.savez_compressed(path, generated_counts=matrix)
+    got = mod.stream_selected_npz(path, np.array([4, 0, 5]), np.array([3, 1]), batch=2)
+    np.testing.assert_array_equal(got, matrix[[4, 0, 5]][:, [3, 1]])

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

@@ -0,0 +1,115 @@
+"""Safety and resume invariants for the scientific campaign runner."""
+import importlib.util
+import json
+import os
+from pathlib import Path
+import tempfile
+import unittest
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+class RuntimeTests(unittest.TestCase):
+    def load(self):
+        self.assertTrue((ROOT / "tools/runtime.py").is_file(), "campaign runtime is not implemented")
+        spec = importlib.util.spec_from_file_location("campaign_runtime", ROOT / "tools/runtime.py")
+        self.assertIsNotNone(spec, "runtime implementation missing")
+        mod = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(mod)
+        return mod
+
+    def test_changed_scientific_input_cannot_reuse_completed_operation(self):
+        mod = self.load()
+        with tempfile.TemporaryDirectory() as td:
+            root = Path(td)
+            inp, output = root / "support.json", root / "output.csv"
+            inp.write_text('{"train_sample_ids":["a"]}')
+            output.write_text("value\n1\n")
+            runtime = mod.Runtime(root)
+            signature = runtime.signature(["tool", "--support", str(inp)], [inp])
+            runtime.record_completed("score", signature, [output], 0.1)
+            inp.write_text('{"train_sample_ids":["b"]}')
+            changed = runtime.signature(["tool", "--support", str(inp)], [inp])
+            with self.assertRaises(mod.ReceiptError):
+                runtime.can_skip("score", changed, [output])
+
+    def test_modified_output_is_not_silently_accepted(self):
+        mod = self.load()
+        with tempfile.TemporaryDirectory() as td:
+            root = Path(td)
+            output = root / "output.csv"
+            output.write_text("value\n1\n")
+            runtime = mod.Runtime(root)
+            sig = runtime.signature(["tool"], [])
+            runtime.record_completed("score", sig, [output], 0.1)
+            self.assertTrue(runtime.can_skip("score", sig, [output]))
+            output.write_text("value\n999\n")
+            with self.assertRaises(mod.ReceiptError):
+                runtime.can_skip("score", sig, [output])
+
+    def test_unreceipted_existing_output_is_preserved_and_rejected(self):
+        mod = self.load()
+        with tempfile.TemporaryDirectory() as td:
+            root = Path(td)
+            output = root / "output.npz"
+            output.write_bytes(b"partial output must survive")
+            runtime = mod.Runtime(root)
+            with self.assertRaises(mod.ReceiptError):
+                runtime.can_skip("sample", runtime.signature(["tool"], []), [output])
+            self.assertEqual(output.read_bytes(), b"partial output must survive")
+
+    def test_same_size_and_timestamp_do_not_hide_replaced_scientific_output(self):
+        mod = self.load()
+        with tempfile.TemporaryDirectory() as td:
+            root = Path(td)
+            output = root / "output.csv"
+            output.write_bytes(b"value\n1\n")
+            runtime = mod.Runtime(root)
+            signature = runtime.signature(["score"], [])
+            runtime.record_completed("score", signature, [output], .1)
+            before = output.stat()
+            output.write_bytes(b"value\n9\n")
+            os.utime(output, ns=(before.st_atime_ns, before.st_mtime_ns))
+            with self.assertRaises(mod.ReceiptError):
+                runtime.can_skip("score", signature, [output])
+
+    def test_failed_action_requires_review_before_retry(self):
+        mod = self.load()
+        with tempfile.TemporaryDirectory() as td:
+            root = Path(td)
+            runtime = mod.Runtime(root)
+            runtime.write_receipt("sample", {"state": "failed", "exit_code": 1})
+            with self.assertRaises(mod.ReceiptError):
+                runtime.can_skip("sample", "new", [])
+
+    def test_preview_replacement_requires_verified_preserved_copy(self):
+        mod = self.load()
+        with tempfile.TemporaryDirectory() as td:
+            root = Path(td)
+            current = root / "reports/readiness.json"
+            current.parent.mkdir()
+            current.write_text('{"status":"pending"}')
+            backup = root / "preview.json"
+            backup.write_bytes(current.read_bytes())
+            runtime = mod.Runtime(root)
+            proof = {str(current): {"backup": str(backup), "sha256": mod.sha256(current)}}
+            self.assertFalse(runtime.can_skip("render", "new", [current], previous_outputs=proof))
+            backup.write_text("changed")
+            with self.assertRaises(mod.ReceiptError):
+                runtime.can_skip("render", "new", [current], previous_outputs=proof)
+
+    def test_cuda_and_cpu_commands_are_contained(self):
+        mod = self.load()
+        with tempfile.TemporaryDirectory() as td:
+            runtime = mod.Runtime(Path(td))
+            gpu = runtime.wrapped_command("train", ["python", "train.py"], "gpu", 16, 4)
+            cpu = runtime.wrapped_command("score", ["python", "score.py"], "cpu", 16, 4)
+            self.assertEqual(Path(gpu[0]).name, "ml-run")
+            self.assertIn("CUDA_VISIBLE_DEVICES=0", gpu)
+            self.assertIn("MemorySwapMax=0", cpu)
+            self.assertIn("OOMPolicy=kill", cpu)
+            self.assertIn("CUDA_VISIBLE_DEVICES=", cpu)
+
+
+if __name__ == "__main__":
+    unittest.main()