napistu 0.4.0__py3-none-any.whl → 0.4.2__py3-none-any.whl

tests/test_sbml_dfs_core.py

@@ -13,10 +13,12 @@ from napistu.modify import pathwayannot
 
 from napistu import identifiers as napistu_identifiers
 from napistu.constants import (
-    SBML_DFS,
+    BQB,
     BQB_DEFINING_ATTRS,
     BQB_DEFINING_ATTRS_LOOSE,
-    BQB,
+    SBML_DFS,
+    SCHEMA_DEFS,
+    ONTOLOGIES,
 )
 from napistu.sbml_dfs_core import SBML_dfs
 from unittest.mock import patch
@@ -291,53 +293,62 @@ def test_read_sbml_with_invalid_ids():
 
 
 def test_get_table(sbml_dfs):
-    assert isinstance(sbml_dfs.get_table("species"), pd.DataFrame)
-    assert isinstance(sbml_dfs.get_table("species", {"id"}), pd.DataFrame)
+    assert isinstance(sbml_dfs.get_table(SBML_DFS.SPECIES), pd.DataFrame)
+    assert isinstance(
+        sbml_dfs.get_table(SBML_DFS.SPECIES, {SCHEMA_DEFS.ID}), pd.DataFrame
+    )
 
     # invalid table
     with pytest.raises(ValueError):
-        sbml_dfs.get_table("foo", {"id"})
+        sbml_dfs.get_table("foo", {SCHEMA_DEFS.ID})
 
     # bad type
     with pytest.raises(TypeError):
-        sbml_dfs.get_table("reaction_species", "id")
+        sbml_dfs.get_table(SBML_DFS.REACTION_SPECIES, SCHEMA_DEFS.ID)
 
     # reaction species don't have ids
     with pytest.raises(ValueError):
-        sbml_dfs.get_table("reaction_species", {"id"})
+        sbml_dfs.get_table(SBML_DFS.REACTION_SPECIES, {SCHEMA_DEFS.ID})
 
 
 def test_search_by_name(sbml_dfs_metabolism):
-    assert sbml_dfs_metabolism.search_by_name("atp", "species", False).shape[0] == 1
-    assert sbml_dfs_metabolism.search_by_name("pyr", "species").shape[0] == 3
-    assert sbml_dfs_metabolism.search_by_name("kinase", "reactions").shape[0] == 4
+    assert (
+        sbml_dfs_metabolism.search_by_name("atp", SBML_DFS.SPECIES, False).shape[0] == 1
+    )
+    assert sbml_dfs_metabolism.search_by_name("pyr", SBML_DFS.SPECIES).shape[0] == 3
+    assert (
+        sbml_dfs_metabolism.search_by_name("kinase", SBML_DFS.REACTIONS).shape[0] == 4
+    )
 
 
 def test_search_by_id(sbml_dfs_metabolism):
-    identifiers_tbl = sbml_dfs_metabolism.get_identifiers("species")
+    identifiers_tbl = sbml_dfs_metabolism.get_identifiers(SBML_DFS.SPECIES)
     ids, species = sbml_dfs_metabolism.search_by_ids(
-        ["P40926"], "species", identifiers_tbl
+        identifiers_tbl, identifiers=["P40926"]
     )
     assert ids.shape[0] == 1
     assert species.shape[0] == 1
 
     ids, species = sbml_dfs_metabolism.search_by_ids(
-        ["57540", "30744"], "species", identifiers_tbl, {"chebi"}
+        identifiers_tbl,
+        identifiers=["57540", "30744"],
+        ontologies={ONTOLOGIES.CHEBI},
     )
     assert ids.shape[0] == 2
     assert species.shape[0] == 2
 
-    ids, species = sbml_dfs_metabolism.search_by_ids(
-        ["baz"], "species", identifiers_tbl
-    )
-    assert ids.shape[0] == 0
-    assert species.shape[0] == 0
+    with pytest.raises(
+        ValueError, match="None of the requested identifiers are present"
+    ):
+        ids, species = sbml_dfs_metabolism.search_by_ids(
+            identifiers_tbl, identifiers=["baz"]  # Non-existent identifier
+        )
 
 
 def test_species_status(sbml_dfs):
 
     species = sbml_dfs.species
-    select_species = species[species["s_name"] == "OxyHbA"]
+    select_species = species[species[SBML_DFS.S_NAME] == "OxyHbA"]
     assert select_species.shape[0] == 1
 
     status = sbml_dfs.species_status(select_species.index[0])

tests/test_sbml_dfs_utils.py

@@ -264,3 +264,73 @@ def test_sbo_constants_internal_consistency():
         assert MINI_SBO_TO_NAME[term] == name
     for term, name in MINI_SBO_TO_NAME.items():
         assert MINI_SBO_FROM_NAME[name] == term
+
+
+def test_infer_entity_type():
+    """Test entity type inference with valid keys"""
+    # when index matches primary key.
+    # Test compartments with index as primary key
+    df = pd.DataFrame(
+        {SBML_DFS.C_NAME: ["cytoplasm"], SBML_DFS.C_IDENTIFIERS: ["GO:0005737"]}
+    )
+    df.index.name = SBML_DFS.C_ID
+    result = sbml_dfs_utils.infer_entity_type(df)
+    assert result == SBML_DFS.COMPARTMENTS
+
+    # Test species with index as primary key
+    df = pd.DataFrame(
+        {SBML_DFS.S_NAME: ["glucose"], SBML_DFS.S_IDENTIFIERS: ["CHEBI:17234"]}
+    )
+    df.index.name = SBML_DFS.S_ID
+    result = sbml_dfs_utils.infer_entity_type(df)
+    assert result == SBML_DFS.SPECIES
+
+    # Test entity type inference by exact column matching.
+    # Test compartmentalized_species (has foreign keys)
+    df = pd.DataFrame(
+        {
+            SBML_DFS.SC_ID: ["glucose_c"],
+            SBML_DFS.S_ID: ["glucose"],
+            SBML_DFS.C_ID: ["cytoplasm"],
+        }
+    )
+    result = sbml_dfs_utils.infer_entity_type(df)
+    assert result == "compartmentalized_species"
+
+    # Test reaction_species (has foreign keys)
+    df = pd.DataFrame(
+        {
+            SBML_DFS.RSC_ID: ["rxn1_glc"],
+            SBML_DFS.R_ID: ["rxn1"],
+            SBML_DFS.SC_ID: ["glucose_c"],
+        }
+    )
+    result = sbml_dfs_utils.infer_entity_type(df)
+    assert result == SBML_DFS.REACTION_SPECIES
+
+    # Test reactions (only primary key)
+    df = pd.DataFrame({SBML_DFS.R_ID: ["rxn1"]})
+    result = sbml_dfs_utils.infer_entity_type(df)
+    assert result == SBML_DFS.REACTIONS
+
+
+def test_infer_entity_type_errors():
+    """Test error cases for entity type inference."""
+    # Test no matching entity type
+    df = pd.DataFrame({"random_column": ["value"], "another_col": ["data"]})
+    with pytest.raises(ValueError, match="No entity type matches DataFrame"):
+        sbml_dfs_utils.infer_entity_type(df)
+
+    # Test partial match (missing required foreign key)
+    df = pd.DataFrame(
+        {SBML_DFS.SC_ID: ["glucose_c"], SBML_DFS.S_ID: ["glucose"]}
+    )  # Missing c_id
+    with pytest.raises(ValueError):
+        sbml_dfs_utils.infer_entity_type(df)
+
+    # Test extra primary keys that shouldn't be there
+    df = pd.DataFrame(
+        {SBML_DFS.R_ID: ["rxn1"], SBML_DFS.S_ID: ["glucose"]}
+    )  # Two primary keys
+    with pytest.raises(ValueError):
+        sbml_dfs_utils.infer_entity_type(df)

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)