Datasets:

jang1563
/

NegBioDB

	"""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()