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

tests/test_ontologies_id_tables.py

@@ -0,0 +1,198 @@
+import pytest
+import pandas as pd
+from unittest.mock import patch
+
+from napistu.ontologies import id_tables
+from napistu.constants import (
+    BQB,
+    IDENTIFIERS,
+    ONTOLOGIES,
+    SBML_DFS,
+    VALID_BQB_TERMS,
+)
+
+
+@pytest.fixture
+def sample_id_table():
+    """Create a sample DataFrame for testing."""
+    return pd.DataFrame(
+        {
+            SBML_DFS.S_ID: ["s1", "s2", "s3", "s4"],
+            IDENTIFIERS.ONTOLOGY: [
+                ONTOLOGIES.GO,
+                ONTOLOGIES.KEGG,
+                ONTOLOGIES.REACTOME,
+                ONTOLOGIES.WIKIPATHWAYS,
+            ],
+            IDENTIFIERS.IDENTIFIER: ["GO:0001", "hsa00010", "R-HSA-123", "WP123"],
+            IDENTIFIERS.BQB: [BQB.IS, BQB.HAS_PART, BQB.IS_PART_OF, BQB.IS_VERSION_OF],
+            IDENTIFIERS.URL: ["foo", "bar", "baz", "qux"],
+            "other_col": ["a", "b", "c", "d"],
+        }
+    )
+
+
+def test_sanitize_id_table_values_valid_cases(sample_id_table):
+    """Test all valid use cases for _sanitize_id_table_values function."""
+
+    # Test string input conversion
+    result = id_tables._sanitize_id_table_values(
+        ONTOLOGIES.GO, sample_id_table, IDENTIFIERS.ONTOLOGY
+    )
+    assert result == {ONTOLOGIES.GO}
+    assert isinstance(result, set)
+
+    # Test list input conversion
+    result = id_tables._sanitize_id_table_values(
+        [ONTOLOGIES.GO, ONTOLOGIES.KEGG], sample_id_table, IDENTIFIERS.ONTOLOGY
+    )
+    assert result == {ONTOLOGIES.GO, ONTOLOGIES.KEGG}
+    assert isinstance(result, set)
+
+    # Test set input unchanged
+    input_set = {ONTOLOGIES.GO, ONTOLOGIES.KEGG}
+    result = id_tables._sanitize_id_table_values(
+        input_set, sample_id_table, IDENTIFIERS.ONTOLOGY
+    )
+    assert result == input_set
+    assert isinstance(result, set)
+
+    # Test successful validation against valid_values
+    result = id_tables._sanitize_id_table_values(
+        BQB.IS, sample_id_table, IDENTIFIERS.BQB, set(VALID_BQB_TERMS)
+    )
+    assert result == {BQB.IS}
+
+    # Test duplicate values in input list are handled correctly
+    result = id_tables._sanitize_id_table_values(
+        [ONTOLOGIES.GO, ONTOLOGIES.GO, ONTOLOGIES.KEGG],
+        sample_id_table,
+        IDENTIFIERS.ONTOLOGY,
+    )
+    assert result == {
+        ONTOLOGIES.GO,
+        ONTOLOGIES.KEGG,
+    }  # Duplicates removed by set conversion
+
+    # Test all values present in table
+    result = id_tables._sanitize_id_table_values(
+        [ONTOLOGIES.GO, ONTOLOGIES.KEGG, ONTOLOGIES.REACTOME],
+        sample_id_table,
+        IDENTIFIERS.ONTOLOGY,
+    )
+    assert result == {ONTOLOGIES.GO, ONTOLOGIES.KEGG, ONTOLOGIES.REACTOME}
+
+    # Test single value present in table
+    result = id_tables._sanitize_id_table_values(
+        ONTOLOGIES.WIKIPATHWAYS, sample_id_table, IDENTIFIERS.ONTOLOGY
+    )
+    assert result == {ONTOLOGIES.WIKIPATHWAYS}
+
+    # Test with different column (BQB)
+    result = id_tables._sanitize_id_table_values(
+        BQB.HAS_PART, sample_id_table, IDENTIFIERS.BQB
+    )
+    assert result == {BQB.HAS_PART}
+
+
+@patch("napistu.ontologies.id_tables.logger")
+def test_sanitize_id_table_values_error_cases(mock_logger, sample_id_table):
+    """Test error cases and edge cases for _sanitize_id_table_values function."""
+
+    # Test invalid input types raise ValueError
+    with pytest.raises(ValueError, match="ontology must be a string, a set, or list"):
+        id_tables._sanitize_id_table_values(123, sample_id_table, IDENTIFIERS.ONTOLOGY)
+
+    with pytest.raises(ValueError, match="ontology must be a string, a set, or list"):
+        id_tables._sanitize_id_table_values(
+            {"key": "value"}, sample_id_table, IDENTIFIERS.ONTOLOGY
+        )
+
+    # Test validation failure against valid_values
+    with pytest.raises(
+        ValueError, match="The following bqb are not valid: INVALID_BQB"
+    ):
+        id_tables._sanitize_id_table_values(
+            "INVALID_BQB", sample_id_table, IDENTIFIERS.BQB, set(VALID_BQB_TERMS), "bqb"
+        )
+
+    # Test multiple invalid values against valid_values
+    with pytest.raises(ValueError, match="The following bqb are not valid"):
+        id_tables._sanitize_id_table_values(
+            ["INVALID1", "INVALID2"],
+            sample_id_table,
+            IDENTIFIERS.BQB,
+            set(VALID_BQB_TERMS),
+            "bqb",
+        )
+
+    # Test all values missing from table raises error
+    missing_values = {"MISSING1", "MISSING2"}
+    with pytest.raises(ValueError, match="None of the requested ontology are present"):
+        id_tables._sanitize_id_table_values(
+            missing_values, sample_id_table, IDENTIFIERS.ONTOLOGY
+        )
+
+    # Test case-sensitive matching (lowercase 'go' should fail)
+    with pytest.raises(ValueError, match="None of the requested ontology are present"):
+        id_tables._sanitize_id_table_values(
+            "INVALID_ONTOLOGY", sample_id_table, IDENTIFIERS.ONTOLOGY
+        )
+
+    # Test custom value_type_name in error messages
+    with pytest.raises(ValueError, match="custom_type must be a string"):
+        id_tables._sanitize_id_table_values(
+            123, sample_id_table, IDENTIFIERS.ONTOLOGY, value_type_name="custom_type"
+        )
+
+    # Test default value_type_name uses column_name
+    with pytest.raises(ValueError, match="test_column must be a string"):
+        id_tables._sanitize_id_table_values(123, sample_id_table, "test_column")
+
+    # Test empty dataframe column
+    empty_df = pd.DataFrame({"ontology": []})
+    with pytest.raises(ValueError, match="None of the requested ontology are present"):
+        id_tables._sanitize_id_table_values("GO", empty_df, IDENTIFIERS.ONTOLOGY)
+
+    # Test partial values missing logs warning but doesn't raise error
+    mixed_values = {ONTOLOGIES.GO, "MISSING"}  # GO exists, MISSING doesn't
+    result = id_tables._sanitize_id_table_values(
+        mixed_values, sample_id_table, IDENTIFIERS.ONTOLOGY
+    )
+
+    assert result == mixed_values
+    mock_logger.warning.assert_called_once()
+    warning_call = mock_logger.warning.call_args[0][0]
+    assert "MISSING" in warning_call
+    assert "not present in the id_table" in warning_call
+
+    # Test multiple partial missing values
+    mock_logger.reset_mock()
+    mixed_values = {ONTOLOGIES.GO, ONTOLOGIES.KEGG, "MISSING1", "MISSING2"}
+    result = id_tables._sanitize_id_table_values(
+        mixed_values, sample_id_table, IDENTIFIERS.ONTOLOGY
+    )
+
+    assert result == mixed_values
+    mock_logger.warning.assert_called_once()
+    warning_call = mock_logger.warning.call_args[0][0]
+    assert "MISSING1" in warning_call and "MISSING2" in warning_call
+
+
+def test_filter_id_table_basic(sample_id_table):
+    """Basic test for filter_id_table filtering by identifier, ontology, and bqb."""
+
+    # Use a known identifier, ontology, and bqb from the fixture
+    filtered = id_tables.filter_id_table(
+        id_table=sample_id_table,
+        identifiers=["GO:0001"],
+        ontologies=[ONTOLOGIES.GO],
+        bqbs=[BQB.IS],
+    )
+    # Should return a DataFrame with only the matching row
+    assert isinstance(filtered, pd.DataFrame)
+    assert len(filtered) == 1
+    row = filtered.iloc[0]
+    assert row[IDENTIFIERS.ONTOLOGY] == ONTOLOGIES.GO
+    assert row[IDENTIFIERS.IDENTIFIER] == "GO:0001"
+    assert row[IDENTIFIERS.BQB] == BQB.IS

tests/test_rpy2_callr.py

@@ -16,7 +16,6 @@ sys.modules["rpy2.robjects.pandas2ri"] = Mock()
 sys.modules["rpy2.rinterface"] = Mock()
 sys.modules["rpy2_arrow"] = Mock()
 sys.modules["rpy2_arrow.arrow"] = Mock()
-sys.modules["pyarrow"] = Mock()
 
 import napistu.rpy2.callr  # noqa: E402
 

tests/test_rpy2_init.py

@@ -15,7 +15,6 @@ sys.modules["rpy2.robjects.pandas2ri"] = Mock()
 sys.modules["rpy2.rinterface"] = Mock()
 sys.modules["rpy2_arrow"] = Mock()
 sys.modules["rpy2_arrow.arrow"] = Mock()
-sys.modules["pyarrow"] = Mock()
 
 import napistu.rpy2  # noqa: E402
 

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

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import pandas as pd
+import pytest
 
 from napistu import sbml_dfs_utils
 from napistu.constants import (
@@ -10,6 +11,10 @@ from napistu.constants import (
     SBML_DFS,
     IDENTIFIERS,
     SBOTERM_NAMES,
+    VALID_SBO_TERMS,
+    VALID_SBO_TERM_NAMES,
+    MINI_SBO_FROM_NAME,
+    MINI_SBO_TO_NAME,
 )
 
 
@@ -219,3 +224,113 @@ def test_stubbed_compartment():
         "url": "https://www.ebi.ac.uk/QuickGO/term/GO:0005575",
         "bqb": "BQB_IS",
     }
+
+
+def test_validate_sbo_values_success():
+    # Should not raise
+    sbml_dfs_utils._validate_sbo_values(pd.Series(VALID_SBO_TERMS), validate="terms")
+    sbml_dfs_utils._validate_sbo_values(
+        pd.Series(VALID_SBO_TERM_NAMES), validate="names"
+    )
+
+
+def test_validate_sbo_values_invalid_type():
+    with pytest.raises(ValueError, match="Invalid validation type"):
+        sbml_dfs_utils._validate_sbo_values(
+            pd.Series(VALID_SBO_TERMS), validate="badtype"
+        )
+
+
+def test_validate_sbo_values_invalid_value():
+    # Add an invalid term
+    s = pd.Series(VALID_SBO_TERMS + ["SBO:9999999"])
+    with pytest.raises(ValueError, match="unusable SBO terms"):
+        sbml_dfs_utils._validate_sbo_values(s, validate="terms")
+    # Add an invalid name
+    s = pd.Series(VALID_SBO_TERM_NAMES + ["not_a_name"])
+    with pytest.raises(ValueError, match="unusable SBO terms"):
+        sbml_dfs_utils._validate_sbo_values(s, validate="names")
+
+
+def test_sbo_constants_internal_consistency():
+    # Every term should have a name and vice versa
+    # MINI_SBO_FROM_NAME: name -> term, MINI_SBO_TO_NAME: term -> name
+    terms_from_names = set(MINI_SBO_FROM_NAME.values())
+    names_from_terms = set(MINI_SBO_TO_NAME.values())
+    assert terms_from_names == set(VALID_SBO_TERMS)
+    assert names_from_terms == set(VALID_SBO_TERM_NAMES)
+    # Bijective mapping
+    for name, term in MINI_SBO_FROM_NAME.items():
+        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_utils.py

@@ -2,9 +2,10 @@ from __future__ import annotations
 
 import gzip
 import os
+import tempfile
 from datetime import datetime
-from unittest.mock import Mock
-from unittest.mock import patch
+from pathlib import Path
+from unittest.mock import Mock, patch
 
 import numpy as np
 import pandas as pd
@@ -705,3 +706,26 @@ def test_update_pathological_names():
     s3 = pd.Series(["foo", "bar", "baz"])
     out3 = utils.update_pathological_names(s3, "prefix_")
     assert list(out3) == ["foo", "bar", "baz"]
+
+
+def test_parquet_save_load():
+    """Test that write_parquet and read_parquet work correctly."""
+    # Create test DataFrame
+    original_df = pd.DataFrame(
+        {
+            "sc_id_origin": ["A", "B", "C"],
+            "sc_id_dest": ["B", "C", "A"],
+            "path_length": [1, 2, 3],
+            "path_weights": [0.1, 0.5, 0.8],
+            "has_connection": [True, False, True],
+        }
+    )
+
+    # Write and read using temporary file
+    with tempfile.TemporaryDirectory() as temp_dir:
+        file_path = Path(temp_dir) / "test.parquet"
+        utils.save_parquet(original_df, file_path)
+        result_df = utils.load_parquet(file_path)
+
+        # Verify they're identical
+        pd.testing.assert_frame_equal(original_df, result_df)