tests/test_pipeline_scripts.py

"""Regression tests for experiment orchestration scripts."""

from __future__ import annotations

import importlib.util
import json
import os
import sys
import time
import types
from pathlib import Path

import pandas as pd
import pytest

from negbiodb.db import connect, create_database, refresh_all_pairs
from negbiodb.export import _resolve_split_id, export_negative_dataset

ROOT = Path(__file__).resolve().parent.parent
MIGRATIONS_DIR = ROOT / "migrations"


def _load_script_module(name: str, rel_path: str):
    path = ROOT / rel_path
    spec = importlib.util.spec_from_file_location(name, path)
    module = importlib.util.module_from_spec(spec)
    assert spec is not None and spec.loader is not None
    spec.loader.exec_module(module)
    return module


@pytest.fixture
def migrated_db(tmp_path):
    db_path = tmp_path / "test.db"
    create_database(db_path, MIGRATIONS_DIR)
    return db_path


def _populate_small_db(conn, n_compounds=3, n_targets=2):
    for i in range(1, n_compounds + 1):
        conn.execute(
            """INSERT INTO compounds
            (canonical_smiles, inchikey, inchikey_connectivity)
            VALUES (?, ?, ?)""",
            (f"C{i}", f"KEY{i:011d}SA-N", f"KEY{i:011d}"),
        )
    for j in range(1, n_targets + 1):
        conn.execute(
            "INSERT INTO targets (uniprot_accession, amino_acid_sequence) VALUES (?, ?)",
            (f"P{j:05d}", f"SEQ{j}"),
        )
    for i in range(1, n_compounds + 1):
        for j in range(1, n_targets + 1):
            conn.execute(
                """INSERT INTO negative_results
                (compound_id, target_id, result_type, confidence_tier,
                 activity_type, activity_value, activity_unit,
                 inactivity_threshold, source_db, source_record_id,
                 extraction_method, publication_year)
                VALUES (?, ?, 'hard_negative', 'silver',
                        'IC50', 20000.0, 'nM',
                        10000.0, 'chembl', ?, 'database_direct', ?)""",
                (i, j, f"C:{i}:{j}", 2015 + i),
            )
    refresh_all_pairs(conn)
    conn.commit()


class TestExportVersioning:
    def test_export_uses_latest_split_without_row_duplication(self, migrated_db, tmp_path):
        with connect(migrated_db) as conn:
            _populate_small_db(conn)
            pair_ids = [row[0] for row in conn.execute(
                "SELECT pair_id FROM compound_target_pairs ORDER BY pair_id"
            )]
            conn.execute(
                """INSERT INTO split_definitions
                (split_name, split_strategy, random_seed, train_ratio, val_ratio, test_ratio)
                VALUES ('random_v1', 'random', 1, 0.7, 0.1, 0.2)"""
            )
            old_id = conn.execute(
                "SELECT split_id FROM split_definitions WHERE split_name = 'random_v1'"
            ).fetchone()[0]
            conn.executemany(
                "INSERT INTO split_assignments (pair_id, split_id, fold) VALUES (?, ?, 'train')",
                [(pair_id, old_id) for pair_id in pair_ids],
            )

            conn.execute(
                """INSERT INTO split_definitions
                (split_name, split_strategy, random_seed, train_ratio, val_ratio, test_ratio)
                VALUES ('random_v2', 'random', 2, 0.7, 0.1, 0.2)"""
            )
            new_id = conn.execute(
                "SELECT split_id FROM split_definitions WHERE split_name = 'random_v2'"
            ).fetchone()[0]
            conn.executemany(
                "INSERT INTO split_assignments (pair_id, split_id, fold) VALUES (?, ?, 'val')",
                [(pair_id, new_id) for pair_id in pair_ids],
            )
            conn.commit()

        result = export_negative_dataset(migrated_db, tmp_path / "exports", split_strategies=["random"])
        df = pd.read_parquet(result["parquet_path"])

        assert len(df) == len(pair_ids)
        assert set(df["split_random"]) == {"val"}

    def test_split_resolution_prefers_version_suffix_over_insert_order(self, migrated_db):
        with connect(migrated_db) as conn:
            conn.execute(
                """INSERT INTO split_definitions
                (split_name, split_strategy, version, random_seed, train_ratio, val_ratio, test_ratio)
                VALUES ('random_v2', 'random', '2.0', 2, 0.7, 0.1, 0.2)"""
            )
            newer_semantic_id = conn.execute(
                "SELECT split_id FROM split_definitions WHERE split_name = 'random_v2'"
            ).fetchone()[0]
            conn.execute(
                """INSERT INTO split_definitions
                (split_name, split_strategy, version, random_seed, train_ratio, val_ratio, test_ratio)
                VALUES ('random_backfill', 'random', '1.0', 1, 0.7, 0.1, 0.2)"""
            )
            conn.commit()

            assert _resolve_split_id(conn, "random") == newer_semantic_id


class TestPrepareExpData:
    def test_skip_exp4_does_not_require_pairs_parquet(self, tmp_path):
        module = _load_script_module("prepare_exp_data_test", "scripts/prepare_exp_data.py")

        data_dir = tmp_path / "exports"
        data_dir.mkdir()
        db_path = tmp_path / "negbiodb.db"
        db_path.write_text("")
        pd.DataFrame({"smiles": ["CC"], "inchikey": ["A" * 27], "uniprot_id": ["P00001"], "target_sequence": ["SEQ"], "Y": [1], "split_random": ["train"]}).to_parquet(data_dir / "negbiodb_m1_balanced.parquet")
        pd.DataFrame({"smiles": ["CC"], "inchikey": ["A" * 27], "uniprot_id": ["P00001"], "target_sequence": ["SEQ"]}).to_parquet(data_dir / "chembl_positives_pchembl6.parquet")

        rc = module.main([
            "--data-dir", str(data_dir),
            "--db", str(db_path),
            "--skip-exp1",
            "--skip-exp4",
        ])

        assert rc == 0

    def test_exp4_only_does_not_require_db_or_positives_and_builds_full_task_ddb(self, tmp_path):
        module = _load_script_module("prepare_exp_data_test_exp4_only", "scripts/prepare_exp_data.py")

        data_dir = tmp_path / "exports"
        data_dir.mkdir()
        rows = []
        for i in range(10):
            rows.append({
                "smiles": f"P{i}",
                "inchikey": f"POS{i:011d}ABCDEFGHIJKLM",
                "uniprot_id": "P00001",
                "target_sequence": "SEQ",
                "Y": 1,
                "split_random": "train",
                "split_cold_compound": "train",
                "split_cold_target": "train",
            })
        for i in range(10):
            rows.append({
                "smiles": f"N{i}",
                "inchikey": f"NEG{i:011d}ABCDEFGHIJKLM",
                "uniprot_id": "P00002" if i < 5 else "P00003",
                "target_sequence": "SEQ",
                "Y": 0,
                "split_random": "test",
                "split_cold_compound": "test",
                "split_cold_target": "test",
            })
        pd.DataFrame(rows).to_parquet(data_dir / "negbiodb_m1_balanced.parquet")

        rc = module.main([
            "--data-dir", str(data_dir),
            "--db", str(tmp_path / "missing.db"),
            "--skip-exp1",
        ])

        assert rc == 0
        ddb = pd.read_parquet(data_dir / "negbiodb_m1_balanced_ddb.parquet")
        pos = ddb[ddb["Y"] == 1]
        assert "split_degree_balanced" in ddb.columns
        assert set(pos["split_degree_balanced"]) != {"train"}


class TestTrainBaselineHelpers:
    def test_build_run_name_includes_dataset_and_seed(self):
        module = _load_script_module("train_baseline_test_names", "scripts/train_baseline.py")
        run_name = module._build_run_name("deepdta", "balanced", "random", "negbiodb", 7)
        assert run_name == "deepdta_balanced_random_negbiodb_seed7"

    def test_resolve_dataset_file_rejects_invalid_ddb_combo(self):
        module = _load_script_module("train_baseline_test_resolve", "scripts/train_baseline.py")
        assert module._resolve_dataset_file("balanced", "ddb", "uniform_random") is None
        assert module._resolve_dataset_file("balanced", "ddb", "negbiodb") == "negbiodb_m1_balanced_ddb.parquet"
        assert module._resolve_dataset_file("realistic", "random", "uniform_random") is None
        assert module._resolve_dataset_file("realistic", "random", "degree_matched") is None

    def test_prepare_graph_cache_backfills_missing_smiles(self, tmp_path):
        torch = pytest.importorskip("torch")
        module = _load_script_module("train_baseline_test_cache", "scripts/train_baseline.py")

        parquet_path = tmp_path / "m1.parquet"
        pd.DataFrame({"smiles": ["CC", "CCC"]}).to_parquet(parquet_path)
        cache_path = tmp_path / "graph_cache.pt"
        torch.save({"CC": {"graph": "cached"}}, cache_path)

        fake_graph_module = types.SimpleNamespace(
            smiles_to_graph=lambda smiles: {"graph": smiles}
        )
        original = sys.modules.get("negbiodb.models.graphdta")
        sys.modules["negbiodb.models.graphdta"] = fake_graph_module
        try:
            cache = module._prepare_graph_cache(parquet_path, cache_path)
        finally:
            if original is None:
                del sys.modules["negbiodb.models.graphdta"]
            else:
                sys.modules["negbiodb.models.graphdta"] = original

        assert set(cache) == {"CC", "CCC"}
        saved = torch.load(cache_path, weights_only=False)
        assert set(saved) == {"CC", "CCC"}

    def test_main_rejects_realistic_ddb(self, tmp_path):
        module = _load_script_module("train_baseline_test_ddb", "scripts/train_baseline.py")
        rc = module.main([
            "--model", "deepdta",
            "--split", "ddb",
            "--negative", "negbiodb",
            "--dataset", "realistic",
            "--data_dir", str(tmp_path),
            "--output_dir", str(tmp_path / "results"),
        ])
        assert rc == 1

    def test_main_rejects_realistic_uniform_random(self, tmp_path):
        module = _load_script_module("train_baseline_test_realistic_control", "scripts/train_baseline.py")
        rc = module.main([
            "--model", "deepdta",
            "--split", "random",
            "--negative", "uniform_random",
            "--dataset", "realistic",
            "--data_dir", str(tmp_path),
            "--output_dir", str(tmp_path / "results"),
        ])
        assert rc == 1

    def test_main_writes_results_with_dataset_and_seed_in_run_name(self, tmp_path, monkeypatch):
        module = _load_script_module("train_baseline_test_main", "scripts/train_baseline.py")

        data_dir = tmp_path / "exports"
        output_dir = tmp_path / "results"
        data_dir.mkdir()
        pd.DataFrame({
            "smiles": ["CC", "CCC", "CCCC"],
            "target_sequence": ["SEQ", "SEQ", "SEQ"],
            "Y": [1, 0, 0],
            "split_random": ["train", "val", "test"],
        }).to_parquet(data_dir / "negbiodb_m1_balanced.parquet")

        fake_torch = types.SimpleNamespace(
            device=lambda name: name,
            cuda=types.SimpleNamespace(is_available=lambda: False),
            backends=types.SimpleNamespace(mps=types.SimpleNamespace(is_available=lambda: False)),
        )
        original_torch = sys.modules.get("torch")
        sys.modules["torch"] = fake_torch

        class DummyDataset:
            def __init__(self, parquet_path, split_col, fold, model, graph_cache):
                self.fold = fold
                self.items = {"train": [1], "val": [1], "test": [1]}[fold]

            def __len__(self):
                return len(self.items)

        class DummyModel:
            def to(self, device):
                return self

            def parameters(self):
                return []

        monkeypatch.setattr(module, "set_seed", lambda seed: None)
        monkeypatch.setattr(module, "DTIDataset", DummyDataset)
        monkeypatch.setattr(module, "make_dataloader", lambda dataset, batch_size, shuffle, device: [dataset.fold])
        monkeypatch.setattr(module, "build_model", lambda model_type: DummyModel())

        def fake_train(model, train_loader, val_loader, epochs, patience, lr, output_dir, device):
            (output_dir / "best.pt").write_text("checkpoint")
            (output_dir / "training_log.csv").write_text("epoch\n1\n")
            return 0.123

        monkeypatch.setattr(module, "train", fake_train)
        monkeypatch.setattr(module, "evaluate", lambda model, test_loader, checkpoint_path, device: {"log_auc": 0.5})

        try:
            rc = module.main([
                "--model", "deepdta",
                "--split", "random",
                "--negative", "negbiodb",
                "--dataset", "balanced",
                "--seed", "9",
                "--data_dir", str(data_dir),
                "--output_dir", str(output_dir),
            ])
        finally:
            if original_torch is None:
                del sys.modules["torch"]
            else:
                sys.modules["torch"] = original_torch

        assert rc == 0
        run_dir = output_dir / "deepdta_balanced_random_negbiodb_seed9"
        results = json.loads((run_dir / "results.json").read_text())
        assert results["run_name"] == "deepdta_balanced_random_negbiodb_seed9"
        assert results["dataset"] == "balanced"
        assert results["seed"] == 9
        assert (run_dir / "best.pt").exists()

    def test_main_writes_strict_json_with_null_for_nan(self, tmp_path, monkeypatch):
        module = _load_script_module("train_baseline_test_nan_json", "scripts/train_baseline.py")

        data_dir = tmp_path / "exports"
        output_dir = tmp_path / "results"
        data_dir.mkdir()
        pd.DataFrame({
            "smiles": ["CC", "CCC", "CCCC"],
            "target_sequence": ["SEQ", "SEQ", "SEQ"],
            "Y": [1, 0, 0],
            "split_random": ["train", "val", "test"],
        }).to_parquet(data_dir / "negbiodb_m1_balanced.parquet")

        fake_torch = types.SimpleNamespace(
            device=lambda name: name,
            cuda=types.SimpleNamespace(is_available=lambda: False),
            backends=types.SimpleNamespace(mps=types.SimpleNamespace(is_available=lambda: False)),
        )
        original_torch = sys.modules.get("torch")
        sys.modules["torch"] = fake_torch

        class DummyDataset:
            def __init__(self, parquet_path, split_col, fold, model, graph_cache):
                self.fold = fold
                self.items = {"train": [1], "val": [1], "test": [1]}[fold]

            def __len__(self):
                return len(self.items)

        class DummyModel:
            def to(self, device):
                return self

            def parameters(self):
                return []

        monkeypatch.setattr(module, "set_seed", lambda seed: None)
        monkeypatch.setattr(module, "DTIDataset", DummyDataset)
        monkeypatch.setattr(module, "make_dataloader", lambda dataset, batch_size, shuffle, device: [dataset.fold])
        monkeypatch.setattr(module, "build_model", lambda model_type: DummyModel())

        def fake_train(model, train_loader, val_loader, epochs, patience, lr, output_dir, device):
            (output_dir / "best.pt").write_text("checkpoint")
            (output_dir / "training_log.csv").write_text("epoch\n1\n")
            return float("nan")

        monkeypatch.setattr(module, "train", fake_train)
        monkeypatch.setattr(module, "evaluate", lambda model, test_loader, checkpoint_path, device: {"log_auc": float("nan")})

        try:
            rc = module.main([
                "--model", "deepdta",
                "--split", "random",
                "--negative", "negbiodb",
                "--dataset", "balanced",
                "--data_dir", str(data_dir),
                "--output_dir", str(output_dir),
            ])
        finally:
            if original_torch is None:
                del sys.modules["torch"]
            else:
                sys.modules["torch"] = original_torch

        assert rc == 0
        result_text = (output_dir / "deepdta_balanced_random_negbiodb_seed42" / "results.json").read_text()
        assert "\"best_val_log_auc\": null" in result_text
        assert "\"log_auc\": null" in result_text
        assert "NaN" not in result_text


class TestEvalCheckpoint:
    def test_eval_checkpoint_uses_ddb_dataset_and_current_run_name(self, tmp_path, monkeypatch):
        module = _load_script_module("eval_checkpoint_test_main", "scripts/eval_checkpoint.py")

        data_dir = tmp_path / "exports"
        output_dir = tmp_path / "results"
        data_dir.mkdir()
        pd.DataFrame({
            "smiles": ["CC", "CCC", "CCCC"],
            "target_sequence": ["SEQ", "SEQ", "SEQ"],
            "Y": [1, 0, 0],
            "split_degree_balanced": ["train", "val", "test"],
        }).to_parquet(data_dir / "negbiodb_m1_balanced_ddb.parquet")

        run_dir = output_dir / "deepdta_balanced_ddb_negbiodb_seed9"
        run_dir.mkdir(parents=True)
        (run_dir / "best.pt").write_text("checkpoint")
        (run_dir / "training_log.csv").write_text("epoch,val_log_auc\n1,0.7\n")

        fake_torch = types.SimpleNamespace(
            device=lambda name: name,
            cuda=types.SimpleNamespace(is_available=lambda: False),
            backends=types.SimpleNamespace(mps=types.SimpleNamespace(is_available=lambda: False)),
        )
        original_torch = sys.modules.get("torch")
        sys.modules["torch"] = fake_torch

        seen: dict[str, object] = {}

        class DummyDataset:
            def __init__(self, parquet_path, split_col, fold, model, graph_cache):
                seen["parquet_name"] = parquet_path.name
                seen["split_col"] = split_col
                self.fold = fold
                self.items = {"train": [1], "val": [1], "test": [1]}[fold]

            def __len__(self):
                return len(self.items)

        class DummyModel:
            def to(self, device):
                seen["device"] = device
                return self

        monkeypatch.setattr(module.baseline, "DTIDataset", DummyDataset)
        monkeypatch.setattr(module.baseline, "make_dataloader", lambda dataset, batch_size, shuffle, device: [dataset.fold])
        monkeypatch.setattr(module.baseline, "build_model", lambda model_type: DummyModel())

        def fake_evaluate(model, test_loader, checkpoint_path, device):
            seen["checkpoint"] = checkpoint_path
            return {"log_auc": 0.5}

        monkeypatch.setattr(module.baseline, "evaluate", fake_evaluate)

        try:
            rc = module.main([
                "--model", "deepdta",
                "--split", "ddb",
                "--negative", "negbiodb",
                "--dataset", "balanced",
                "--seed", "9",
                "--data_dir", str(data_dir),
                "--output_dir", str(output_dir),
            ])
        finally:
            if original_torch is None:
                del sys.modules["torch"]
            else:
                sys.modules["torch"] = original_torch

        assert rc == 0
        assert seen["parquet_name"] == "negbiodb_m1_balanced_ddb.parquet"
        assert seen["split_col"] == "split_degree_balanced"
        assert seen["checkpoint"] == run_dir / "best.pt"
        results = json.loads((run_dir / "results.json").read_text())
        assert results["run_name"] == "deepdta_balanced_ddb_negbiodb_seed9"
        assert results["best_val_log_auc"] == pytest.approx(0.7)

    def test_eval_checkpoint_rejects_realistic_ddb(self, tmp_path):
        module = _load_script_module("eval_checkpoint_test_ddb", "scripts/eval_checkpoint.py")
        rc = module.main([
            "--model", "deepdta",
            "--split", "ddb",
            "--negative", "negbiodb",
            "--dataset", "realistic",
            "--data_dir", str(tmp_path),
            "--output_dir", str(tmp_path / "results"),
        ])
        assert rc == 1

    def test_eval_checkpoint_falls_back_to_legacy_run_directory(self, tmp_path, monkeypatch):
        module = _load_script_module("eval_checkpoint_test_legacy", "scripts/eval_checkpoint.py")

        data_dir = tmp_path / "exports"
        output_dir = tmp_path / "results"
        data_dir.mkdir()
        pd.DataFrame({
            "smiles": ["CC", "CCC", "CCCC"],
            "target_sequence": ["SEQ", "SEQ", "SEQ"],
            "Y": [1, 0, 0],
            "split_random": ["train", "val", "test"],
        }).to_parquet(data_dir / "negbiodb_m1_balanced.parquet")

        run_dir = output_dir / "deepdta_random_negbiodb"
        run_dir.mkdir(parents=True)
        (run_dir / "best.pt").write_text("checkpoint")
        (run_dir / "training_log.csv").write_text("epoch,val_log_auc\n1,0.8\n")

        fake_torch = types.SimpleNamespace(
            device=lambda name: name,
            cuda=types.SimpleNamespace(is_available=lambda: False),
            backends=types.SimpleNamespace(mps=types.SimpleNamespace(is_available=lambda: False)),
        )
        original_torch = sys.modules.get("torch")
        sys.modules["torch"] = fake_torch

        class DummyDataset:
            def __init__(self, parquet_path, split_col, fold, model, graph_cache):
                self.fold = fold
                self.items = {"train": [1], "val": [1], "test": [1]}[fold]

            def __len__(self):
                return len(self.items)

        class DummyModel:
            def to(self, device):
                return self

        monkeypatch.setattr(module.baseline, "DTIDataset", DummyDataset)
        monkeypatch.setattr(module.baseline, "make_dataloader", lambda dataset, batch_size, shuffle, device: [dataset.fold])
        monkeypatch.setattr(module.baseline, "build_model", lambda model_type: DummyModel())
        monkeypatch.setattr(module.baseline, "evaluate", lambda model, test_loader, checkpoint_path, device: {"log_auc": 0.5})

        try:
            rc = module.main([
                "--model", "deepdta",
                "--split", "random",
                "--negative", "negbiodb",
                "--dataset", "balanced",
                "--seed", "42",
                "--data_dir", str(data_dir),
                "--output_dir", str(output_dir),
            ])
        finally:
            if original_torch is None:
                del sys.modules["torch"]
            else:
                sys.modules["torch"] = original_torch

        assert rc == 0
        results = json.loads((run_dir / "results.json").read_text())
        assert results["run_name"] == "deepdta_random_negbiodb"
        assert results["best_val_log_auc"] == pytest.approx(0.8)


class TestCollectResults:
    def test_load_results_prefers_canonical_run_name_for_duplicate_settings(self, tmp_path):
        module = _load_script_module("collect_results_test_dedup", "scripts/collect_results.py")
        results_base = tmp_path / "results" / "baselines"

        legacy_dir = results_base / "deepdta_random_negbiodb"
        legacy_dir.mkdir(parents=True)
        (legacy_dir / "results.json").write_text(json.dumps({
            "run_name": "deepdta_random_negbiodb",
            "model": "deepdta",
            "split": "random",
            "negative": "negbiodb",
            "dataset": "balanced",
            "seed": 42,
            "n_train": 1,
            "n_val": 1,
            "n_test": 1,
            "best_val_log_auc": 0.1,
            "test_metrics": {"log_auc": 0.1},
        }))

        canonical_dir = results_base / "deepdta_balanced_random_negbiodb_seed42"
        canonical_dir.mkdir(parents=True)
        (canonical_dir / "results.json").write_text(json.dumps({
            "run_name": "deepdta_balanced_random_negbiodb_seed42",
            "model": "deepdta",
            "split": "random",
            "negative": "negbiodb",
            "dataset": "balanced",
            "seed": 42,
            "n_train": 1,
            "n_val": 1,
            "n_test": 1,
            "best_val_log_auc": 0.9,
            "test_metrics": {"log_auc": 0.9},
        }))

        loaded = module.load_results(results_base)
        assert len(loaded) == 1
        assert loaded.iloc[0]["log_auc"] == pytest.approx(0.9)

    def test_load_results_drops_stale_ddb_runs_by_checkpoint_mtime(self, tmp_path):
        module = _load_script_module("collect_results_test_stale_ddb", "scripts/collect_results.py")
        results_base = tmp_path / "results" / "baselines"
        ddb_reference = tmp_path / "exports" / "negbiodb_m1_balanced_ddb.parquet"
        ddb_reference.parent.mkdir(parents=True)
        ddb_reference.write_text("ddb")

        base_time = time.time() - 1000
        os.utime(ddb_reference, (base_time + 100, base_time + 100))

        stale_dir = results_base / "deepdta_balanced_ddb_negbiodb_seed42"
        stale_dir.mkdir(parents=True)
        stale_json = stale_dir / "results.json"
        stale_json.write_text(json.dumps({
            "run_name": "deepdta_balanced_ddb_negbiodb_seed42",
            "model": "deepdta",
            "split": "ddb",
            "negative": "negbiodb",
            "dataset": "balanced",
            "seed": 42,
            "n_train": 1,
            "n_val": 1,
            "n_test": 1,
            "best_val_log_auc": 0.1,
            "test_metrics": {"log_auc": 0.1},
        }))
        stale_best = stale_dir / "best.pt"
        stale_best.write_text("checkpoint")
        os.utime(stale_best, (base_time, base_time))
        os.utime(stale_json, (base_time + 200, base_time + 200))

        fresh_dir = results_base / "deepdta_balanced_ddb_negbiodb_seed43"
        fresh_dir.mkdir(parents=True)
        fresh_json = fresh_dir / "results.json"
        fresh_json.write_text(json.dumps({
            "run_name": "deepdta_balanced_ddb_negbiodb_seed43",
            "model": "deepdta",
            "split": "ddb",
            "negative": "negbiodb",
            "dataset": "balanced",
            "seed": 43,
            "n_train": 1,
            "n_val": 1,
            "n_test": 1,
            "best_val_log_auc": 0.9,
            "test_metrics": {"log_auc": 0.9},
        }))
        fresh_best = fresh_dir / "best.pt"
        fresh_best.write_text("checkpoint")
        os.utime(fresh_best, (base_time + 200, base_time + 200))

        loaded = module.load_results(results_base, ddb_reference=ddb_reference)
        assert len(loaded) == 1
        assert int(loaded.iloc[0]["seed"]) == 43
        assert loaded.iloc[0]["log_auc"] == pytest.approx(0.9)

    def test_filter_results_by_dataset_and_seed(self):
        module = _load_script_module("collect_results_test_filter", "scripts/collect_results.py")
        df = pd.DataFrame([
            {"model": "deepdta", "dataset": "balanced", "seed": 1, "split": "random", "negative": "negbiodb"},
            {"model": "deepdta", "dataset": "balanced", "seed": 2, "split": "random", "negative": "negbiodb"},
            {"model": "deepdta", "dataset": "realistic", "seed": 1, "split": "random", "negative": "negbiodb"},
        ])

        filtered = module.filter_results(df, dataset="balanced", seeds=[2])
        assert len(filtered) == 1
        assert filtered.iloc[0]["dataset"] == "balanced"
        assert int(filtered.iloc[0]["seed"]) == 2

    def test_filter_results_by_all_axes(self):
        module = _load_script_module("collect_results_test_filter_axes", "scripts/collect_results.py")
        df = pd.DataFrame([
            {"model": "deepdta", "dataset": "balanced", "seed": 1, "split": "random", "negative": "negbiodb"},
            {"model": "graphdta", "dataset": "balanced", "seed": 1, "split": "random", "negative": "negbiodb"},
            {"model": "deepdta", "dataset": "balanced", "seed": 1, "split": "cold_target", "negative": "negbiodb"},
            {"model": "deepdta", "dataset": "balanced", "seed": 1, "split": "random", "negative": "uniform_random"},
        ])

        filtered = module.filter_results(
            df,
            dataset="balanced",
            seeds=[1],
            models=["deepdta"],
            splits=["random"],
            negatives=["negbiodb"],
        )
        assert len(filtered) == 1
        row = filtered.iloc[0]
        assert row["model"] == "deepdta"
        assert row["split"] == "random"
        assert row["negative"] == "negbiodb"

    def test_build_table1_preserves_dataset_and_seed(self):
        module = _load_script_module("collect_results_test_table", "scripts/collect_results.py")
        df = pd.DataFrame([
            {
                "model": "deepdta",
                "split": "random",
                "negative": "negbiodb",
                "dataset": "balanced",
                "seed": 42,
                "n_test": 10,
                "log_auc": 0.5,
                "auprc": 0.4,
                "bedroc": 0.3,
                "ef_1pct": 1.0,
                "ef_5pct": 2.0,
                "mcc": 0.1,
                "auroc": 0.6,
            }
        ])

        table = module.build_table1(df)
        assert list(table.columns[:5]) == ["model", "dataset", "seed", "split", "negative"]

    def test_aggregate_over_seeds_computes_mean_std_and_counts(self):
        module = _load_script_module("collect_results_test_aggregate", "scripts/collect_results.py")
        df = pd.DataFrame([
            {
                "model": "deepdta", "dataset": "balanced", "seed": 1, "split": "random", "negative": "negbiodb",
                "n_test": 10, "log_auc": 0.4, "auprc": 0.3, "bedroc": 0.2, "ef_1pct": 1.0, "ef_5pct": 2.0, "mcc": 0.1, "auroc": 0.6,
            },
            {
                "model": "deepdta", "dataset": "balanced", "seed": 2, "split": "random", "negative": "negbiodb",
                "n_test": 12, "log_auc": 0.6, "auprc": 0.5, "bedroc": 0.4, "ef_1pct": 3.0, "ef_5pct": 4.0, "mcc": 0.3, "auroc": 0.8,
            },
        ])

        agg = module.aggregate_over_seeds(df)
        assert len(agg) == 1
        row = agg.iloc[0]
        assert int(row["n_seeds"]) == 2
        assert row["log_auc_mean"] == pytest.approx(0.5)
        assert row["n_test_mean"] == pytest.approx(11.0)
        assert "log_auc_std" in agg.columns

    def test_format_aggregated_markdown_includes_mean_std(self):
        module = _load_script_module("collect_results_test_agg_md", "scripts/collect_results.py")
        agg = pd.DataFrame([
            {
                "model": "deepdta",
                "dataset": "balanced",
                "split": "random",
                "negative": "negbiodb",
                "n_seeds": 2,
                "log_auc_mean": 0.5,
                "log_auc_std": 0.1,
                "auprc_mean": 0.4,
                "auprc_std": 0.05,
                "bedroc_mean": 0.3,
                "bedroc_std": 0.02,
                "ef_1pct_mean": 1.0,
                "ef_1pct_std": 0.1,
                "ef_5pct_mean": 2.0,
                "ef_5pct_std": 0.2,
                "mcc_mean": 0.1,
                "mcc_std": 0.01,
                "auroc_mean": 0.6,
                "auroc_std": 0.03,
            }
        ])

        md = module.format_aggregated_markdown(agg)
        assert "0.500 +/- 0.100" in md
        assert "| **Seeds** |" in md

    def test_summarize_exp1_groups_by_dataset(self):
        module = _load_script_module("collect_results_test_summary", "scripts/collect_results.py")
        df = pd.DataFrame([
            {"model": "deepdta", "dataset": "balanced", "negative": "negbiodb", "seed": 1, "log_auc": 0.50},
            {"model": "deepdta", "dataset": "balanced", "negative": "uniform_random", "seed": 1, "log_auc": 0.60},
            {"model": "deepdta", "dataset": "balanced", "negative": "degree_matched", "seed": 1, "log_auc": 0.55},
            {"model": "deepdta", "dataset": "realistic", "negative": "negbiodb", "seed": 2, "log_auc": 0.40},
            {"model": "deepdta", "dataset": "realistic", "negative": "uniform_random", "seed": 2, "log_auc": 0.44},
            {"model": "deepdta", "dataset": "realistic", "negative": "degree_matched", "seed": 2, "log_auc": 0.42},
        ])

        summary = module.summarize_exp1(df)
        assert "Dataset=balanced" in summary
        assert "Dataset=realistic" in summary

    def test_summarize_exp1_uses_only_matched_seeds(self):
        module = _load_script_module("collect_results_test_matched_seeds", "scripts/collect_results.py")
        df = pd.DataFrame([
            {"model": "deepdta", "dataset": "balanced", "negative": "negbiodb", "seed": 1, "log_auc": 0.50},
            {"model": "deepdta", "dataset": "balanced", "negative": "uniform_random", "seed": 1, "log_auc": 0.60},
            {"model": "deepdta", "dataset": "balanced", "negative": "degree_matched", "seed": 1, "log_auc": 0.55},
            {"model": "deepdta", "dataset": "balanced", "negative": "negbiodb", "seed": 2, "log_auc": 0.10},
            {"model": "deepdta", "dataset": "balanced", "negative": "uniform_random", "seed": 3, "log_auc": 0.90},
            {"model": "deepdta", "dataset": "balanced", "negative": "degree_matched", "seed": 4, "log_auc": 0.95},
        ])

        summary = module.summarize_exp1(df)
        assert "[n=1]" in summary
        assert "NegBioDB=0.500" in summary

    def test_summarize_exp1_aggregated_uses_only_matched_seeds(self):
        module = _load_script_module("collect_results_test_agg_matched_seeds", "scripts/collect_results.py")
        df = pd.DataFrame([
            {"model": "deepdta", "dataset": "balanced", "negative": "negbiodb", "seed": 1, "log_auc": 0.50},
            {"model": "deepdta", "dataset": "balanced", "negative": "uniform_random", "seed": 1, "log_auc": 0.60},
            {"model": "deepdta", "dataset": "balanced", "negative": "degree_matched", "seed": 1, "log_auc": 0.55},
            {"model": "deepdta", "dataset": "balanced", "negative": "negbiodb", "seed": 2, "log_auc": 0.10},
            {"model": "deepdta", "dataset": "balanced", "negative": "uniform_random", "seed": 3, "log_auc": 0.90},
            {"model": "deepdta", "dataset": "balanced", "negative": "degree_matched", "seed": 4, "log_auc": 0.95},
        ])

        summary = module.summarize_exp1_aggregated(df)
        assert "[n=1]" in summary
        assert "NegBioDB=0.500" in summary
        assert "uniform_random=0.600" in summary
        assert "0.900" not in summary

    def test_main_returns_error_when_filters_remove_all_rows(self, tmp_path):
        module = _load_script_module("collect_results_test_main_filter", "scripts/collect_results.py")
        results_dir = tmp_path / "results" / "baselines" / "run1"
        results_dir.mkdir(parents=True)
        (results_dir / "results.json").write_text(json.dumps({
            "model": "deepdta",
            "split": "random",
            "negative": "negbiodb",
            "dataset": "balanced",
            "seed": 1,
            "n_train": 1,
            "n_val": 1,
            "n_test": 1,
            "best_val_log_auc": 0.1,
            "test_metrics": {"log_auc": 0.2},
        }))

        rc = module.main([
            "--results-dir", str(tmp_path / "results" / "baselines"),
            "--out", str(tmp_path / "out"),
            "--dataset", "realistic",
        ])
        assert rc == 1

    def test_main_writes_aggregated_csv(self, tmp_path):
        module = _load_script_module("collect_results_test_main_agg", "scripts/collect_results.py")
        results_base = tmp_path / "results" / "baselines"
        for seed, log_auc in [(1, 0.2), (2, 0.4)]:
            run_dir = results_base / f"run_{seed}"
            run_dir.mkdir(parents=True, exist_ok=True)
            (run_dir / "results.json").write_text(json.dumps({
                "model": "deepdta",
                "split": "random",
                "negative": "negbiodb",
                "dataset": "balanced",
                "seed": seed,
                "n_train": 1,
                "n_val": 1,
                "n_test": 1,
                "best_val_log_auc": 0.1,
                "test_metrics": {
                    "log_auc": log_auc,
                    "auprc": 0.1,
                    "bedroc": 0.1,
                    "ef_1pct": 1.0,
                    "ef_5pct": 1.0,
                    "mcc": 0.1,
                    "auroc": 0.1,
                },
            }))

        out_dir = tmp_path / "out"
        rc = module.main([
            "--results-dir", str(results_base),
            "--out", str(out_dir),
            "--aggregate-seeds",
        ])
        assert rc == 0
        assert (out_dir / "table1_aggregated.csv").exists()
        assert (out_dir / "table1_aggregated.md").exists()