| import json |
|
|
| import numpy as np |
| import pandas as pd |
| import pytest |
|
|
| from clc_mini_bench.data import ( |
| ROOT, assign_families, assign_folds, build, gene_candidates, grouped_folds, |
| load_protocol, merge_measurements, validate_dataset, |
| ) |
|
|
|
|
| def test_duplicate_measurements_aggregate_in_pkd_space(): |
| raw = pd.DataFrame([ |
| {"clone_id": "a", "platform": "P", "VH": "ACDEF", "VL": "GGGG", "KD_M": 1e-9, "source_table": "5"}, |
| {"clone_id": "b", "platform": "P", "VH": "ACDEF", "VL": "GGGG", "KD_M": 1e-7, "source_table": "5"}, |
| ]) |
| frame = merge_measurements(raw) |
| assert len(frame) == 1 |
| assert frame.iloc[0].pKD == pytest.approx(8.0) |
| assert frame.iloc[0].KD_M == pytest.approx(1e-8) |
| assert frame.iloc[0].clone_id == "a|b" |
| assert frame.iloc[0].measurement_count == 2 |
|
|
|
|
| def test_invalid_affinity_and_duplicate_ids_rejected(): |
| raw = pd.DataFrame([{"clone_id": "a", "platform": "P", "VH": "ACDEF", "VL": "GGGG", "KD_M": 0, "source_table": "5"}]) |
| with pytest.raises(ValueError, match="positive"): |
| merge_measurements(raw) |
| raw.KD_M = 1e-8 |
| with pytest.raises(ValueError, match="Duplicate clone"): |
| merge_measurements(pd.concat([raw, raw])) |
|
|
|
|
| def test_single_linkage_gene_and_length_constraints(): |
| frame = pd.DataFrame([ |
| {"sample_id": "a", "platform": "P", "V_gene": "V1;V2", "J_gene": "J1", "CDRH3": "AAAA"}, |
| {"sample_id": "b", "platform": "P", "V_gene": "V2", "J_gene": "J1", "CDRH3": "AACC"}, |
| {"sample_id": "c", "platform": "P", "V_gene": "V2", "J_gene": "J1", "CDRH3": "CCCC"}, |
| {"sample_id": "d", "platform": "P", "V_gene": "V3", "J_gene": "J1", "CDRH3": "AAAA"}, |
| {"sample_id": "e", "platform": "P", "V_gene": "V1", "J_gene": "J2", "CDRH3": "AAAA"}, |
| {"sample_id": "f", "platform": "P", "V_gene": "V1", "J_gene": "J1", "CDRH3": "AAAAA"}, |
| {"sample_id": "g", "platform": "Q", "V_gene": "V1", "J_gene": "J1", "CDRH3": "AAAA"}, |
| ]) |
| result = assign_families(frame).set_index("sample_id") |
| assert result.loc["a", "family_id"] == result.loc["b", "family_id"] == result.loc["c", "family_id"] |
| assert result.family_id.nunique() == 5 |
| assert gene_candidates("IGHV1-1*01_IGHV1-1*02_IGHV2-1*01") == {"IGHV1-1", "IGHV2-1"} |
|
|
|
|
| def test_folds_are_reproducible_group_disjoint_and_row_order_independent(): |
| groups = ["a"] * 8 + ["b"] * 6 + ["c"] * 4 + ["d", "e", "f", "g", "h"] |
| ids = grouped_folds(groups, 5, 42) |
| assert np.array_equal(ids, grouped_folds(groups, 5, 42)) |
| mapping = dict(zip(groups, ids)) |
| shuffled = list(reversed(groups)) |
| assert [mapping[g] for g in shuffled] == grouped_folds(shuffled, 5, 42).tolist() |
| assert set(ids) == set(range(5)) |
| for g in set(groups): |
| assert len(set(ids[np.array(groups) == g])) == 1 |
|
|
|
|
| def test_checked_in_source_data_and_prepared_data(): |
| raw = pd.read_csv(ROOT / "data/raw/measurements.csv", dtype={"clone_id": str}) |
| assert raw.groupby("platform").size().to_dict() == {"OmniClic": 170, "OmniFlic": 245} |
| assert not raw.duplicated(["platform", "clone_id"]).any() |
| expected = {"omniclic": 161, "omniflic": 213} |
| for name, n in expected.items(): |
| frame = pd.read_csv(ROOT / f"data/processed/{name}_nkp46.csv") |
| validate_dataset(frame) |
| assert len(frame) == n |
| assert frame.fold_id.nunique() == 5 |
| replay = assign_folds(frame.drop(columns="fold_id"), load_protocol()) |
| assert np.array_equal(replay.fold_id, frame.fold_id) |
| excluded = pd.read_csv(ROOT / "data/processed/excluded.csv", dtype={"clone_id": str}).set_index("clone_id") |
| assert set(excluded.index) == {"Gen_1", "50"} |
| assert excluded.loc["Gen_1", "numbering_end"] == 121 |
| assert excluded.loc["50", "exclusion_reason"] == "excluded_sequence_group" |
|
|
|
|
| def test_source_sequences_use_filed_xml_and_match_filed_cdrs(): |
| import xml.etree.ElementTree as ET |
| root = ET.parse(ROOT / "data/raw/OMNI-002WO_SEQLIST.xml").getroot() |
| sequences = {int(e.attrib["sequenceIDNumber"]): e.findtext("INSDSeq/INSDSeq_sequence") for e in root.findall("SequenceData")} |
| raw = pd.read_csv(ROOT / "data/raw/measurements.csv", dtype={"clone_id": str}) |
| for row in raw.itertuples(index=False): |
| assert sequences[row.vh_seq_id] == row.VH |
| assert sequences[row.vl_seq_id] == row.VL |
| assert sequences[row.cdr3_seq_id] == row.patent_CDRH3 |
| assert row.patent_CDRH3 in row.VH |
| verification = json.loads((ROOT / "data/raw/full_vh_verification.json").read_text()) |
| assert verification["verified_clone_to_full_VH_SEQ_ID_count"] == 415 |
|
|
|
|
| def test_build_omniclic_uses_only_non_v2_measurements(tmp_path): |
| raw = pd.read_csv(ROOT / "data/raw/measurements.csv", dtype={"clone_id": str}) |
| manifest = build(ROOT / "data/raw/measurements.csv", tmp_path) |
| frame = pd.read_csv(tmp_path / "omniclic_nkp46.csv", dtype={"clone_id": str}) |
| original = raw.loc[raw.platform.eq("OmniClic") & ~raw.clone_id.str.endswith("_v2") & raw.clone_id.ne("50")].set_index("clone_id") |
| assert len(original) == len(frame) == 161 |
| assert set(frame.clone_id) == set(original.index) |
| assert frame.measurement_count.eq(1).all() |
| assert not frame.clone_id.str.contains("_v2", regex=False).any() |
| np.testing.assert_allclose(frame.KD_M, original.loc[frame.clone_id, "KD_M"], rtol=1e-10, atol=0) |
| np.testing.assert_allclose(frame.pKD, -np.log10(original.loc[frame.clone_id, "KD_M"]), rtol=1e-10, atol=0) |
| expected_excluded = set(raw.loc[raw.platform.eq("OmniClic") & raw.clone_id.str.endswith("_v2"), "clone_id"]) |
| excluded_all = pd.read_csv(tmp_path / "excluded_measurements.csv", dtype={"clone_id": str}) |
| excluded = excluded_all.loc[excluded_all.platform.eq("OmniClic")] |
| assert len(excluded) == len(expected_excluded) == 8 |
| assert set(excluded.clone_id) == expected_excluded |
| index = pd.read_csv(tmp_path / "clone_to_sample.csv", dtype={"clone_id": str}) |
| assert not index.loc[index.clone_id.isin(expected_excluded), "included"].any() |
| assert index.loc[index.clone_id.isin(original.index) & index.platform.eq("OmniClic"), "included"].all() |
| assert manifest["datasets"]["OmniClic"]["included_measurement_count"] == 161 |
| assert manifest["datasets"]["OmniClic"]["excluded_measurement_count"] == 9 |
| for platform in ("omniclic", "omniflic"): |
| old = pd.read_csv(ROOT / f"data/processed/{platform}_nkp46.csv").set_index("sample_id") |
| new = pd.read_csv(tmp_path / f"{platform}_nkp46.csv").set_index("sample_id") |
| pd.testing.assert_frame_equal(new[["VH", "VL", "family_id", "fold_id"]], old[["VH", "VL", "family_id", "fold_id"]]) |
| assert (tmp_path / "omniflic_nkp46.csv").read_bytes() == (ROOT / "data/processed/omniflic_nkp46.csv").read_bytes() |
|
|
|
|
| def test_omniclic_50_group_is_removed_without_changing_other_samples_or_partitions(tmp_path): |
| raw_path = ROOT / "data/raw/measurements.csv" |
| previous_protocol = load_protocol() |
| previous_protocol["version"] = "0.5.0" |
| previous_protocol["inclusion"].pop("excluded_sequence_groups") |
| previous_protocol["inclusion"].pop("sequence_group_exclusion_stage") |
| previous_path = tmp_path / "v0_5_0.json" |
| previous_path.write_text(json.dumps(previous_protocol)) |
| build(raw_path, tmp_path / "previous", previous_path) |
| manifest = build(raw_path, tmp_path / "current") |
| previous = pd.read_csv(tmp_path / "previous/omniclic_nkp46.csv", dtype={"clone_id": str}) |
| current = pd.read_csv(tmp_path / "current/omniclic_nkp46.csv", dtype={"clone_id": str}) |
| removed = previous.loc[previous.clone_id.eq("50")].iloc[0] |
| assert len(previous) == 162 and len(current) == 161 |
| pd.testing.assert_frame_equal(current.reset_index(drop=True), previous.loc[previous.clone_id.ne("50")].reset_index(drop=True)) |
| assert not ((current.VH == removed.VH) & (current.VL == removed.VL)).any() |
| index = pd.read_csv(tmp_path / "current/clone_to_sample.csv", dtype={"clone_id": str}) |
| pair = index.loc[index.platform.eq("OmniClic") & index.clone_id.isin(["50", "0050_v2"])] |
| assert len(pair) == 2 and not pair.included.any() |
| excluded = pd.read_csv(tmp_path / "current/excluded.csv", dtype={"clone_id": str}).set_index("clone_id") |
| assert excluded.loc["50", "sample_id"] == removed.sample_id |
| assert excluded.loc["50", "exclusion_reason"] == "excluded_sequence_group" |
| assert current.groupby("fold_id").size().to_dict() == {0: 27, 1: 28, 2: 43, 3: 28, 4: 35} |
| for chain in ("VH", "VL"): |
| assert removed.sample_id not in (tmp_path / f"current/omniclic_nkp46.{chain}.fasta").read_text() |
| assert (tmp_path / "previous/omniflic_nkp46.csv").read_bytes() == (tmp_path / "current/omniflic_nkp46.csv").read_bytes() |
| assert manifest["datasets"]["OmniClic"]["included_measurement_count"] == 161 |
|
|
|
|
| def test_build_omniflic_prefers_rat_measurements(tmp_path): |
| raw = pd.read_csv(ROOT / "data/raw/measurements.csv", dtype={"clone_id": str}) |
| source = raw.loc[raw.platform.eq("OmniFlic")] |
| rat = source.loc[source.clone_id.str.startswith("Rat_")] |
| numeric = source.loc[source.clone_id.str.fullmatch(r"\d+") & ~source.VH.isin(rat.VH)] |
| expected = pd.concat([rat, numeric]).set_index("clone_id") |
| assert len(rat) == 138 and len(numeric) == 75 |
| manifest = build(ROOT / "data/raw/measurements.csv", tmp_path) |
| frame = pd.read_csv(tmp_path / "omniflic_nkp46.csv", dtype={"clone_id": str}) |
| assert len(frame) == len(expected) == 213 |
| assert set(frame.clone_id) == set(expected.index) |
| assert frame.measurement_count.eq(1).all() |
| np.testing.assert_allclose(frame.KD_M, expected.loc[frame.clone_id, "KD_M"], rtol=1e-10, atol=0) |
| np.testing.assert_allclose(frame.pKD, -np.log10(expected.loc[frame.clone_id, "KD_M"]), rtol=1e-10, atol=0) |
| assert frame.set_index("clone_id").loc["Rat_108", "KD_M"] == pytest.approx(73.1e-9, rel=1e-10, abs=0) |
| excluded = pd.read_csv(tmp_path / "excluded_measurements.csv", dtype={"clone_id": str}) |
| superseded = excluded.loc[excluded.platform.eq("OmniFlic")] |
| assert len(superseded) == 31 |
| assert superseded.exclusion_reason.eq("superseded_by_preferred_clone_id_prefix").all() |
| assert superseded.clone_id.str.fullmatch(r"\d+").all() |
| assert len(superseded.drop_duplicates(["VH", "VL"])) == 30 |
| index = pd.read_csv(tmp_path / "clone_to_sample.csv", dtype={"clone_id": str}) |
| assert not index.loc[index.platform.eq("OmniFlic") & index.clone_id.isin(superseded.clone_id), "included"].any() |
| assert index.loc[index.platform.eq("OmniFlic") & index.clone_id.isin(expected.index), "included"].all() |
| assert manifest["datasets"]["OmniFlic"]["included_measurement_count"] == 213 |
| assert manifest["datasets"]["OmniFlic"]["excluded_measurement_count"] == 32 |
| assert (tmp_path / "omniclic_nkp46.csv").read_bytes() == (ROOT / "data/processed/omniclic_nkp46.csv").read_bytes() |
| original = source.loc[source.clone_id.eq("9451")].copy() |
| ambiguous = original.copy() |
| ambiguous["clone_id"] = "unresolved_duplicate" |
| ambiguous["KD_M"] *= 2 |
| ambiguous_path = tmp_path / "unresolved_raw.csv" |
| pd.concat([original, ambiguous]).to_csv(ambiguous_path, index=False) |
| with pytest.raises(ValueError, match="retain one original measurement"): |
| build(ambiguous_path, tmp_path / "unresolved_output") |
|
|
