From 2a54dd62a62749b6585f68dcc68923914b10c72c Mon Sep 17 00:00:00 2001 From: Jerry Wang Date: Sat, 23 May 2026 17:15:24 +0800 Subject: [PATCH] Remove stale utils tests --- test/test_add_n_top.py | 232 ---------------------- test/test_baseline_scores.py | 243 ------------------------ test/test_concat_embedding.py | 98 ---------- test/test_generate_partial_summaries.py | 106 ----------- 4 files changed, 679 deletions(-) delete mode 100644 test/test_add_n_top.py delete mode 100644 test/test_baseline_scores.py delete mode 100644 test/test_concat_embedding.py delete mode 100644 test/test_generate_partial_summaries.py diff --git a/test/test_add_n_top.py b/test/test_add_n_top.py deleted file mode 100644 index 7e8d373..0000000 --- a/test/test_add_n_top.py +++ /dev/null @@ -1,232 +0,0 @@ -"""Unit tests for recomputing n_top columns in results CSVs.""" - -from __future__ import annotations - -import csv -import sys -from pathlib import Path - -import numpy as np -import pandas as pd -import pytest - -from utils import add_n_top - - -def _write_npz(path: Path, ids: np.ndarray) -> None: - path.parent.mkdir(parents=True, exist_ok=True) - np.savez(path, embeddings=np.ones((len(ids), 2)), ids=ids) - - -def _read_rows(path: Path) -> list[dict[str, str]]: - with path.open(newline="") as handle: - return list(csv.DictReader(handle)) - - -def test_parse_and_normalize_selected_ids() -> None: - assert add_n_top._parse_selected_ids([1, "2"]) == [1, "2"] - assert add_n_top._parse_selected_ids("[1, 'x']") == [1, "x"] - assert add_n_top._parse_selected_ids("a,b,, c") == ["a", "b", " c"] - assert add_n_top._parse_selected_ids(None) == [] - - assert add_n_top._normalize_id(3) == "3" - assert add_n_top._normalize_id(np.int64(4)) == "4" - assert add_n_top._normalize_id("5.0") == "5" - assert add_n_top._normalize_id("variant_a") == "variant_a" - assert add_n_top._normalize_id(" ") == "" - - -def test_resolve_embedding_model_prefers_summary_then_overrides() -> None: - assert ( - add_n_top._resolve_embedding_model({"embedding_model": "model_a"}) == "model_a" - ) - assert ( - add_n_top._resolve_embedding_model( - {"embedding_model": "NONE", "hydra_overrides": ["+embedding_model=model_b"]} - ) - == "model_b" - ) - assert ( - add_n_top._resolve_embedding_model( - {"hydra_overrides": ["embedding_model: model_c"]} - ) - == "model_c" - ) - assert add_n_top._resolve_embedding_model({}) is None - - -def test_load_dataset_map_resolves_paths_and_validates_entries(tmp_path: Path) -> None: - yaml_path = tmp_path / "datasets.yaml" - yaml_path.write_text( - "datasets:\n" - " - name: toy\n" - " metadata_path: labels.csv\n" - " embedding_dir: embeddings\n" - " subset_ids_path: subset.txt\n" - ) - - dataset_map = add_n_top._load_dataset_map(yaml_path) - - assert dataset_map["toy"] == { - "metadata_path": (tmp_path / "labels.csv").resolve(), - "embedding_dir": (tmp_path / "embeddings").resolve(), - "subset_ids_path": (tmp_path / "subset.txt").resolve(), - } - - with pytest.raises(FileNotFoundError): - add_n_top._load_dataset_map(tmp_path / "missing.yaml") - - yaml_path.write_text("datasets: []\n") - with pytest.raises(ValueError, match="No datasets"): - add_n_top._load_dataset_map(yaml_path) - - yaml_path.write_text("datasets:\n - name: toy\n metadata_path: labels.csv\n") - with pytest.raises(ValueError, match="missing embedding_dir"): - add_n_top._load_dataset_map(yaml_path) - - -def test_compute_top_id_set_uses_embeddings_metadata_and_subset(tmp_path: Path) -> None: - embeddings_path = tmp_path / "embeddings" / "toy_model.npz" - metadata_path = tmp_path / "labels.csv" - subset_path = tmp_path / "subset.txt" - _write_npz(embeddings_path, np.array([0, 1, 2, 3])) - pd.DataFrame({"label": [0.1, 0.9, 0.3, 0.8]}).to_csv(metadata_path, index=False) - subset_path.write_text("0\n2\n3\n") - - assert add_n_top._compute_top_id_set( - embeddings_path=embeddings_path, - metadata_path=metadata_path, - label_key="label", - subset_ids_path=None, - top_p=0.5, - ) == {"1", "3"} - assert add_n_top._compute_top_id_set( - embeddings_path=embeddings_path, - metadata_path=metadata_path, - label_key="label", - subset_ids_path=subset_path, - top_p=0.34, - ) == {"3"} - - subset_path.write_text("99\n") - with pytest.raises(ValueError, match="removed all samples"): - add_n_top._compute_top_id_set( - embeddings_path=embeddings_path, - metadata_path=metadata_path, - label_key="label", - subset_ids_path=subset_path, - top_p=0.5, - ) - - -def test_load_helpers_validate_inputs(tmp_path: Path) -> None: - subset_path = tmp_path / "subset.txt" - subset_path.write_text("bad\n") - with pytest.raises(ValueError, match="Invalid sample id"): - add_n_top._load_subset_ids(subset_path) - - subset_path.write_text("\n") - with pytest.raises(ValueError, match="did not contain"): - add_n_top._load_subset_ids(subset_path) - - embeddings_path = tmp_path / "no_ids.npz" - np.savez(embeddings_path, embeddings=np.ones((2, 2))) - with pytest.raises(ValueError, match="ids"): - add_n_top._load_sample_ids(embeddings_path) - - with pytest.raises(FileNotFoundError): - add_n_top._load_summary(tmp_path / "missing_summary.json") - - -def test_update_results_csv_writes_counts_and_respects_overwrite( - tmp_path: Path, -) -> None: - results_path = tmp_path / "results.csv" - results_path.write_text( - 'round,selected_sample_ids,n_top\n0,"[1, 3, 5]",old\n1,"[2, 4]",old\n' - ) - - assert not add_n_top._update_results_csv( - results_path, top_ids={"1", "3"}, column_name="n_top", overwrite=False - ) - - assert add_n_top._update_results_csv( - results_path, top_ids={"1", "3"}, column_name="n_top", overwrite=True - ) - rows = _read_rows(results_path) - assert [row["n_top"] for row in rows] == ["2", "0"] - - assert add_n_top._update_results_csv( - results_path, top_ids={"2", "4"}, column_name="n_top_50", overwrite=False - ) - rows = _read_rows(results_path) - assert rows[0]["n_top_50"] == "0" - assert rows[1]["n_top_50"] == "2" - - -def test_update_results_csv_handles_empty_and_missing_columns(tmp_path: Path) -> None: - empty_path = tmp_path / "empty.csv" - empty_path.write_text("selected_sample_ids\n") - assert not add_n_top._update_results_csv( - empty_path, top_ids={"1"}, column_name="n_top", overwrite=False - ) - - missing_path = tmp_path / "missing.csv" - missing_path.write_text("round\n0\n") - with pytest.raises(ValueError, match="selected_sample_ids"): - add_n_top._update_results_csv( - missing_path, top_ids={"1"}, column_name="n_top", overwrite=False - ) - - -def test_main_updates_results_from_dataset_yaml(tmp_path: Path, monkeypatch) -> None: - metadata_path = tmp_path / "labels.csv" - embeddings_dir = tmp_path / "embeddings" - datasets_yaml = tmp_path / "datasets.yaml" - run_dir = tmp_path / "runs" / "run_0" - results_path = run_dir / "results.csv" - run_dir.mkdir(parents=True) - pd.DataFrame({"label": [0.1, 0.9, 0.3, 0.8]}).to_csv(metadata_path, index=False) - _write_npz(embeddings_dir / "toy_model.npz", np.array([0, 1, 2, 3])) - datasets_yaml.write_text( - "datasets:\n" - " - name: toy\n" - f" metadata_path: {metadata_path}\n" - f" embedding_dir: {embeddings_dir}\n" - ) - (run_dir / "summary.json").write_text( - '{"dataset_name": "toy", "embedding_model": "toy_model"}' - ) - results_path.write_text('round,selected_sample_ids\n0,"[1, 3]"\n1,"[0, 2]"\n') - monkeypatch.setattr( - sys, - "argv", - [ - "add_n_top.py", - str(tmp_path / "runs"), - "--datasets-yaml", - str(datasets_yaml), - "--top-p", - "0.5", - "--column-name", - "n_top", - "--label-key", - "label", - ], - ) - - assert add_n_top.main() == 0 - - rows = _read_rows(results_path) - assert [row["n_top"] for row in rows] == ["2", "0"] - - -def test_main_rejects_invalid_arguments(tmp_path: Path, monkeypatch) -> None: - monkeypatch.setattr(sys, "argv", ["add_n_top.py", str(tmp_path), "--top-p", "2"]) - with pytest.raises(SystemExit, match="top_p"): - add_n_top.main() - - missing = tmp_path / "missing" - monkeypatch.setattr(sys, "argv", ["add_n_top.py", str(missing)]) - with pytest.raises(SystemExit, match="Root dir not found"): - add_n_top.main() diff --git a/test/test_baseline_scores.py b/test/test_baseline_scores.py deleted file mode 100644 index 941b377..0000000 --- a/test/test_baseline_scores.py +++ /dev/null @@ -1,243 +0,0 @@ -""" -Unit tests for baseline_scores helpers. -""" - -from types import SimpleNamespace - -import numpy as np -import pandas as pd -import pytest - -from utils import baseline_scores -from utils.baseline_scores import ( - DatasetSpec, - build_top_mask, - compute_random_summary_metrics_history, - draw_random_rounds, - load_dataset_specs, - load_labels, - load_subset_ids, -) - - -def test_rounds_to_top_all_nan_when_no_hits(): - labels = np.array([1.0, 2.0, 3.0, 4.0], dtype=float) - top_mask = np.zeros(len(labels), dtype=bool) - - history = compute_random_summary_metrics_history( - labels=labels, - top_mask=top_mask, - max_label=float(labels.max()), - num_rounds=2, - num_samples_per_round=2, - seed=0, - ) - - assert len(history) == 2 - for record in history: - assert np.isnan(record["rounds_to_top"]) - - -def test_rounds_to_top_first_hit_persists(): - labels = np.linspace(1.0, 6.0, 6, dtype=float) - num_rounds = 3 - num_samples_per_round = 2 - seed = 7 - - rng = np.random.default_rng(seed) - rounds = draw_random_rounds( - num_samples=len(labels), - num_rounds=num_rounds, - num_samples_per_round=num_samples_per_round, - rng=rng, - ) - - top_mask = np.zeros(len(labels), dtype=bool) - top_mask[int(rounds[1][0])] = True - - history = compute_random_summary_metrics_history( - labels=labels, - top_mask=top_mask, - max_label=float(labels.max()), - num_rounds=num_rounds, - num_samples_per_round=num_samples_per_round, - seed=seed, - ) - - assert np.isnan(history[0]["rounds_to_top"]) - assert pytest.approx(2.0) == history[1]["rounds_to_top"] - assert pytest.approx(2.0) == history[2]["rounds_to_top"] - - -def test_load_dataset_specs_resolves_relative_paths(tmp_path): - (tmp_path / "metadata.csv").write_text("label\n1\n") - (tmp_path / "subset.txt").write_text("0\n") - yaml_path = tmp_path / "datasets.yaml" - yaml_path.write_text( - "datasets:\n" - " - name: toy\n" - " metadata_path: metadata.csv\n" - " subset_ids_path: subset.txt\n" - ) - - specs = load_dataset_specs(yaml_path) - - assert specs == [ - DatasetSpec( - name="toy", - metadata_path=(tmp_path / "metadata.csv").resolve(), - subset_ids_path=(tmp_path / "subset.txt").resolve(), - ) - ] - - -def test_load_dataset_specs_validates_required_fields(tmp_path): - missing = tmp_path / "missing.yaml" - with pytest.raises(FileNotFoundError): - load_dataset_specs(missing) - - yaml_path = tmp_path / "datasets.yaml" - yaml_path.write_text("datasets: []\n") - with pytest.raises(ValueError, match="No datasets"): - load_dataset_specs(yaml_path) - - yaml_path.write_text("datasets:\n - metadata_path: labels.csv\n") - with pytest.raises(ValueError, match="missing name"): - load_dataset_specs(yaml_path) - - yaml_path.write_text("datasets:\n - name: toy\n") - with pytest.raises(ValueError, match="missing metadata_path"): - load_dataset_specs(yaml_path) - - -def test_load_subset_ids_skips_blanks_and_rejects_bad_values(tmp_path): - subset_path = tmp_path / "subset.txt" - subset_path.write_text("\n1\n 3 \n") - np.testing.assert_array_equal(load_subset_ids(subset_path), np.array([1, 3])) - - subset_path.write_text("a\n") - with pytest.raises(ValueError, match="Invalid sample id"): - load_subset_ids(subset_path) - - subset_path.write_text("\n") - with pytest.raises(ValueError, match="did not contain any ids"): - load_subset_ids(subset_path) - - -def test_load_labels_applies_subset_and_filters_nonfinite(tmp_path): - metadata_path = tmp_path / "metadata.csv" - pd.DataFrame({"label": [1.0, "bad", 3.5, np.nan]}).to_csv( - metadata_path, index=False - ) - subset_path = tmp_path / "subset.txt" - subset_path.write_text("0\n1\n2\n") - dataset = DatasetSpec("toy", metadata_path, subset_path) - - labels, sample_ids = load_labels(dataset, "label", {}, {}) - - np.testing.assert_allclose(labels, np.array([1.0, 3.5])) - np.testing.assert_array_equal(sample_ids, np.array([0, 2])) - - -def test_load_labels_rejects_missing_label_out_of_bounds_and_empty(tmp_path): - metadata_path = tmp_path / "metadata.csv" - pd.DataFrame({"label": [np.nan, np.nan]}).to_csv(metadata_path, index=False) - dataset = DatasetSpec("toy", metadata_path) - - with pytest.raises(ValueError, match="Label key"): - load_labels(dataset, "missing", {}, {}) - - subset_path = tmp_path / "subset.txt" - subset_path.write_text("2\n") - with pytest.raises(ValueError, match="out of bounds"): - load_labels(DatasetSpec("toy", metadata_path, subset_path), "label", {}, {}) - - with pytest.raises(ValueError, match="No finite labels"): - load_labels(dataset, "label", {}, {}) - - -def test_build_top_mask_marks_highest_values() -> None: - labels = np.array([1.0, 5.0, 3.0, 4.0]) - - np.testing.assert_array_equal( - build_top_mask(labels, 0.25), [False, True, False, False] - ) - np.testing.assert_array_equal(build_top_mask(labels, 1.0), [True, True, True, True]) - - -def test_draw_random_rounds_validates_sample_counts() -> None: - rng = np.random.default_rng(0) - - with pytest.raises(ValueError, match="must be > 0"): - draw_random_rounds(10, 0, 2, rng) - with pytest.raises(ValueError, match="exceed dataset size"): - draw_random_rounds(3, 2, 2, rng) - - -def test_main_writes_random_baseline_csv(tmp_path, monkeypatch): - metadata_path = tmp_path / "metadata.csv" - pd.DataFrame({"label": [1.0, 2.0, 3.0, 4.0]}).to_csv(metadata_path, index=False) - yaml_path = tmp_path / "datasets.yaml" - yaml_path.write_text( - f"datasets:\n - name: toy\n metadata_path: {metadata_path}\n" - ) - output_csv = tmp_path / "baseline.csv" - monkeypatch.setattr( - baseline_scores, - "parse_args", - lambda: SimpleNamespace( - datasets_yaml=str(yaml_path), - output_csv=str(output_csv), - label_key="label", - num_experiments=2, - num_rounds=2, - num_samples_per_round=1, - top_p=0.25, - dataset=["toy"], - ), - ) - monkeypatch.setattr(baseline_scores, "tqdm", lambda iterable: iterable) - - baseline_scores.main() - - frame = pd.read_csv(output_csv) - assert len(frame) == 4 - assert set(frame["dataset_name"]) == {"toy"} - assert set(frame["seed"]) == {0, 1} - - -def test_main_validates_arguments_and_dataset_filter(tmp_path, monkeypatch): - metadata_path = tmp_path / "metadata.csv" - pd.DataFrame({"label": [1.0, 2.0]}).to_csv(metadata_path, index=False) - yaml_path = tmp_path / "datasets.yaml" - yaml_path.write_text( - f"datasets:\n - name: toy\n metadata_path: {metadata_path}\n" - ) - - def set_args(**updates): - base = { - "datasets_yaml": str(yaml_path), - "output_csv": str(tmp_path / "out.csv"), - "label_key": "label", - "num_experiments": 1, - "num_rounds": 1, - "num_samples_per_round": 1, - "top_p": 0.25, - "dataset": [], - } - base.update(updates) - monkeypatch.setattr( - baseline_scores, "parse_args", lambda: SimpleNamespace(**base) - ) - - set_args(num_experiments=0) - with pytest.raises(ValueError, match="num_experiments"): - baseline_scores.main() - - set_args(top_p=2.0) - with pytest.raises(ValueError, match="top_p"): - baseline_scores.main() - - set_args(dataset=["missing"]) - with pytest.raises(ValueError, match="Requested datasets not found"): - baseline_scores.main() diff --git a/test/test_concat_embedding.py b/test/test_concat_embedding.py deleted file mode 100644 index fe25f1d..0000000 --- a/test/test_concat_embedding.py +++ /dev/null @@ -1,98 +0,0 @@ -"""Unit tests for embedding concatenation utilities.""" - -from __future__ import annotations - -from pathlib import Path - -import numpy as np -import pytest - -from utils import concat_embedding - - -def _write_npz(path: Path, embeddings: np.ndarray, ids: np.ndarray) -> None: - path.parent.mkdir(parents=True, exist_ok=True) - np.savez(path, embeddings=embeddings, ids=ids) - - -def test_concat_embeddings_matches_ids_in_first_file_order(tmp_path: Path) -> None: - path_a = tmp_path / "a.npz" - path_b = tmp_path / "b.npz" - output = tmp_path / "nested" / "out.npz" - _write_npz( - path_a, - np.array([[2.0, 0.0], [0.0, 4.0], [1.0, 1.0]]), - np.array([2, 1, 3]), - ) - _write_npz( - path_b, - np.array([[0.0, 5.0], [6.0, 0.0], [7.0, 7.0]]), - np.array([3, 2, 4]), - ) - - concat_embedding.concat_embeddings(path_a, path_b, output) - - data = np.load(output) - np.testing.assert_array_equal(data["ids"], np.array([2, 3])) - np.testing.assert_allclose( - data["embeddings"], - np.array([[2.0, 0.0, 6.0, 0.0], [1.0, 1.0, 0.0, 5.0]]), - ) - - -def test_concat_embeddings_can_normalize_before_concatenation(tmp_path: Path) -> None: - path_a = tmp_path / "a.npz" - path_b = tmp_path / "b.npz" - output = tmp_path / "out.npz" - _write_npz(path_a, np.array([[3.0, 4.0], [0.0, 0.0]]), np.array([1, 2])) - _write_npz(path_b, np.array([[0.0, 5.0], [8.0, 6.0]]), np.array([1, 2])) - - concat_embedding.concat_embeddings(path_a, path_b, output, normalize=True) - - data = np.load(output) - np.testing.assert_allclose( - data["embeddings"], - np.array([[0.6, 0.8, 0.0, 1.0], [0.0, 0.0, 0.8, 0.6]]), - ) - - -def test_concat_embeddings_rejects_duplicate_ids(tmp_path: Path) -> None: - path_a = tmp_path / "a.npz" - path_b = tmp_path / "b.npz" - _write_npz(path_a, np.ones((2, 1)), np.array([1, 1])) - _write_npz(path_b, np.ones((2, 1)), np.array([1, 2])) - - with pytest.raises(ValueError, match="duplicates"): - concat_embedding.concat_embeddings(path_a, path_b, tmp_path / "out.npz") - - -def test_concat_embeddings_rejects_no_overlap(tmp_path: Path) -> None: - path_a = tmp_path / "a.npz" - path_b = tmp_path / "b.npz" - _write_npz(path_a, np.ones((1, 1)), np.array([1])) - _write_npz(path_b, np.ones((1, 1)), np.array([2])) - - with pytest.raises(ValueError, match="No overlapping ids"): - concat_embedding.concat_embeddings(path_a, path_b, tmp_path / "out.npz") - - -def test_load_npz_validates_required_arrays_and_shapes(tmp_path: Path) -> None: - missing = tmp_path / "missing_keys.npz" - mismatch = tmp_path / "mismatch.npz" - np.savez(missing, embeddings=np.ones((2, 2))) - _write_npz(mismatch, np.ones((2, 2)), np.array([1])) - - with pytest.raises(ValueError, match="must contain"): - concat_embedding._load_npz(missing) - with pytest.raises(ValueError, match="length mismatch"): - concat_embedding._load_npz(mismatch) - - -def test_apply_pca_variance_validates_target_and_handles_degenerate_data() -> None: - with pytest.raises(ValueError, match="target_variance"): - concat_embedding._apply_pca_variance(np.ones((2, 2)), 0.0) - - projected, n_components = concat_embedding._apply_pca_variance(np.ones((3, 2)), 0.9) - - assert n_components == 1 - np.testing.assert_allclose(projected, np.zeros((3, 2))) diff --git a/test/test_generate_partial_summaries.py b/test/test_generate_partial_summaries.py deleted file mode 100644 index 5dd2801..0000000 --- a/test/test_generate_partial_summaries.py +++ /dev/null @@ -1,106 +0,0 @@ -"""Unit tests for partial summary generation.""" - -from __future__ import annotations - -import json -import sys -from pathlib import Path - -import pytest - -from utils import generate_partial_summaries as gps - - -def test_parse_selected_ids_accepts_lists_literals_and_csv_text() -> None: - assert gps._parse_selected_ids([1, 2]) == [1, 2] - assert gps._parse_selected_ids("[3, 'x']") == [3, "x"] - assert gps._parse_selected_ids("a,b,, c") == ["a", "b", " c"] - assert gps._parse_selected_ids(5) == [5] - assert gps._parse_selected_ids(None) == [] - - -def test_compute_summary_uses_cumulative_metrics() -> None: - rows = [ - { - "round": "0", - "normalized_true": "0.2", - "n_top": "0", - "selected_sample_ids": "[1, 2]", - "train_spearman": "0.1", - "extreme_value_auc": "", - }, - { - "round": "1", - "normalized_true": "0.5", - "n_top": "1", - "selected_sample_ids": "[3, 4]", - "train_spearman": "0.3", - "extreme_value_auc": "0.4", - }, - ] - - summary = gps._compute_summary(rows) - - assert summary["auc_true"] == pytest.approx(0.35) - assert summary["avg_top"] == pytest.approx(1.0 / 6.0) - assert summary["rounds_to_top"] == pytest.approx(2.0) - assert summary["overall_true"] == pytest.approx(0.5) - assert summary["max_train_spearman"] == pytest.approx(0.3) - assert summary["max_extreme_value_auc"] == pytest.approx(0.4) - - -def test_compute_summary_returns_nan_for_empty_rows() -> None: - summary = gps._compute_summary([]) - - assert set(summary) == set(gps.SUMMARY_METRIC_RULES) - assert all(value != value for value in summary.values()) - - -def test_load_rows_sorts_by_round_and_defaults_bad_rounds(tmp_path: Path) -> None: - csv_path = tmp_path / "results.csv" - csv_path.write_text( - "round,normalized_true,selected_sample_ids\n2,0.4,[3]\nbad,0.1,[1]\n1,0.3,[2]\n" - ) - - rows = gps._load_rows(csv_path) - - assert [row["_round"] for row in rows] == [0, 1, 2] - - -def test_main_writes_explicit_partial_summaries(tmp_path: Path, monkeypatch) -> None: - run_dir = tmp_path / "20-00-00" / "dataset_a" / "job_0" / "seed_0" - run_dir.mkdir(parents=True) - (run_dir / "summary.json").write_text(json.dumps({"dataset_name": "dataset_a"})) - (run_dir / "results.csv").write_text( - "round,normalized_true,n_selected_in_top,selected_sample_ids\n" - "0,0.2,0,variant_1\n" - "1,0.7,1,variant_2\n" - ) - monkeypatch.setattr( - sys, - "argv", - [ - "generate_partial_summaries.py", - str(tmp_path), - "--n", - "1,2,99", - ], - ) - - assert gps.main() == 0 - - summary_1 = json.loads((run_dir / "summary_1.json").read_text()) - summary_2 = json.loads((run_dir / "summary_2.json").read_text()) - assert summary_1["dataset_name"] == "dataset_a" - assert summary_1["overall_true"] == pytest.approx(0.2) - assert summary_2["overall_true"] == pytest.approx(0.7) - assert summary_2["rounds_to_top"] == pytest.approx(2.0) - assert not (run_dir / "summary_99.json").exists() - - -def test_main_rejects_missing_multirun_dir(tmp_path: Path, monkeypatch) -> None: - missing = tmp_path / "missing" - monkeypatch.setattr(sys, "argv", ["generate_partial_summaries.py", str(missing)]) - - with pytest.raises(SystemExit, match="Multirun dir not found"): - gps.main()