napistu 0.2.5.dev7__py3-none-any.whl → 0.3.1__py3-none-any.whl

tests/test_ontologies_mygene.py

@@ -0,0 +1,39 @@
+from napistu.ontologies.mygene import create_python_mapping_tables
+from napistu.ontologies.constants import INTERCONVERTIBLE_GENIC_ONTOLOGIES
+
+
+def test_create_python_mapping_tables_yeast():
+    """Test create_python_mapping_tables with yeast species."""
+    # Test with a subset of mappings to keep test runtime reasonable
+    test_mappings = {"ensembl_gene", "symbol", "uniprot"}
+
+    # Verify test mappings are valid
+    assert test_mappings.issubset(
+        INTERCONVERTIBLE_GENIC_ONTOLOGIES
+    ), "Test mappings must be valid ontologies"
+
+    # Call function with yeast species
+    mapping_tables = create_python_mapping_tables(
+        mappings=test_mappings,
+        species="Saccharomyces cerevisiae",
+        test_mode=True,  # Limit to 1000 genes for faster testing
+    )
+
+    # Basic validation of results
+    assert isinstance(mapping_tables, dict), "Should return a dictionary"
+
+    # Check that all requested mappings are present (ignoring extras like ncbi_entrez_gene)
+    assert test_mappings.issubset(
+        set(mapping_tables.keys())
+    ), "All requested mappings should be present"
+
+    # Check each mapping table
+    for ontology in test_mappings:
+        df = mapping_tables[ontology]
+        assert not df.empty, f"Mapping table for {ontology} should not be empty"
+        assert (
+            df.index.name == "ncbi_entrez_gene"
+        ), f"Index should be entrez gene IDs for {ontology}"
+        assert (
+            not df.index.duplicated().any()
+        ), f"Should not have duplicate indices in {ontology}"

tests/test_ontologies_renaming.py

@@ -0,0 +1,110 @@
+"""Tests for the ontology aliases module."""
+
+import pytest
+import pandas as pd
+from napistu import identifiers
+from napistu.constants import IDENTIFIERS, SBML_DFS
+from napistu.ontologies import renaming
+
+
+@pytest.fixture
+def mock_sbml_dfs():
+    """Create a mock SBML_dfs object for testing."""
+    # Create a simple species DataFrame with identifiers
+    s1_ids = identifiers.Identifiers(
+        [
+            {
+                IDENTIFIERS.ONTOLOGY: "ncbigene",
+                IDENTIFIERS.IDENTIFIER: "123",
+                IDENTIFIERS.URL: "http://ncbi/123",
+                IDENTIFIERS.BQB: "is",
+            },
+            {
+                IDENTIFIERS.ONTOLOGY: "uniprot_id",
+                IDENTIFIERS.IDENTIFIER: "P12345",
+                IDENTIFIERS.URL: "http://uniprot/P12345",
+                IDENTIFIERS.BQB: "is",
+            },
+        ]
+    )
+
+    s2_ids = identifiers.Identifiers(
+        [
+            {
+                IDENTIFIERS.ONTOLOGY: "ncbigene",
+                IDENTIFIERS.IDENTIFIER: "456",
+                IDENTIFIERS.URL: "http://ncbi/456",
+                IDENTIFIERS.BQB: "is",
+            }
+        ]
+    )
+
+    species_df = pd.DataFrame(
+        {"s_name": ["gene1", "gene2"], SBML_DFS.S_IDENTIFIERS: [s1_ids, s2_ids]}
+    )
+
+    # Create mock SBML_dfs object
+    class MockSBMLDfs:
+        def __init__(self):
+            self.species = species_df
+            self.schema = {"species": {"pk": "s_id", "id": SBML_DFS.S_IDENTIFIERS}}
+
+        def get_identifiers(self, table_name):
+            if table_name == SBML_DFS.SPECIES:
+                all_ids = []
+                for idx, row in self.species.iterrows():
+                    for id_dict in row[SBML_DFS.S_IDENTIFIERS].ids:
+                        all_ids.append({"s_id": idx, **id_dict})
+                return pd.DataFrame(all_ids)
+            return pd.DataFrame()
+
+    return MockSBMLDfs()
+
+
+def test_rename_species_ontologies_basic(mock_sbml_dfs):
+    """Test basic alias updating functionality."""
+    # Define test aliases
+    test_aliases = {"ncbi_entrez_gene": {"ncbigene"}, "uniprot": {"uniprot_id"}}
+
+    # Update aliases
+    renaming.rename_species_ontologies(mock_sbml_dfs, test_aliases)
+
+    # Get updated identifiers
+    updated_ids = mock_sbml_dfs.get_identifiers(SBML_DFS.SPECIES)
+
+    # Check that ontologies were updated correctly
+    assert "ncbi_entrez_gene" in set(updated_ids[IDENTIFIERS.ONTOLOGY])
+    assert "uniprot" in set(updated_ids[IDENTIFIERS.ONTOLOGY])
+    assert "ncbigene" not in set(updated_ids[IDENTIFIERS.ONTOLOGY])
+    assert "uniprot_id" not in set(updated_ids[IDENTIFIERS.ONTOLOGY])
+
+
+def test_rename_species_ontologies_no_overlap(mock_sbml_dfs):
+    """Test that error is raised when no aliases overlap with data."""
+    # Define aliases that don't match any existing ontologies
+    test_aliases = {"ensembl_gene": {"ensembl"}}
+
+    # Should raise ValueError due to no overlap
+    with pytest.raises(ValueError, match="do not overlap"):
+        renaming.rename_species_ontologies(mock_sbml_dfs, test_aliases)
+
+
+def test_rename_species_ontologies_partial_update(mock_sbml_dfs):
+    """Test that partial updates work correctly."""
+    # Define aliases that only update some ontologies
+    test_aliases = {
+        "ncbi_entrez_gene": {"ncbigene"}
+        # Don't include uniprot_id mapping
+    }
+
+    # Update aliases
+    renaming.rename_species_ontologies(mock_sbml_dfs, test_aliases)
+
+    # Get updated identifiers
+    updated_ids = mock_sbml_dfs.get_identifiers(SBML_DFS.SPECIES)
+
+    # Check that only ncbigene was updated
+    assert "ncbi_entrez_gene" in set(updated_ids[IDENTIFIERS.ONTOLOGY])
+    assert "uniprot_id" in set(
+        updated_ids[IDENTIFIERS.ONTOLOGY]
+    )  # Should remain unchanged

tests/test_rpy2_callr.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+import sys
+from unittest.mock import Mock, patch
+import pandas as pd
+import pytest
+
+
+# Mock all rpy2 dependencies before any imports to prevent ImportErrors
+sys.modules["rpy2"] = Mock()
+sys.modules["rpy2.robjects"] = Mock()
+sys.modules["rpy2.robjects.conversion"] = Mock()
+sys.modules["rpy2.robjects.default_converter"] = Mock()
+sys.modules["rpy2.robjects.packages"] = Mock()
+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
+
+
+def test_get_napistu_r_without_rpy2():
+    """Test get_napistu_r when rpy2 not available."""
+    with patch("napistu.rpy2.get_rpy2_availability", return_value=False):
+        with pytest.raises(ImportError, match="requires `rpy2`"):
+            napistu.rpy2.callr.get_napistu_r()
+
+
+def test_bioconductor_org_r_function_without_rpy2():
+    """Test bioconductor function when rpy2 not available."""
+    with patch("napistu.rpy2.get_rpy2_availability", return_value=False):
+        with pytest.raises(ImportError):
+            napistu.rpy2.callr.bioconductor_org_r_function("test", "Homo sapiens")
+
+
+def test_get_rbase_without_rpy2():
+    """Test get_rbase when rpy2 not available."""
+    with patch("napistu.rpy2.get_rpy2_availability", return_value=False):
+        with pytest.raises(ImportError):
+            napistu.rpy2.callr.get_rbase()
+
+
+def test_pandas_conversion_functions_without_rpy2():
+    """Test pandas conversion functions when rpy2 not available."""
+    with patch("napistu.rpy2.get_rpy2_availability", return_value=False):
+        # Test pandas to R conversion
+        df = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+        with pytest.raises(ImportError):
+            napistu.rpy2.callr.pandas_to_r_dataframe(df)
+
+        # Test R to pandas conversion
+        mock_rdf = Mock()
+        with pytest.raises(ImportError):
+            napistu.rpy2.callr.r_dataframe_to_pandas(mock_rdf)
+
+        # Test internal converter function
+        with pytest.raises(ImportError):
+            napistu.rpy2.callr._get_py2rpy_pandas_conv()
+
+
+def test_callr_module_import_safety():
+    """Test that callr module can be imported safely without triggering R initialization."""
+    import importlib
+
+    # Test module can be imported without rpy2
+    with patch.dict("sys.modules", {"rpy2": None}):
+        # This should not raise ImportError during import
+        importlib.reload(napistu.rpy2.callr)
+
+    # Test that function calls fail appropriately but imports don't
+    with patch("napistu.rpy2.get_rpy2_availability", return_value=False):
+        # Functions should fail with ImportError, not other errors
+        with pytest.raises(ImportError):
+            napistu.rpy2.callr.get_napistu_r()
+
+        with pytest.raises(ImportError):
+            napistu.rpy2.callr.get_rbase()

tests/test_rpy2_init.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+import sys
+from unittest.mock import Mock, patch
+import pytest
+
+
+# Mock all rpy2 dependencies before any imports to prevent ImportErrors
+sys.modules["rpy2"] = Mock()
+sys.modules["rpy2.robjects"] = Mock()
+sys.modules["rpy2.robjects.conversion"] = Mock()
+sys.modules["rpy2.robjects.default_converter"] = Mock()
+sys.modules["rpy2.robjects.packages"] = Mock()
+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
+
+
+def test_rpy2_availability_detection():
+    """Test rpy2 availability detection in various scenarios."""
+    # Test ImportError case
+    with patch.dict("sys.modules", {"rpy2": None}):
+        if hasattr(napistu.rpy2.get_rpy2_availability, "cache_clear"):
+            napistu.rpy2.get_rpy2_availability.cache_clear()
+        assert napistu.rpy2.get_rpy2_availability() is False
+
+    # Test other exception case during import
+    with patch("builtins.__import__") as mock_import:
+        mock_import.side_effect = RuntimeError("R installation broken")
+        if hasattr(napistu.rpy2.get_rpy2_availability, "cache_clear"):
+            napistu.rpy2.get_rpy2_availability.cache_clear()
+        assert napistu.rpy2.get_rpy2_availability() is False
+
+    # Test success case
+    mock_rpy2 = Mock()
+    with patch.dict("sys.modules", {"rpy2": mock_rpy2}):
+        if hasattr(napistu.rpy2.get_rpy2_availability, "cache_clear"):
+            napistu.rpy2.get_rpy2_availability.cache_clear()
+        assert napistu.rpy2.get_rpy2_availability() is True
+
+
+def test_caching_behavior():
+    """Test that lazy loading functions are properly cached."""
+    # Test availability caching
+    with patch("builtins.__import__") as mock_import:
+        mock_import.return_value = Mock()
+        if hasattr(napistu.rpy2.get_rpy2_availability, "cache_clear"):
+            napistu.rpy2.get_rpy2_availability.cache_clear()
+
+        result1 = napistu.rpy2.get_rpy2_availability()
+        result2 = napistu.rpy2.get_rpy2_availability()
+
+        assert result1 == result2
+        # Only test call count if caching is enabled
+        if hasattr(napistu.rpy2.get_rpy2_availability, "cache_clear"):
+            assert mock_import.call_count == 1  # Should only be called once
+
+    # Test core modules caching
+    with patch("napistu.rpy2.get_rpy2_availability", return_value=True):
+        with patch("rpy2.robjects.conversion"), patch(
+            "rpy2.robjects.default_converter"
+        ), patch("rpy2.robjects.packages.importr"):
+            if hasattr(napistu.rpy2.get_rpy2_core_modules, "cache_clear"):
+                napistu.rpy2.get_rpy2_core_modules.cache_clear()
+
+            result1 = napistu.rpy2.get_rpy2_core_modules()
+            result2 = napistu.rpy2.get_rpy2_core_modules()
+
+            # Only test object identity if caching is enabled
+            if hasattr(napistu.rpy2.get_rpy2_core_modules, "cache_clear"):
+                assert result1 is result2  # Same object due to caching
+
+
+def test_lazy_import_functions_without_rpy2():
+    """Test that lazy import functions fail appropriately when rpy2 unavailable."""
+    with patch("napistu.rpy2.get_rpy2_availability", return_value=False):
+        # Clear all caches if they exist
+        if hasattr(napistu.rpy2.get_rpy2_core_modules, "cache_clear"):
+            napistu.rpy2.get_rpy2_core_modules.cache_clear()
+        if hasattr(napistu.rpy2.get_rpy2_extended_modules, "cache_clear"):
+            napistu.rpy2.get_rpy2_extended_modules.cache_clear()
+        if hasattr(napistu.rpy2.get_napistu_r_package, "cache_clear"):
+            napistu.rpy2.get_napistu_r_package.cache_clear()
+
+        # All should raise ImportError
+        with pytest.raises(ImportError, match="requires `rpy2`"):
+            napistu.rpy2.get_rpy2_core_modules()
+
+        with pytest.raises(ImportError, match="requires `rpy2`"):
+            napistu.rpy2.get_rpy2_extended_modules()
+
+        with pytest.raises(ImportError, match="requires `rpy2`"):
+            napistu.rpy2.get_napistu_r_package()
+
+
+def test_decorators():
+    """Test require_rpy2 and report_r_exceptions decorators."""
+    # Test require_rpy2 with rpy2 available
+    with patch("napistu.rpy2.get_rpy2_availability", return_value=True):
+
+        @napistu.rpy2.require_rpy2
+        def test_func_success():
+            return "success"
+
+        assert test_func_success() == "success"
+
+    # Test require_rpy2 without rpy2
+    with patch("napistu.rpy2.get_rpy2_availability", return_value=False):
+
+        @napistu.rpy2.require_rpy2
+        def test_func_fail():
+            return "success"
+
+        with pytest.raises(ImportError, match="test_func_fail.*requires `rpy2`"):
+            test_func_fail()
+
+    # Test report_r_exceptions with success
+    with patch("napistu.rpy2.get_rpy2_availability", return_value=True):
+
+        @napistu.rpy2.report_r_exceptions
+        def test_func_report_success():
+            return "success"
+
+        assert test_func_report_success() == "success"
+
+    # Test report_r_exceptions with failure
+    with patch("napistu.rpy2.get_rpy2_availability", return_value=True):
+        with patch("napistu.rpy2.rsession_info") as mock_rsession:
+
+            @napistu.rpy2.report_r_exceptions
+            def test_func_report_fail():
+                raise ValueError("R function failed")
+
+            with pytest.raises(ValueError, match="R function failed"):
+                test_func_report_fail()
+
+            mock_rsession.assert_called_once()
+
+
+def test_module_import_safety():
+    """Test that modules can be imported safely without triggering R initialization."""
+    import importlib
+
+    # Test modules can be imported without rpy2
+    with patch.dict("sys.modules", {"rpy2": None}):
+        # These should not raise ImportError during import
+        importlib.reload(napistu.rpy2)

tests/test_sbml.py

@@ -1,8 +1,5 @@
 from __future__ import annotations
 
-import os
-import pytest
-
 import pandas as pd
 from napistu import sbml_dfs_core
 from napistu.ingestion import sbml
@@ -18,31 +15,3 @@ def test_sbml_dfs(sbml_path):
     assert type(dfs.get_cspecies_features()) is pd.DataFrame
     assert type(dfs.get_species_features()) is pd.DataFrame
     assert type(dfs.get_identifiers("species")) is pd.DataFrame
-
-
-@pytest.mark.skip_on_windows
-def test_adding_sbml_annotations(sbml_model):
-    annotations = pd.DataFrame(
-        [
-            {
-                "id": "compartment_12045",
-                "type": "compartment",
-                "uri": "http://identifiers.org/chebi/CHEBI:00000",
-            },
-            {
-                "id": "species_9033251",
-                "type": "species",
-                "uri": "http://identifiers.org/bigg.metabolite/fakemet",
-            },
-            {
-                "id": "species_9033251",
-                "type": "species",
-                "uri": "http://identifiers.org/chebi/CHEBI:00000",
-            },
-        ]
-    )
-
-    outpath = "/tmp/tmp_write_test.sbml"
-
-    sbml.add_sbml_annotations(sbml_model, annotations, save_path=outpath)
-    assert os.path.isfile(outpath) is True

tests/test_sbml_dfs_core.py

@@ -10,7 +10,7 @@ from napistu.ingestion import sbml
 from napistu.modify import pathwayannot
 
 from napistu import identifiers as napistu_identifiers
-from napistu.constants import SBML_DFS
+from napistu.constants import SBML_DFS, SBOTERM_NAMES
 from napistu.sbml_dfs_core import SBML_dfs
 
 
@@ -196,17 +196,13 @@ def test_sbml_dfs_remove_reactions_check_species(sbml_dfs):
     # find all r_ids for a species and check if
     # removing all these reactions also removes the species
     s_id = sbml_dfs.species.index[0]
-    dat = (
-        sbml_dfs.compartmentalized_species.query("s_id == @s_id").merge(
-            sbml_dfs.reaction_species, on="sc_id"
-        )
-    )[["r_id", "sc_id"]]
-    r_ids = dat["r_id"]
-    sc_ids = dat["sc_id"]
+    dat = sbml_dfs.compartmentalized_species.query("s_id == @s_id").merge(
+        sbml_dfs.reaction_species, left_index=True, right_on="sc_id"
+    )
+    r_ids = dat["r_id"].unique()
     sbml_dfs.remove_reactions(r_ids, remove_species=True)
-    for sc_id in sc_ids:
-        assert sc_id not in sbml_dfs.compartmentalized_species.index
     assert s_id not in sbml_dfs.species.index
+    sbml_dfs.validate()
 
 
 def test_formula(sbml_dfs):
@@ -369,3 +365,131 @@ def test_get_identifiers_handles_missing_values():
     assert result.shape[0] == 0 or all(
         result[SBML_DFS.S_ID] == "s1"
     ), "Only Identifiers objects should be returned."
+
+
+def test_find_underspecified_reactions():
+
+    reaction_w_regulators = pd.DataFrame(
+        {
+            SBML_DFS.SC_ID: ["A", "B", "C", "D", "E", "F", "G"],
+            SBML_DFS.STOICHIOMETRY: [-1, -1, 1, 1, 0, 0, 0],
+            SBML_DFS.SBO_TERM: [
+                SBOTERM_NAMES.REACTANT,
+                SBOTERM_NAMES.REACTANT,
+                SBOTERM_NAMES.PRODUCT,
+                SBOTERM_NAMES.PRODUCT,
+                SBOTERM_NAMES.CATALYST,
+                SBOTERM_NAMES.CATALYST,
+                SBOTERM_NAMES.STIMULATOR,
+            ],
+        }
+    ).assign(r_id="bar")
+    reaction_w_regulators[SBML_DFS.RSC_ID] = [
+        f"rsc_{i}" for i in range(len(reaction_w_regulators))
+    ]
+    reaction_w_regulators.set_index(SBML_DFS.RSC_ID, inplace=True)
+    reaction_w_regulators = sbml_dfs_core.add_sbo_role(reaction_w_regulators)
+
+    reaction_w_interactors = pd.DataFrame(
+        {
+            SBML_DFS.SC_ID: ["A", "B"],
+            SBML_DFS.STOICHIOMETRY: [-1, 1],
+            SBML_DFS.SBO_TERM: [SBOTERM_NAMES.REACTANT, SBOTERM_NAMES.REACTANT],
+        }
+    ).assign(r_id="baz")
+    reaction_w_interactors[SBML_DFS.RSC_ID] = [
+        f"rsc_{i}" for i in range(len(reaction_w_interactors))
+    ]
+    reaction_w_interactors.set_index(SBML_DFS.RSC_ID, inplace=True)
+    reaction_w_interactors = sbml_dfs_core.add_sbo_role(reaction_w_interactors)
+
+    working_reactions = reaction_w_regulators.copy()
+    working_reactions["new"] = True
+    working_reactions.loc["rsc_0", "new"] = False
+    working_reactions
+    result = sbml_dfs_core.find_underspecified_reactions(working_reactions)
+    assert result == {"bar"}
+
+    # missing one enzyme -> operable
+    working_reactions = reaction_w_regulators.copy()
+    working_reactions["new"] = True
+    working_reactions.loc["rsc_4", "new"] = False
+    working_reactions
+    result = sbml_dfs_core.find_underspecified_reactions(working_reactions)
+    assert result == set()
+
+    # missing one product -> inoperable
+    working_reactions = reaction_w_regulators.copy()
+    working_reactions["new"] = True
+    working_reactions.loc["rsc_2", "new"] = False
+    working_reactions
+    result = sbml_dfs_core.find_underspecified_reactions(working_reactions)
+    assert result == {"bar"}
+
+    # missing all enzymes -> inoperable
+    working_reactions = reaction_w_regulators.copy()
+    working_reactions["new"] = True
+    working_reactions.loc["rsc_4", "new"] = False
+    working_reactions.loc["rsc_5", "new"] = False
+    working_reactions
+    result = sbml_dfs_core.find_underspecified_reactions(working_reactions)
+    assert result == {"bar"}
+
+    # missing regulators -> operable
+    working_reactions = reaction_w_regulators.copy()
+    working_reactions["new"] = True
+    working_reactions.loc["rsc_6", "new"] = False
+    working_reactions
+    result = sbml_dfs_core.find_underspecified_reactions(working_reactions)
+    assert result == set()
+
+    # remove an interactor
+    working_reactions = reaction_w_interactors.copy()
+    working_reactions["new"] = True
+    working_reactions.loc["rsc_0", "new"] = False
+    working_reactions
+    result = sbml_dfs_core.find_underspecified_reactions(working_reactions)
+    assert result == {"baz"}
+
+
+def test_remove_entity_data_success(sbml_dfs_w_data):
+    """Test successful removal of entity data."""
+    # Get initial data
+    initial_species_data_keys = set(sbml_dfs_w_data.species_data.keys())
+    initial_reactions_data_keys = set(sbml_dfs_w_data.reactions_data.keys())
+
+    # Remove species data
+    sbml_dfs_w_data._remove_entity_data(SBML_DFS.SPECIES, "test_species")
+    assert "test_species" not in sbml_dfs_w_data.species_data
+    assert set(sbml_dfs_w_data.species_data.keys()) == initial_species_data_keys - {
+        "test_species"
+    }
+
+    # Remove reactions data
+    sbml_dfs_w_data._remove_entity_data(SBML_DFS.REACTIONS, "test_reactions")
+    assert "test_reactions" not in sbml_dfs_w_data.reactions_data
+    assert set(sbml_dfs_w_data.reactions_data.keys()) == initial_reactions_data_keys - {
+        "test_reactions"
+    }
+
+    # Validate the model is still valid after removals
+    sbml_dfs_w_data.validate()
+
+
+def test_remove_entity_data_nonexistent(sbml_dfs_w_data, caplog):
+    """Test warning when trying to remove nonexistent entity data."""
+    # Try to remove nonexistent species data
+    sbml_dfs_w_data._remove_entity_data(SBML_DFS.SPECIES, "nonexistent_label")
+    assert "Label 'nonexistent_label' not found in species_data" in caplog.text
+    assert set(sbml_dfs_w_data.species_data.keys()) == {"test_species"}
+
+    # Clear the log
+    caplog.clear()
+
+    # Try to remove nonexistent reactions data
+    sbml_dfs_w_data._remove_entity_data(SBML_DFS.REACTIONS, "nonexistent_label")
+    assert "Label 'nonexistent_label' not found in reactions_data" in caplog.text
+    assert set(sbml_dfs_w_data.reactions_data.keys()) == {"test_reactions"}
+
+    # Validate the model is still valid
+    sbml_dfs_w_data.validate()