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

tests/test_ontologies_renaming.py

@@ -1,14 +1,16 @@
 """Tests for the ontology aliases module."""
 
+from unittest.mock import patch
+
 import pytest
 import pandas as pd
 from napistu import identifiers
-from napistu.constants import IDENTIFIERS, SBML_DFS
+from napistu.constants import IDENTIFIERS, SBML_DFS, ONTOLOGIES
 from napistu.ontologies import renaming
 
 
 @pytest.fixture
-def mock_sbml_dfs():
+def mock_sbml_dfs(sbml_dfs):
     """Create a mock SBML_dfs object for testing."""
     # Create a simple species DataFrame with identifiers
     s1_ids = identifiers.Identifiers(
@@ -39,32 +41,27 @@ def mock_sbml_dfs():
         ]
     )
 
+    s3_ids = identifiers.Identifiers([])
+
     species_df = pd.DataFrame(
-        {"s_name": ["gene1", "gene2"], SBML_DFS.S_IDENTIFIERS: [s1_ids, s2_ids]}
+        {
+            SBML_DFS.S_NAME: ["gene1", "gene2", "gene3"],
+            SBML_DFS.S_IDENTIFIERS: [s1_ids, s2_ids, s3_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()
+    # Patch the species attribute only for the duration of the test
+    with patch.object(sbml_dfs, "species", new=species_df):
+        yield sbml_dfs  # All methods are real, only .species is patched
 
 
 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"}}
+    test_aliases = {
+        ONTOLOGIES.NCBI_ENTREZ_GENE: {"ncbigene"},
+        ONTOLOGIES.UNIPROT: {"uniprot_id"},
+    }
 
     # Update aliases
     renaming.rename_species_ontologies(mock_sbml_dfs, test_aliases)
@@ -73,11 +70,18 @@ def test_rename_species_ontologies_basic(mock_sbml_dfs):
     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 ONTOLOGIES.NCBI_ENTREZ_GENE in set(updated_ids[IDENTIFIERS.ONTOLOGY])
+    assert ONTOLOGIES.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])
 
+    # verify that all the species have Identifiers object
+    for row in mock_sbml_dfs.species.itertuples():
+        val = getattr(row, SBML_DFS.S_IDENTIFIERS)
+        assert val is not None and isinstance(
+            val, identifiers.Identifiers
+        ), f"Bad value: {val} in row {row}"
+
 
 def test_rename_species_ontologies_no_overlap(mock_sbml_dfs):
     """Test that error is raised when no aliases overlap with data."""
@@ -93,7 +97,7 @@ 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"}
+        ONTOLOGIES.NCBI_ENTREZ_GENE: {"ncbigene"}
         # Don't include uniprot_id mapping
     }
 
@@ -104,7 +108,7 @@ def test_rename_species_ontologies_partial_update(mock_sbml_dfs):
     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 ONTOLOGIES.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

@@ -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

@@ -5,6 +5,7 @@ import os
 import numpy as np
 import pandas as pd
 import pytest
+from napistu import identifiers
 from napistu import sbml_dfs_core
 from napistu.source import Source
 from napistu.ingestion import sbml
@@ -25,11 +26,13 @@ from unittest.mock import patch
 def test_data():
     """Create test data for SBML integration tests."""
 
+    blank_id = identifiers.Identifiers([])
+
     # Test compartments
     compartments_df = pd.DataFrame(
         [
-            {"c_name": "nucleus", "c_Identifiers": None},
-            {"c_name": "cytoplasm", "c_Identifiers": None},
+            {SBML_DFS.C_NAME: "nucleus", SBML_DFS.C_IDENTIFIERS: blank_id},
+            {SBML_DFS.C_NAME: "cytoplasm", SBML_DFS.C_IDENTIFIERS: blank_id},
         ]
     )
 
@@ -37,14 +40,18 @@ def test_data():
     species_df = pd.DataFrame(
         [
             {
-                "s_name": "TP53",
-                "s_Identifiers": None,
+                SBML_DFS.S_NAME: "TP53",
+                SBML_DFS.S_IDENTIFIERS: blank_id,
                 "gene_type": "tumor_suppressor",
             },
-            {"s_name": "MDM2", "s_Identifiers": None, "gene_type": "oncogene"},
             {
-                "s_name": "CDKN1A",
-                "s_Identifiers": None,
+                SBML_DFS.S_NAME: "MDM2",
+                SBML_DFS.S_IDENTIFIERS: blank_id,
+                "gene_type": "oncogene",
+            },
+            {
+                SBML_DFS.S_NAME: "CDKN1A",
+                SBML_DFS.S_IDENTIFIERS: blank_id,
                 "gene_type": "cell_cycle",
             },
         ]
@@ -58,10 +65,10 @@ def test_data():
                 "downstream_name": "CDKN1A",
                 "upstream_compartment": "nucleus",
                 "downstream_compartment": "nucleus",
-                "r_name": "TP53_activates_CDKN1A",
-                "sbo_term": "SBO:0000459",
-                "r_Identifiers": None,
-                "r_isreversible": False,
+                SBML_DFS.R_NAME: "TP53_activates_CDKN1A",
+                SBML_DFS.SBO_TERM: "SBO:0000459",
+                SBML_DFS.R_IDENTIFIERS: blank_id,
+                SBML_DFS.R_ISREVERSIBLE: False,
                 "confidence": 0.95,
             },
             {
@@ -69,10 +76,10 @@ def test_data():
                 "downstream_name": "TP53",
                 "upstream_compartment": "cytoplasm",
                 "downstream_compartment": "nucleus",
-                "r_name": "MDM2_inhibits_TP53",
-                "sbo_term": "SBO:0000020",
-                "r_Identifiers": None,
-                "r_isreversible": False,
+                SBML_DFS.R_NAME: "MDM2_inhibits_TP53",
+                SBML_DFS.SBO_TERM: "SBO:0000020",
+                SBML_DFS.R_IDENTIFIERS: blank_id,
+                SBML_DFS.R_ISREVERSIBLE: False,
                 "confidence": 0.87,
             },
         ]
@@ -611,3 +618,146 @@ def test_sbml_custom_stoichiometry(test_data):
     stoichiometries = result.reaction_species["stoichiometry"].unique()
     assert 2 in stoichiometries  # upstream
     assert 3 in stoichiometries  # downstream
+
+
+def test_validate_schema_missing(minimal_valid_sbml_dfs):
+    """Test validation fails when schema is missing."""
+    delattr(minimal_valid_sbml_dfs, "schema")
+    with pytest.raises(ValueError, match="No schema found"):
+        minimal_valid_sbml_dfs.validate()
+
+
+def test_validate_table(minimal_valid_sbml_dfs):
+    """Test _validate_table fails for various table structure issues."""
+    # Wrong index name
+    sbml_dfs = minimal_valid_sbml_dfs.copy()
+    sbml_dfs.species.index.name = "wrong_name"
+    with pytest.raises(ValueError, match="the index name for species was not the pk"):
+        sbml_dfs.validate()
+
+    # Duplicate primary keys
+    sbml_dfs = minimal_valid_sbml_dfs.copy()
+    duplicate_species = pd.DataFrame(
+        {
+            SBML_DFS.S_NAME: ["ATP", "ADP"],
+            SBML_DFS.S_IDENTIFIERS: [
+                identifiers.Identifiers([]),
+                identifiers.Identifiers([]),
+            ],
+            SBML_DFS.S_SOURCE: [Source(init=True), Source(init=True)],
+        },
+        index=pd.Index(["S00001", "S00001"], name=SBML_DFS.S_ID),
+    )
+    sbml_dfs.species = duplicate_species
+    with pytest.raises(ValueError, match="primary keys were duplicated"):
+        sbml_dfs.validate()
+
+    # Missing required variables
+    sbml_dfs = minimal_valid_sbml_dfs.copy()
+    sbml_dfs.species = sbml_dfs.species.drop(columns=[SBML_DFS.S_NAME])
+    with pytest.raises(ValueError, match="Missing .+ required variables for species"):
+        sbml_dfs.validate()
+
+    # Empty table
+    sbml_dfs = minimal_valid_sbml_dfs.copy()
+    sbml_dfs.species = pd.DataFrame(
+        {
+            SBML_DFS.S_NAME: [],
+            SBML_DFS.S_IDENTIFIERS: [],
+            SBML_DFS.S_SOURCE: [],
+        },
+        index=pd.Index([], name=SBML_DFS.S_ID),
+    )
+    with pytest.raises(ValueError, match="species contained no entries"):
+        sbml_dfs.validate()
+
+
+def test_check_pk_fk_correspondence(minimal_valid_sbml_dfs):
+    """Test _check_pk_fk_correspondence fails for various foreign key issues."""
+    # Missing species reference
+    sbml_dfs = minimal_valid_sbml_dfs.copy()
+    sbml_dfs.compartmentalized_species[SBML_DFS.S_ID] = ["S99999"]
+    with pytest.raises(
+        ValueError,
+        match="s_id values were found in compartmentalized_species but missing from species",
+    ):
+        sbml_dfs.validate()
+
+    # Missing compartment reference
+    sbml_dfs = minimal_valid_sbml_dfs.copy()
+    sbml_dfs.compartmentalized_species[SBML_DFS.C_ID] = ["C99999"]
+    with pytest.raises(
+        ValueError,
+        match="c_id values were found in compartmentalized_species but missing from compartments",
+    ):
+        sbml_dfs.validate()
+
+    # Null foreign keys
+    sbml_dfs = minimal_valid_sbml_dfs.copy()
+    sbml_dfs.compartmentalized_species[SBML_DFS.S_ID] = [None]
+    with pytest.raises(
+        ValueError, match="compartmentalized_species included missing s_id values"
+    ):
+        sbml_dfs.validate()
+
+
+def test_validate_reaction_species(minimal_valid_sbml_dfs):
+    """Test _validate_reaction_species fails for various reaction species issues."""
+    # Null stoichiometry
+    sbml_dfs = minimal_valid_sbml_dfs.copy()
+    sbml_dfs.reaction_species[SBML_DFS.STOICHIOMETRY] = [None]
+    with pytest.raises(ValueError, match="All reaction_species.* must be not null"):
+        sbml_dfs.validate()
+
+    # Null SBO terms
+    sbml_dfs = minimal_valid_sbml_dfs.copy()
+    sbml_dfs.reaction_species[SBML_DFS.SBO_TERM] = [None]
+    with pytest.raises(
+        ValueError, match="sbo_terms were None; all terms should be defined"
+    ):
+        sbml_dfs.validate()
+
+    # Invalid SBO terms
+    sbml_dfs = minimal_valid_sbml_dfs.copy()
+    sbml_dfs.reaction_species[SBML_DFS.SBO_TERM] = ["INVALID_SBO_TERM"]
+    with pytest.raises(ValueError, match="sbo_terms were not defined"):
+        sbml_dfs.validate()
+
+
+def test_validate_identifiers(minimal_valid_sbml_dfs):
+    """Test _validate_identifiers fails when identifiers are missing."""
+    minimal_valid_sbml_dfs.species[SBML_DFS.S_IDENTIFIERS] = [None]
+    with pytest.raises(ValueError, match="species has .+ missing ids"):
+        minimal_valid_sbml_dfs.validate()
+
+
+def test_validate_sources(minimal_valid_sbml_dfs):
+    """Test _validate_sources fails when sources are missing."""
+    minimal_valid_sbml_dfs.species[SBML_DFS.S_SOURCE] = [None]
+    with pytest.raises(ValueError, match="species has .+ missing sources"):
+        minimal_valid_sbml_dfs.validate()
+
+
+def test_validate_species_data(minimal_valid_sbml_dfs):
+    """Test _validate_species_data fails when species_data has invalid structure."""
+    invalid_data = pd.DataFrame(
+        {"extra_info": ["test"]}, index=pd.Index(["S99999"], name=SBML_DFS.S_ID)
+    )  # Non-existent species
+    minimal_valid_sbml_dfs.species_data["invalid"] = invalid_data
+    with pytest.raises(ValueError, match="species data invalid was invalid"):
+        minimal_valid_sbml_dfs.validate()
+
+
+def test_validate_reactions_data(minimal_valid_sbml_dfs):
+    """Test _validate_reactions_data fails when reactions_data has invalid structure."""
+    invalid_data = pd.DataFrame(
+        {"extra_info": ["test"]}, index=pd.Index(["R99999"], name=SBML_DFS.R_ID)
+    )  # Non-existent reaction
+    minimal_valid_sbml_dfs.reactions_data["invalid"] = invalid_data
+    with pytest.raises(ValueError, match="reactions data invalid was invalid"):
+        minimal_valid_sbml_dfs.validate()
+
+
+def test_validate_passes_with_valid_data(minimal_valid_sbml_dfs):
+    """Test that validation passes with completely valid data."""
+    minimal_valid_sbml_dfs.validate()  # Should not raise any exceptions

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,43 @@ 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

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
@@ -686,3 +687,45 @@ def test_safe_fill():
         "a_very_long\nstringggg",
         "",
     ]
+
+
+def test_update_pathological_names():
+
+    # All numeric
+    s = pd.Series(["1", "2", "3"])
+    out = utils.update_pathological_names(s, "prefix_")
+    assert all(x.startswith("prefix_") for x in out)
+    assert list(out) == ["prefix_1", "prefix_2", "prefix_3"]
+
+    # Mixed numeric and non-numeric
+    s2 = pd.Series(["1", "foo", "3"])
+    out2 = utils.update_pathological_names(s2, "prefix_")
+    assert list(out2) == ["1", "foo", "3"]
+
+    # All non-numeric
+    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)