"""Tests for negbiodb_ppi.export — PPI ML dataset export pipeline.""" import sqlite3 import sys from pathlib import Path import numpy as np import pandas as pd import pyarrow.parquet as pq import pytest sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "src")) from negbiodb_ppi.export import ( _register_ppi_split, generate_random_split, generate_cold_protein_split, generate_cold_both_partition, generate_degree_balanced_split, _build_export_query, export_negative_dataset, resolve_conflicts, add_random_split, add_cold_protein_split, add_cold_both_partition_split, add_degree_balanced_split, apply_ppi_m1_splits, build_m1_balanced, build_m1_realistic, generate_uniform_random_negatives, generate_degree_matched_negatives, control_pairs_to_df, ) # ------------------------------------------------------------------ # Fixtures # ------------------------------------------------------------------ @pytest.fixture def ppi_db(tmp_path): """Create a minimal PPI database with proteins, pairs, and split tables.""" db_path = tmp_path / "test_ppi.db" conn = sqlite3.connect(str(db_path)) # Schema (minimal version of migration 001) conn.executescript(""" CREATE TABLE schema_migrations ( version TEXT PRIMARY KEY, applied_at TEXT DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')) ); CREATE TABLE proteins ( protein_id INTEGER PRIMARY KEY AUTOINCREMENT, uniprot_accession TEXT NOT NULL UNIQUE, uniprot_entry_name TEXT, gene_symbol TEXT, amino_acid_sequence TEXT, sequence_length INTEGER, organism TEXT DEFAULT 'Homo sapiens', taxonomy_id INTEGER DEFAULT 9606, subcellular_location TEXT, created_at TEXT DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')), updated_at TEXT DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')) ); CREATE TABLE ppi_negative_results ( result_id INTEGER PRIMARY KEY AUTOINCREMENT, protein1_id INTEGER NOT NULL REFERENCES proteins(protein_id), protein2_id INTEGER NOT NULL REFERENCES proteins(protein_id), experiment_id INTEGER, evidence_type TEXT NOT NULL, confidence_tier TEXT NOT NULL, interaction_score REAL, source_db TEXT NOT NULL, source_record_id TEXT NOT NULL, extraction_method TEXT NOT NULL, publication_year INTEGER, created_at TEXT DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')), updated_at TEXT DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')), CHECK (protein1_id < protein2_id) ); CREATE TABLE protein_protein_pairs ( pair_id INTEGER PRIMARY KEY AUTOINCREMENT, protein1_id INTEGER NOT NULL REFERENCES proteins(protein_id), protein2_id INTEGER NOT NULL REFERENCES proteins(protein_id), num_experiments INTEGER NOT NULL, num_sources INTEGER NOT NULL, best_confidence TEXT NOT NULL, best_evidence_type TEXT, earliest_year INTEGER, min_interaction_score REAL, max_interaction_score REAL, protein1_degree INTEGER, protein2_degree INTEGER, UNIQUE(protein1_id, protein2_id), CHECK (protein1_id < protein2_id) ); CREATE TABLE ppi_split_definitions ( split_id INTEGER PRIMARY KEY AUTOINCREMENT, split_name TEXT NOT NULL, split_strategy TEXT NOT NULL CHECK (split_strategy IN ( 'random', 'cold_protein', 'cold_both', 'bfs_cluster', 'degree_balanced')), description TEXT, random_seed INTEGER, train_ratio REAL DEFAULT 0.7, val_ratio REAL DEFAULT 0.1, test_ratio REAL DEFAULT 0.2, date_created TEXT DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')), version TEXT DEFAULT '1.0', UNIQUE(split_name, version) ); CREATE TABLE ppi_split_assignments ( pair_id INTEGER NOT NULL REFERENCES protein_protein_pairs(pair_id), split_id INTEGER NOT NULL REFERENCES ppi_split_definitions(split_id), fold TEXT NOT NULL CHECK (fold IN ('train', 'val', 'test')), PRIMARY KEY (pair_id, split_id) ); INSERT INTO schema_migrations (version) VALUES ('001'); """) # Insert 10 proteins with sequences proteins = [ ("A00001", "ACGT" * 25, "GENE_A", "Nucleus"), ("A00002", "DEFG" * 30, "GENE_B", "Cytoplasm"), ("A00003", "HIJK" * 20, "GENE_C", "Membrane"), ("A00004", "LMNO" * 35, "GENE_D", None), ("A00005", "PQRS" * 15, "GENE_E", "Nucleus"), ("A00006", "TUVW" * 40, "GENE_F", "Cytoplasm"), ("A00007", "XYZA" * 22, "GENE_G", None), ("A00008", "BCDE" * 28, "GENE_H", "Membrane"), ("A00009", "FGHI" * 18, "GENE_I", "Nucleus"), ("A00010", "JKLM" * 33, "GENE_J", "Cytoplasm"), ] conn.executemany( """INSERT INTO proteins (uniprot_accession, amino_acid_sequence, sequence_length, gene_symbol, subcellular_location) VALUES (?, ?, ?, ?, ?)""", [(acc, seq, len(seq), gene, loc) for acc, seq, gene, loc in proteins], ) # Insert negative results and pairs # Create a connected graph: 1-2, 1-3, 2-3, 3-4, 4-5, 5-6, 6-7, 7-8, 8-9, 9-10, 1-5, 2-6, 3-7, 4-8, 5-9 pair_data = [ (1, 2), (1, 3), (2, 3), (3, 4), (4, 5), (5, 6), (6, 7), (7, 8), (8, 9), (9, 10), (1, 5), (2, 6), (3, 7), (4, 8), (5, 9), ] for p1, p2 in pair_data: conn.execute( """INSERT INTO ppi_negative_results (protein1_id, protein2_id, evidence_type, confidence_tier, source_db, source_record_id, extraction_method) VALUES (?, ?, 'experimental_non_interaction', 'gold', 'huri', ?, 'database_direct')""", (p1, p2, f"huri_{p1}_{p2}"), ) # Compute degrees from negbiodb_ppi.ppi_db import refresh_all_ppi_pairs refresh_all_ppi_pairs(conn) conn.commit() conn.close() return db_path @pytest.fixture def sample_neg_df(): """Sample negative DataFrame for merge tests.""" return pd.DataFrame({ "pair_id": list(range(100)), "uniprot_id_1": [f"A{i:05d}" for i in range(1, 101)], "sequence_1": ["ACGT" * 25] * 100, "gene_symbol_1": [f"G{i}" for i in range(100)], "subcellular_location_1": ["Nucleus"] * 100, "uniprot_id_2": [f"B{i:05d}" for i in range(1, 101)], "sequence_2": ["DEFG" * 30] * 100, "gene_symbol_2": [f"G{i}" for i in range(100, 200)], "subcellular_location_2": ["Cytoplasm"] * 100, "Y": [0] * 100, "confidence_tier": ["gold"] * 100, "num_sources": [1] * 100, "protein1_degree": list(range(1, 101)), "protein2_degree": list(range(100, 0, -1)), }) @pytest.fixture def sample_pos_df(): """Sample positive DataFrame for merge tests.""" return pd.DataFrame({ "pair_id": [None] * 20, "uniprot_id_1": [f"C{i:05d}" for i in range(1, 21)], "sequence_1": ["HIJK" * 20] * 20, "gene_symbol_1": [f"PG{i}" for i in range(20)], "subcellular_location_1": ["Membrane"] * 20, "uniprot_id_2": [f"D{i:05d}" for i in range(1, 21)], "sequence_2": ["LMNO" * 35] * 20, "gene_symbol_2": [f"PG{i}" for i in range(20, 40)], "subcellular_location_2": [None] * 20, "Y": [1] * 20, "confidence_tier": [None] * 20, "num_sources": [None] * 20, "protein1_degree": [None] * 20, "protein2_degree": [None] * 20, }) # ------------------------------------------------------------------ # DB-level split tests # ------------------------------------------------------------------ class TestRegisterPpiSplit: def test_register_new(self, ppi_db): conn = sqlite3.connect(str(ppi_db)) split_id = _register_ppi_split( conn, "test_v1", "random", 42, {"train": 0.7, "val": 0.1, "test": 0.2} ) assert split_id > 0 conn.close() def test_reregister_clears(self, ppi_db): conn = sqlite3.connect(str(ppi_db)) sid1 = _register_ppi_split( conn, "test_v1", "random", 42, {"train": 0.7, "val": 0.1, "test": 0.2} ) # Insert a dummy assignment conn.execute( "INSERT INTO ppi_split_assignments (pair_id, split_id, fold) VALUES (1, ?, 'train')", (sid1,), ) conn.commit() sid2 = _register_ppi_split( conn, "test_v1", "random", 42, {"train": 0.7, "val": 0.1, "test": 0.2} ) assert sid1 == sid2 cnt = conn.execute( "SELECT COUNT(*) FROM ppi_split_assignments WHERE split_id = ?", (sid1,), ).fetchone()[0] assert cnt == 0 # cleared conn.close() class TestRandomSplit: def test_covers_all_pairs(self, ppi_db): conn = sqlite3.connect(str(ppi_db)) result = generate_random_split(conn, seed=42) total_pairs = conn.execute( "SELECT COUNT(*) FROM protein_protein_pairs" ).fetchone()[0] assert sum(result["counts"].values()) == total_pairs conn.close() def test_deterministic(self, ppi_db): conn = sqlite3.connect(str(ppi_db)) r1 = generate_random_split(conn, seed=42) r2 = generate_random_split(conn, seed=42) assert r1["counts"] == r2["counts"] conn.close() def test_approximate_ratios(self, ppi_db): conn = sqlite3.connect(str(ppi_db)) result = generate_random_split(conn, seed=42) total = sum(result["counts"].values()) # With 15 pairs, ratios won't be exact, but train should be largest assert result["counts"].get("train", 0) >= result["counts"].get("test", 0) conn.close() class TestColdProteinSplit: def test_no_leakage(self, ppi_db): """Test-group proteins must never appear in train-fold pairs.""" conn = sqlite3.connect(str(ppi_db)) result = generate_cold_protein_split(conn, seed=42) # leaked_proteins = test-group proteins in train-fold pairs (should be 0) assert result["leaked_proteins"] == 0 conn.close() def test_covers_all_pairs(self, ppi_db): conn = sqlite3.connect(str(ppi_db)) result = generate_cold_protein_split(conn, seed=42) total = conn.execute("SELECT COUNT(*) FROM protein_protein_pairs").fetchone()[0] assert sum(result["counts"].values()) == total conn.close() def test_all_folds_present(self, ppi_db): conn = sqlite3.connect(str(ppi_db)) result = generate_cold_protein_split(conn, seed=42) assert "train" in result["counts"] assert "test" in result["counts"] conn.close() class TestColdBothPartition: def test_excludes_cross_partition(self, ppi_db): conn = sqlite3.connect(str(ppi_db)) result = generate_cold_both_partition(conn, seed=42, nparts=4) total = conn.execute("SELECT COUNT(*) FROM protein_protein_pairs").fetchone()[0] assigned = sum(result["counts"].values()) assert assigned <= total assert result["excluded"] == total - assigned conn.close() def test_cold_both_integrity(self, ppi_db): """No protein should appear in both train and test.""" conn = sqlite3.connect(str(ppi_db)) result = generate_cold_both_partition(conn, seed=42, nparts=4) split_id = result["split_id"] train_proteins = set() for r in conn.execute( """SELECT protein1_id FROM protein_protein_pairs ppp JOIN ppi_split_assignments sa ON ppp.pair_id = sa.pair_id WHERE sa.split_id = ? AND sa.fold = 'train' UNION SELECT protein2_id FROM protein_protein_pairs ppp JOIN ppi_split_assignments sa ON ppp.pair_id = sa.pair_id WHERE sa.split_id = ? AND sa.fold = 'train'""", (split_id, split_id), ).fetchall(): train_proteins.add(r[0]) test_proteins = set() for r in conn.execute( """SELECT protein1_id FROM protein_protein_pairs ppp JOIN ppi_split_assignments sa ON ppp.pair_id = sa.pair_id WHERE sa.split_id = ? AND sa.fold = 'test' UNION SELECT protein2_id FROM protein_protein_pairs ppp JOIN ppi_split_assignments sa ON ppp.pair_id = sa.pair_id WHERE sa.split_id = ? AND sa.fold = 'test'""", (split_id, split_id), ).fetchall(): test_proteins.add(r[0]) assert len(train_proteins & test_proteins) == 0 conn.close() class TestDegreeBalancedSplit: def test_covers_all_pairs(self, ppi_db): conn = sqlite3.connect(str(ppi_db)) result = generate_degree_balanced_split(conn, seed=42) total = conn.execute("SELECT COUNT(*) FROM protein_protein_pairs").fetchone()[0] assert sum(result["counts"].values()) == total conn.close() def test_all_folds_present(self, ppi_db): conn = sqlite3.connect(str(ppi_db)) result = generate_degree_balanced_split(conn, seed=42) assert "train" in result["counts"] assert "test" in result["counts"] conn.close() # ------------------------------------------------------------------ # Export tests # ------------------------------------------------------------------ class TestExportNegativeDataset: def test_export_parquet(self, ppi_db, tmp_path): conn = sqlite3.connect(str(ppi_db)) generate_random_split(conn, seed=42) conn.close() output_dir = tmp_path / "exports" result = export_negative_dataset( ppi_db, output_dir, split_strategies=["random"] ) assert result["total_rows"] == 15 assert Path(result["parquet_path"]).exists() # Verify schema df = pd.read_parquet(result["parquet_path"]) assert "uniprot_id_1" in df.columns assert "sequence_1" in df.columns assert "uniprot_id_2" in df.columns assert "sequence_2" in df.columns assert "Y" in df.columns assert (df["Y"] == 0).all() assert "split_random" in df.columns def test_export_all_strategies(self, ppi_db, tmp_path): conn = sqlite3.connect(str(ppi_db)) generate_random_split(conn, seed=42) generate_cold_protein_split(conn, seed=42) generate_degree_balanced_split(conn, seed=42) conn.close() output_dir = tmp_path / "exports" result = export_negative_dataset( ppi_db, output_dir, split_strategies=["random", "cold_protein", "degree_balanced"], ) df = pd.read_parquet(result["parquet_path"]) assert "split_random" in df.columns assert "split_cold_protein" in df.columns assert "split_degree_balanced" in df.columns # ------------------------------------------------------------------ # Conflict resolution tests # ------------------------------------------------------------------ class TestConflictResolution: def test_no_conflicts(self, sample_neg_df, sample_pos_df): clean_neg, clean_pos, n = resolve_conflicts(sample_neg_df, sample_pos_df) assert n == 0 assert len(clean_neg) == 100 assert len(clean_pos) == 20 def test_conflicts_removed(self): neg = pd.DataFrame({ "uniprot_id_1": ["A", "B", "C"], "uniprot_id_2": ["X", "Y", "Z"], "Y": [0, 0, 0], }) pos = pd.DataFrame({ "uniprot_id_1": ["A", "D"], "uniprot_id_2": ["X", "W"], "Y": [1, 1], }) clean_neg, clean_pos, n = resolve_conflicts(neg, pos) assert n == 1 # (A, X) is conflict assert len(clean_neg) == 2 assert len(clean_pos) == 1 assert "A" not in clean_neg["uniprot_id_1"].values assert "A" not in clean_pos["uniprot_id_1"].values # ------------------------------------------------------------------ # DataFrame-level split tests # ------------------------------------------------------------------ class TestDataFrameSplits: def test_random_split(self, sample_neg_df): df = add_random_split(sample_neg_df, seed=42) assert "split_random" in df.columns assert set(df["split_random"].unique()) == {"train", "val", "test"} assert len(df) == 100 def test_random_split_empty(self): df = pd.DataFrame(columns=["uniprot_id_1", "uniprot_id_2"]) result = add_random_split(df, seed=42) assert "split_random" in result.columns assert len(result) == 0 def test_cold_protein_no_leakage(self, sample_neg_df): """Test-group proteins must not appear in train-fold pairs. Note: train-group proteins CAN appear in test-fold pairs (expected: when partner is test-group, pair fold = max = test). """ df = add_cold_protein_split(sample_neg_df, seed=42) assert "split_cold_protein" in df.columns train_pairs = df[df["split_cold_protein"] == "train"] test_pairs = df[df["split_cold_protein"] == "test"] # Identify test-group proteins: proteins that ONLY appear in test/val pairs # (never in train pairs as both sides) train_proteins = set(train_pairs["uniprot_id_1"]) | set(train_pairs["uniprot_id_2"]) test_only_proteins = ( (set(test_pairs["uniprot_id_1"]) | set(test_pairs["uniprot_id_2"])) - train_proteins ) # These test-only proteins should not appear in any train pair for _, row in train_pairs.iterrows(): assert row["uniprot_id_1"] not in test_only_proteins assert row["uniprot_id_2"] not in test_only_proteins def test_cold_both_excludes_cross(self, sample_neg_df): df = add_cold_both_partition_split(sample_neg_df, seed=42, nparts=4) assert "split_cold_both" in df.columns # Some rows should be None (excluded) n_assigned = df["split_cold_both"].notna().sum() assert n_assigned <= len(df) def test_degree_balanced(self, sample_neg_df): df = add_degree_balanced_split(sample_neg_df, seed=42) assert "split_degree_balanced" in df.columns assert set(df["split_degree_balanced"].unique()) == {"train", "val", "test"} def test_apply_all_splits(self, sample_neg_df): df = apply_ppi_m1_splits(sample_neg_df, seed=42) assert "split_random" in df.columns assert "split_cold_protein" in df.columns assert "split_cold_both" in df.columns assert "split_degree_balanced" in df.columns # ------------------------------------------------------------------ # M1 builder tests # ------------------------------------------------------------------ class TestM1Builders: def test_balanced_1to1(self, sample_neg_df, sample_pos_df): df = build_m1_balanced(sample_neg_df, sample_pos_df, seed=42) n_pos = (df["Y"] == 1).sum() n_neg = (df["Y"] == 0).sum() assert n_pos == 20 assert n_neg == 20 # sampled down to match assert "split_random" in df.columns def test_realistic_ratio(self, sample_neg_df, sample_pos_df): df = build_m1_realistic(sample_neg_df, sample_pos_df, ratio=3, seed=42) n_pos = (df["Y"] == 1).sum() n_neg = (df["Y"] == 0).sum() assert n_pos == 20 assert n_neg == 60 # 3:1 ratio def test_realistic_capped(self, sample_neg_df, sample_pos_df): """When not enough negatives, use all available.""" df = build_m1_realistic(sample_neg_df, sample_pos_df, ratio=100, seed=42) n_neg = (df["Y"] == 0).sum() assert n_neg == 100 # all available # ------------------------------------------------------------------ # Control negative tests # ------------------------------------------------------------------ class TestControlNegatives: def test_uniform_random(self, ppi_db): # Use empty positive set pairs = generate_uniform_random_negatives( ppi_db, positive_pairs=set(), n_samples=10, seed=42 ) assert len(pairs) == 10 # All canonical for a, b in pairs: assert a < b def test_uniform_excludes_negatives(self, ppi_db): pairs = generate_uniform_random_negatives( ppi_db, positive_pairs=set(), n_samples=5, seed=42 ) # Load existing negatives conn = sqlite3.connect(str(ppi_db)) existing = set() for r in conn.execute( """SELECT p1.uniprot_accession, p2.uniprot_accession FROM protein_protein_pairs ppp JOIN proteins p1 ON ppp.protein1_id = p1.protein_id JOIN proteins p2 ON ppp.protein2_id = p2.protein_id""" ).fetchall(): existing.add((r[0], r[1]) if r[0] < r[1] else (r[1], r[0])) conn.close() assert len(pairs & existing) == 0 def test_degree_matched(self, ppi_db): pairs = generate_degree_matched_negatives( ppi_db, positive_pairs=set(), n_samples=5, seed=42 ) assert len(pairs) == 5 def test_control_to_df(self, ppi_db): pairs = {("A00001", "A00010"), ("A00002", "A00009")} df = control_pairs_to_df(pairs, ppi_db) assert len(df) == 2 assert (df["Y"] == 0).all() assert df["sequence_1"].notna().all() assert df["sequence_2"].notna().all() # ------------------------------------------------------------------ # Parquet schema contract # ------------------------------------------------------------------ class TestSchemaContract: """Verify Parquet output matches the schema contract from the plan.""" REQUIRED_NEGATIVE_COLS = [ "pair_id", "uniprot_id_1", "sequence_1", "gene_symbol_1", "subcellular_location_1", "uniprot_id_2", "sequence_2", "gene_symbol_2", "subcellular_location_2", "Y", "confidence_tier", "num_sources", "protein1_degree", "protein2_degree", ] def test_negative_schema(self, ppi_db, tmp_path): conn = sqlite3.connect(str(ppi_db)) generate_random_split(conn, seed=42) conn.close() result = export_negative_dataset( ppi_db, tmp_path / "exports", split_strategies=["random"] ) df = pd.read_parquet(result["parquet_path"]) for col in self.REQUIRED_NEGATIVE_COLS: assert col in df.columns, f"Missing column: {col}" assert "split_random" in df.columns def test_m1_schema(self, sample_neg_df, sample_pos_df): df = build_m1_balanced(sample_neg_df, sample_pos_df, seed=42) for col in self.REQUIRED_NEGATIVE_COLS: assert col in df.columns, f"Missing column: {col}" # Y should have both 0 and 1 assert set(df["Y"].unique()) == {0, 1} # Positives should have pair_id = None pos_rows = df[df["Y"] == 1] assert pos_rows["pair_id"].isna().all()