napistu 0.4.1__py3-none-any.whl → 0.4.3__py3-none-any.whl

tests/test_statistics_quantiles.py

@@ -0,0 +1,133 @@
+import pytest
+import numpy as np
+import pandas as pd
+from napistu.statistics import quantiles
+
+
+def test_calculate_quantiles_valid_inputs():
+    """Test calculate_quantiles with valid, well-formed inputs."""
+    # Create observed data: 4 features x 3 attributes
+    observed = pd.DataFrame(
+        [[0.8, 0.3, 0.9], [0.2, 0.7, 0.1], [0.5, 0.5, 0.5], [0.1, 0.9, 0.2]],
+        index=["gene1", "gene2", "gene3", "gene4"],
+        columns=["attr1", "attr2", "attr3"],
+    )
+
+    # Create null data: 2 samples per feature (8 rows total)
+    null_index = ["gene1", "gene2", "gene3", "gene4"] * 2
+    null_data = pd.DataFrame(
+        [
+            [0.1, 0.2, 0.3],  # gene1 sample 1
+            [0.4, 0.5, 0.6],  # gene2 sample 1
+            [0.7, 0.8, 0.9],  # gene3 sample 1
+            [0.0, 0.1, 0.2],  # gene4 sample 1
+            [0.2, 0.3, 0.4],  # gene1 sample 2
+            [0.5, 0.6, 0.7],  # gene2 sample 2
+            [0.8, 0.9, 1.0],  # gene3 sample 2
+            [0.1, 0.2, 0.3],  # gene4 sample 2
+        ],
+        index=null_index,
+        columns=["attr1", "attr2", "attr3"],
+    )
+
+    # Calculate quantiles
+    result = quantiles.calculate_quantiles(observed, null_data)
+
+    # Verify output structure
+    assert result.shape == observed.shape
+    assert list(result.index) == list(observed.index)
+    assert list(result.columns) == list(observed.columns)
+
+    # Check specific quantile calculations
+    # gene1, attr1: observed=0.8, nulls=[0.1, 0.2] -> quantile = 1.0 (100%)
+    assert result.loc["gene1", "attr1"] == 1.0
+
+    # gene2, attr2: observed=0.7, nulls=[0.5, 0.6] -> quantile = 1.0 (100%)
+    assert result.loc["gene2", "attr2"] == 1.0
+
+    # gene3, attr3: observed=0.5, nulls=[0.9, 1.0] -> quantile = 0.0 (0%)
+    assert result.loc["gene3", "attr3"] == 0.0
+
+    # gene4, attr1: observed=0.1, nulls=[0.0, 0.1]
+    # With ≤: 0.0 ≤ 0.1 (True), 0.1 ≤ 0.1 (True) → 2/2 = 1.0
+    assert result.loc["gene4", "attr1"] == 1.0
+
+
+def test_calculate_quantiles_error_cases():
+    """Test calculate_quantiles with invalid inputs that should raise errors or warnings."""
+    # Base observed data
+    observed = pd.DataFrame(
+        [[0.8, 0.3], [0.2, 0.7]], index=["gene1", "gene2"], columns=["attr1", "attr2"]
+    )
+
+    # Test 1: Mismatched columns
+    null_wrong_cols = pd.DataFrame(
+        [[0.1, 0.2, 0.3], [0.4, 0.5, 0.6]],
+        index=["gene1", "gene2"],
+        columns=["attr1", "attr2", "attr3"],  # Extra column
+    )
+
+    with pytest.raises((KeyError, ValueError)):
+        quantiles.calculate_quantiles(observed, null_wrong_cols)
+
+    # Test 2: Missing features in null data
+    null_missing_feature = pd.DataFrame(
+        [[0.1, 0.2]], index=["gene1"], columns=["attr1", "attr2"]  # Missing gene2
+    )
+
+    # Current implementation doesn't validate - it will likely fail in groupby or indexing
+    # This test verifies current behavior (may change if validation added)
+    try:
+        result = quantiles.calculate_quantiles(observed, null_missing_feature)
+        # If it succeeds, gene2 quantiles will be invalid/error
+        assert True  # Just check it doesn't crash for now
+    except (KeyError, ValueError, IndexError):
+        assert True  # Expected behavior
+
+    # Test 3: Unequal null samples per feature
+    null_unequal_samples = pd.DataFrame(
+        [
+            [0.1, 0.2],  # gene1 sample 1
+            [0.3, 0.4],  # gene1 sample 2
+            [0.5, 0.6],  # gene2 sample 1 (only 1 sample)
+        ],
+        index=["gene1", "gene1", "gene2"],
+        columns=["attr1", "attr2"],
+    )
+
+    # This should still work but may give different results
+    result = quantiles.calculate_quantiles(observed, null_unequal_samples)
+    assert result.shape == observed.shape
+
+    # Test 4: Empty null data
+    null_empty = pd.DataFrame(columns=["attr1", "attr2"])
+
+    with pytest.raises((ValueError, IndexError)):
+        quantiles.calculate_quantiles(observed, null_empty)
+
+    # Test 5: Single null sample (edge case)
+    null_single = pd.DataFrame(
+        [[0.1, 0.2], [0.5, 0.6]], index=["gene1", "gene2"], columns=["attr1", "attr2"]
+    )
+
+    result = quantiles.calculate_quantiles(observed, null_single)
+    assert result.shape == observed.shape
+    # With single sample, results should be binary (0 or 1)
+    assert all(val in [0.0, 1.0] for val in result.values.flatten())
+
+    # Test 6: NaN values in data
+    observed_with_nan = observed.copy()
+    observed_with_nan.loc["gene1", "attr1"] = np.nan
+
+    null_with_nan = pd.DataFrame(
+        [[np.nan, 0.2], [0.4, 0.5], [0.1, 0.3], [0.6, 0.7]],
+        index=["gene1", "gene2", "gene1", "gene2"],
+        columns=["attr1", "attr2"],
+    )
+
+    # Should raise ValueError for NaN values
+    with pytest.raises(ValueError, match="NaN values found in observed data"):
+        quantiles.calculate_quantiles(observed_with_nan, null_single)
+
+    with pytest.raises(ValueError, match="NaN values found in null data"):
+        quantiles.calculate_quantiles(observed, null_with_nan)

tests/test_set_coverage.py

@@ -1,50 +0,0 @@
-from __future__ import annotations
-
-from napistu import source
-from napistu.network import ng_utils
-
-
-def test_get_minimal_source_edges(sbml_dfs_metabolism):
-    vertices = sbml_dfs_metabolism.reactions.reset_index().rename(
-        columns={"r_id": "node"}
-    )
-
-    minimal_source_edges = ng_utils.get_minimal_sources_edges(
-        vertices, sbml_dfs_metabolism
-    )
-    # print(minimal_source_edges.shape)
-    assert minimal_source_edges.shape == (87, 3)
-
-
-def test_greedy_set_coverge_of_sources(sbml_dfs_metabolism):
-    table_schema = sbml_dfs_metabolism.schema["reactions"]
-
-    source_df = source.unnest_sources(
-        sbml_dfs_metabolism.reactions, source_var="r_Source"
-    )
-    # print(source_df.shape)
-    assert source_df.shape == (111, 7)
-
-    set_coverage = source.greedy_set_coverge_of_sources(source_df, table_schema)
-    # print(set_coverage.shape)
-    assert set_coverage.shape == (87, 6)
-
-
-################################################
-# __main__
-################################################
-
-if __name__ == "__main__":
-    import os
-    from napistu import indices
-    from napistu import consensus
-
-    test_path = os.path.abspath(os.path.join(__file__, os.pardir))
-    test_data = os.path.join(test_path, "test_data")
-
-    pw_index = indices.PWIndex(os.path.join(test_data, "pw_index_metabolism.tsv"))
-    sbml_dfs_dict = consensus.construct_sbml_dfs_dict(pw_index)
-    sbml_dfs_metabolism = consensus.construct_consensus_model(sbml_dfs_dict, pw_index)
-
-    test_get_minimal_source_edges(sbml_dfs_metabolism)
-    test_greedy_set_coverge_of_sources(sbml_dfs_metabolism)