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

tests/test_context_filtering.py

@@ -0,0 +1,267 @@
+from __future__ import annotations
+
+import copy
+import pytest
+import pandas as pd
+from napistu import sbml_dfs_core
+from napistu.constants import SBML_DFS
+from napistu.context.filtering import (
+    filter_species_by_attribute,
+    find_species_with_attribute,
+    _binarize_species_data,
+    filter_reactions_with_disconnected_cspecies,
+)
+
+
+@pytest.fixture
+def sbml_dfs_with_test_data(sbml_dfs):
+    """Add test data to the sbml_dfs fixture for filtering tests."""
+    # Add location data
+    location_data = pd.DataFrame(
+        index=sbml_dfs.species.index[:5],
+        data={
+            "compartment": ["nucleus", "cytoplasm", "nucleus", "membrane", "cytoplasm"],
+            "confidence": [0.9, 0.8, 0.7, 0.95, 0.85],
+        },
+    )
+    sbml_dfs.add_species_data("location", location_data)
+
+    # Add expression data
+    expression_data = pd.DataFrame(
+        index=sbml_dfs.species.index[:5],
+        data={
+            "is_expressed": [True, True, False, True, False],
+            "expression_level": [100, 50, 0, 75, 0],
+        },
+    )
+    sbml_dfs.add_species_data("expression", expression_data)
+
+    return sbml_dfs
+
+
+def test_find_species_to_filter_by_attribute(sbml_dfs_with_test_data):
+    """Test the find_species_to_filter_by_attribute function."""
+    # Get the first 5 species IDs for reference
+    test_species = list(sbml_dfs_with_test_data.species.index[:5])
+
+    # Test filtering by single value
+    filtered = find_species_with_attribute(
+        sbml_dfs_with_test_data.species_data["location"], "compartment", "nucleus"
+    )
+    assert len(filtered) == 2
+    assert all(s_id in test_species for s_id in filtered)
+
+    # Test filtering by list of values
+    filtered = find_species_with_attribute(
+        sbml_dfs_with_test_data.species_data["location"],
+        "compartment",
+        ["nucleus", "cytoplasm"],
+    )
+    assert len(filtered) == 4
+    assert all(s_id in test_species for s_id in filtered)
+
+    # Test filtering with negation
+    filtered = find_species_with_attribute(
+        sbml_dfs_with_test_data.species_data["location"],
+        "compartment",
+        "nucleus",
+        negate=True,
+    )
+    assert len(filtered) == 3
+    assert all(s_id in test_species for s_id in filtered)
+
+    # Test filtering boolean values
+    filtered = find_species_with_attribute(
+        sbml_dfs_with_test_data.species_data["expression"], "is_expressed", True
+    )
+    assert len(filtered) == 3
+    assert all(s_id in test_species for s_id in filtered)
+
+    # Test filtering numeric values
+    filtered = find_species_with_attribute(
+        sbml_dfs_with_test_data.species_data["location"], "confidence", 0.9
+    )
+    assert len(filtered) == 1
+    assert all(s_id in test_species for s_id in filtered)
+
+
+def test_filter_species_by_attribute(sbml_dfs_with_test_data):
+    """Test the filter_species_by_attribute function."""
+    # Get the first 5 species IDs for reference
+    test_species = list(sbml_dfs_with_test_data.species.index[:5])
+    original_species_count = len(sbml_dfs_with_test_data.species)
+
+    # Test filtering in place - should remove species in nucleus
+    result = filter_species_by_attribute(
+        sbml_dfs_with_test_data, "location", "compartment", "nucleus"
+    )
+    assert result is None
+    # Should have removed the nucleus species from the test set
+    assert len(sbml_dfs_with_test_data.species) == original_species_count - 2
+    # Check that species in nucleus were removed
+    remaining_test_species = [
+        s for s in test_species if s in sbml_dfs_with_test_data.species.index
+    ]
+    assert (
+        len(remaining_test_species) == 3
+    )  # Should have 3 test species left (cytoplasm, membrane, cytoplasm)
+
+    # Test filtering with new object - should remove expressed species
+    sbml_dfs_copy = copy.deepcopy(sbml_dfs_with_test_data)
+
+    # Count how many species are expressed in our test data
+    expressed_count = sum(
+        sbml_dfs_copy.species_data["expression"]["is_expressed"].iloc[:5]
+    )
+
+    filtered_sbml_dfs = filter_species_by_attribute(
+        sbml_dfs_copy, "expression", "is_expressed", True, inplace=False
+    )
+    # Original should be unchanged
+    assert len(sbml_dfs_copy.species) == len(sbml_dfs_with_test_data.species)
+    # New object should have removed expressed species from our test set
+    assert (
+        len(filtered_sbml_dfs.species)
+        == len(sbml_dfs_with_test_data.species) - expressed_count
+    )
+
+    # Test filtering with invalid table name
+    with pytest.raises(ValueError, match="species_data_table .* not found"):
+        filter_species_by_attribute(
+            sbml_dfs_with_test_data, "nonexistent_table", "compartment", "nucleus"
+        )
+
+    # Test filtering with invalid attribute name
+    with pytest.raises(ValueError, match="attribute_name .* not found"):
+        filter_species_by_attribute(
+            sbml_dfs_with_test_data, "location", "nonexistent_attribute", "nucleus"
+        )
+
+    # Test filtering with list of values and negation
+    # Keep only species NOT in nucleus or cytoplasm (just membrane in our test data)
+
+    VALID_COMPARTMENTS = ["nucleus", "cytoplasm"]
+    filtered_sbml_dfs = filter_species_by_attribute(
+        sbml_dfs_with_test_data,
+        "location",
+        "compartment",
+        VALID_COMPARTMENTS,
+        negate=True,
+        inplace=False,
+    )
+
+    # Get remaining species from our test set
+    remaining_test_species = [
+        s for s in test_species if s in filtered_sbml_dfs.species.index
+    ]
+
+    assert all(filtered_sbml_dfs.species_data["location"].isin(VALID_COMPARTMENTS))
+
+
+def test_binarize_species_data():
+    # Create test data with different column types
+    test_data = pd.DataFrame(
+        {
+            "bool_col": [True, False, True],
+            "binary_int": [1, 0, 1],
+            "non_binary_int": [1, 2, 3],
+            "float_col": [1.5, 2.5, 3.5],
+            "str_col": ["a", "b", "c"],
+        }
+    )
+
+    # Run the binarization
+    binary_df = _binarize_species_data(test_data)
+
+    # Check that only boolean and binary columns were kept
+    assert set(binary_df.columns) == {"bool_col", "binary_int"}
+
+    # Check that boolean was converted to int
+    assert (
+        binary_df["bool_col"].dtype == "int32" or binary_df["bool_col"].dtype == "int64"
+    )
+    assert binary_df["bool_col"].tolist() == [1, 0, 1]
+
+    # Check that binary int remained the same
+    assert binary_df["binary_int"].tolist() == [1, 0, 1]
+
+    # Test with only non-binary columns
+    non_binary_data = pd.DataFrame(
+        {
+            "non_binary_int": [1, 2, 3],
+            "float_col": [1.5, 2.5, 3.5],
+        }
+    )
+
+    # Should raise ValueError when no binary columns are found
+    with pytest.raises(ValueError, match="No binary or boolean columns found"):
+        _binarize_species_data(non_binary_data)
+
+    # Test with empty DataFrame
+    empty_data = pd.DataFrame()
+    with pytest.raises(ValueError, match="No binary or boolean columns found"):
+        _binarize_species_data(empty_data)
+
+
+def test_filter_reactions_with_disconnected_cspecies(sbml_dfs):
+    # 1. Select first few reactions
+    first_reactions = list(sbml_dfs.reactions.index[:5])
+
+    # 2. Find defining species in these reactions
+    reaction_species = sbml_dfs_core.add_sbo_role(sbml_dfs.reaction_species)
+    defining_species = (
+        reaction_species[reaction_species[SBML_DFS.R_ID].isin(first_reactions)]
+        .query("sbo_role == 'DEFINING'")
+        # at most 1 record for an sc_id in a reaction (generally true anyways)
+        .groupby([SBML_DFS.R_ID, SBML_DFS.SC_ID])
+        .first()
+        .reset_index(drop=False)
+        .groupby(SBML_DFS.R_ID)
+        .head(2)  # Take 2 defining species per reaction
+    )
+
+    # 3. Get species IDs for these compartmentalized species
+    species_info = defining_species.merge(
+        sbml_dfs.compartmentalized_species[[SBML_DFS.S_ID]],
+        left_on=SBML_DFS.SC_ID,
+        right_index=True,
+    )
+
+    # Filter out reactions that have less than 2 distinct s_ids (transport reactions)
+    valid_reactions = (
+        species_info.groupby(SBML_DFS.R_ID)[SBML_DFS.S_ID]
+        .nunique()
+        .pipe(lambda x: x[x >= 2])
+        .index
+    )
+    species_info = species_info[species_info[SBML_DFS.R_ID].isin(valid_reactions)]
+
+    # 4. Create binary occurrence data where DISJOINT_S_ID is in a different comaprtment from the other top species
+    # this should result in removing disconnected_reactions from the sbml_dfs
+    DISJOINT_S_ID = species_info.value_counts("s_id").index[0]
+    disconnected_reactions = set(
+        species_info["r_id"][species_info["s_id"] == DISJOINT_S_ID].tolist()
+    )
+
+    # mock data
+    mock_species_data = pd.DataFrame({SBML_DFS.S_ID: species_info["s_id"].unique()})
+    mock_species_data["compartment_A"] = [
+        1 if s_id == DISJOINT_S_ID else 0 for s_id in mock_species_data[SBML_DFS.S_ID]
+    ]
+    mock_species_data["compartment_B"] = [
+        0 if s_id == DISJOINT_S_ID else 1 for s_id in mock_species_data[SBML_DFS.S_ID]
+    ]
+    mock_species_data.set_index(SBML_DFS.S_ID, inplace=True)
+
+    sbml_dfs.add_species_data("test_data", mock_species_data)
+
+    # Run the filter function
+    filtered_sbml_dfs = filter_reactions_with_disconnected_cspecies(
+        sbml_dfs, "test_data", inplace=False
+    )
+
+    filtered_first_reactions = [
+        r for r in first_reactions if r not in filtered_sbml_dfs.reactions.index
+    ]
+
+    assert set(filtered_first_reactions) == disconnected_reactions

tests/test_identifiers.py

@@ -5,6 +5,8 @@ import os
 import numpy as np
 import pandas as pd
 from napistu import identifiers
+from napistu.constants import IDENTIFIERS, SBML_DFS
+import pytest
 
 # logger = logging.getLogger()
 # logger.setLevel("DEBUG")
@@ -139,6 +141,100 @@ def test_reciprocal_ensembl_dicts():
         )
 
 
+def test_df_to_identifiers_basic():
+    """Test basic conversion of DataFrame to Identifiers objects."""
+    # Create a simple test DataFrame
+    df = pd.DataFrame(
+        {
+            "s_id": ["s1", "s1", "s2"],
+            IDENTIFIERS.ONTOLOGY: ["ncbi_entrez_gene", "uniprot", "ncbi_entrez_gene"],
+            IDENTIFIERS.IDENTIFIER: ["123", "P12345", "456"],
+            IDENTIFIERS.URL: [
+                "http://ncbi/123",
+                "http://uniprot/P12345",
+                "http://ncbi/456",
+            ],
+            IDENTIFIERS.BQB: ["is", "is", "is"],
+        }
+    )
+
+    # Convert to Identifiers objects
+    result = identifiers.df_to_identifiers(df, SBML_DFS.SPECIES)
+
+    # Check basic properties
+    assert isinstance(result, pd.Series)
+    assert len(result) == 2  # Two unique s_ids
+    assert all(isinstance(x, identifiers.Identifiers) for x in result)
+
+    # Check specific values
+    s1_ids = result["s1"].ids
+    assert len(s1_ids) == 2  # Two identifiers for s1
+    assert any(x[IDENTIFIERS.IDENTIFIER] == "123" for x in s1_ids)
+    assert any(x[IDENTIFIERS.IDENTIFIER] == "P12345" for x in s1_ids)
+
+    s2_ids = result["s2"].ids
+    assert len(s2_ids) == 1  # One identifier for s2
+    assert s2_ids[0][IDENTIFIERS.IDENTIFIER] == "456"
+
+
+def test_df_to_identifiers_duplicates():
+    """Test that duplicates are handled correctly."""
+    # Create DataFrame with duplicate entries
+    df = pd.DataFrame(
+        {
+            "s_id": ["s1", "s1", "s1"],
+            IDENTIFIERS.ONTOLOGY: [
+                "ncbi_entrez_gene",
+                "ncbi_entrez_gene",
+                "ncbi_entrez_gene",
+            ],
+            IDENTIFIERS.IDENTIFIER: ["123", "123", "123"],  # Same identifier repeated
+            IDENTIFIERS.URL: ["http://ncbi/123"] * 3,
+            IDENTIFIERS.BQB: ["is"] * 3,
+        }
+    )
+
+    result = identifiers.df_to_identifiers(df, SBML_DFS.SPECIES)
+
+    # Should collapse duplicates
+    assert len(result) == 1  # One unique s_id
+    assert len(result["s1"].ids) == 1  # One unique identifier
+
+
+def test_df_to_identifiers_missing_columns():
+    """Test that missing required columns raise an error."""
+    # Create DataFrame missing required columns
+    df = pd.DataFrame(
+        {
+            "s_id": ["s1"],
+            IDENTIFIERS.ONTOLOGY: ["ncbi_entrez_gene"],
+            IDENTIFIERS.IDENTIFIER: ["123"],
+            # Missing URL and BQB
+        }
+    )
+
+    with pytest.raises(
+        ValueError, match="The DataFrame does not contain the required columns"
+    ):
+        identifiers.df_to_identifiers(df, SBML_DFS.SPECIES)
+
+
+def test_df_to_identifiers_invalid_entity_type():
+    """Test that invalid entity type raises an error."""
+    df = pd.DataFrame(
+        {
+            "s_id": ["s1"],
+            IDENTIFIERS.ONTOLOGY: ["ncbi_entrez_gene"],
+            IDENTIFIERS.IDENTIFIER: ["123"],
+            IDENTIFIERS.URL: ["http://ncbi/123"],
+            IDENTIFIERS.BQB: ["is"],
+        }
+    )
+
+    with pytest.raises(ValueError, match="Invalid entity type"):
+        identifiers.df_to_identifiers(df, "invalid_type")
+
+
 ################################################
 # __main__
 ################################################
@@ -149,3 +245,7 @@ if __name__ == "__main__":
     test_url_from_identifiers()
     test_parsing_ensembl_ids()
     test_reciprocal_ensembl_dicts()
+    test_df_to_identifiers_basic()
+    test_df_to_identifiers_duplicates()
+    test_df_to_identifiers_missing_columns()
+    test_df_to_identifiers_invalid_entity_type()

tests/test_indices.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import os
+import datetime
 
 import pandas as pd
 import pytest
@@ -10,6 +11,70 @@ test_path = os.path.abspath(os.path.join(__file__, os.pardir))
 test_data = os.path.join(test_path, "test_data")
 
 
+def test_create_pathway_index_df():
+    """Test the creation of pathway index DataFrame."""
+    # Test input data
+    model_keys = {"human": "model1", "mouse": "model2"}
+    model_urls = {
+        "human": "http://example.com/model1.xml",
+        "mouse": "http://example.com/model2.xml",
+    }
+    model_species = {"human": "Homo sapiens", "mouse": "Mus musculus"}
+    base_path = "/test/path"
+    source_name = "TestSource"
+
+    # Create pathway index
+    result = indices.create_pathway_index_df(
+        model_keys=model_keys,
+        model_urls=model_urls,
+        model_species=model_species,
+        base_path=base_path,
+        source_name=source_name,
+    )
+
+    # Expected date in YYYYMMDD format
+    expected_date = datetime.date.today().strftime("%Y%m%d")
+
+    # Assertions
+    assert isinstance(result, pd.DataFrame), "Result should be a pandas DataFrame"
+    assert len(result) == 2, "Should have 2 rows for 2 models"
+
+    # Check required columns exist
+    required_columns = {
+        "url",
+        "species",
+        "sbml_path",
+        "file",
+        "date",
+        "pathway_id",
+        "name",
+        "source",
+    }
+    assert set(result.columns) == required_columns, "Missing required columns"
+
+    # Check content for first model (human)
+    human_row = result[result["pathway_id"] == "model1"].iloc[0]
+    assert human_row["url"] == "http://example.com/model1.xml"
+    assert human_row["species"] == "Homo sapiens"
+    assert human_row["file"] == "model1.sbml"
+    assert human_row["date"] == expected_date
+    assert human_row["source"] == "TestSource"
+    assert human_row["sbml_path"] == os.path.join(base_path, "model1.sbml")
+
+    # Test with custom file extension
+    result_custom_ext = indices.create_pathway_index_df(
+        model_keys=model_keys,
+        model_urls=model_urls,
+        model_species=model_species,
+        base_path=base_path,
+        source_name=source_name,
+        file_extension=".xml",
+    )
+    assert result_custom_ext.iloc[0]["file"].endswith(
+        ".xml"
+    ), "Custom extension not applied"
+
+
 def test_pwindex_from_file():
     pw_index_path = os.path.join(test_data, "pw_index.tsv")
     pw_index = indices.PWIndex(pw_index_path)

tests/{test_edgelist.py → test_ingestion_napistu_edgelist.py}

@@ -1,13 +1,13 @@
 from __future__ import annotations
 
 import pandas as pd
-from napistu.ingestion import cpr_edgelist
+from napistu.ingestion import napistu_edgelist
 
 
 def test_edgelist_remove_reciprocal_reactions():
     edgelist = pd.DataFrame({"from": ["A", "B", "C", "D"], "to": ["B", "A", "D", "C"]})
 
-    nondegenerate_edgelist = cpr_edgelist.remove_reciprocal_interactions(edgelist)
+    nondegenerate_edgelist = napistu_edgelist.remove_reciprocal_interactions(edgelist)
 
     assert nondegenerate_edgelist.shape == (2, 2)
 

tests/test_matching_interactions.py

@@ -0,0 +1,108 @@
+import pandas as pd
+from napistu.network import net_create
+
+from napistu.network import precompute
+from napistu.matching.interactions import (
+    edgelist_to_pathway_species,
+    edgelist_to_scids,
+    filter_to_direct_mechanistic_interactions,
+    filter_to_indirect_mechanistic_interactions,
+)
+
+
+def test_edgelist_to_pathway_species(sbml_dfs):
+
+    edgelist = pd.DataFrame(
+        [
+            {"identifier_upstream": "17996", "identifier_downstream": "16526"},
+            {"identifier_upstream": "15377", "identifier_downstream": "17544"},
+            {"identifier_upstream": "15378", "identifier_downstream": "57945"},
+            {"identifier_upstream": "57540", "identifier_downstream": "17996"},
+        ]
+    )
+    species_identifiers = sbml_dfs.get_identifiers("species").query("bqb == 'BQB_IS'")
+
+    edgelist_w_sids = edgelist_to_pathway_species(
+        edgelist, species_identifiers, ontologies={"chebi", "uniprot"}
+    )
+    assert edgelist_w_sids.shape == (4, 4)
+
+    egelist_w_scids = edgelist_to_scids(
+        edgelist, sbml_dfs, species_identifiers, ontologies={"chebi"}
+    )
+
+    assert egelist_w_scids.shape == (12, 6)
+
+    direct_interactions = filter_to_direct_mechanistic_interactions(
+        edgelist, sbml_dfs, species_identifiers, ontologies={"chebi"}
+    )
+
+    assert direct_interactions.shape == (2, 10)
+
+
+def test_direct_and_indirect_mechanism_matching(sbml_dfs_glucose_metabolism):
+
+    napistu_graph = net_create.process_napistu_graph(sbml_dfs_glucose_metabolism)
+
+    edgelist = pd.DataFrame(
+        [
+            {
+                "identifier_upstream": "17925",
+                "identifier_downstream": "32966",
+            },  # glu, fbp
+            {
+                "identifier_upstream": "57634",
+                "identifier_downstream": "32966",
+            },  # f6p, fbp
+            {
+                "identifier_upstream": "32966",
+                "identifier_downstream": "57642",
+            },  # fbp, dhap
+            {
+                "identifier_upstream": "17925",
+                "identifier_downstream": "15361",
+            },  # glu, pyr
+        ]
+    )
+
+    species_identifiers = sbml_dfs_glucose_metabolism.get_identifiers("species")
+
+    direct_interactions = filter_to_direct_mechanistic_interactions(
+        formatted_edgelist=edgelist,
+        sbml_dfs=sbml_dfs_glucose_metabolism,
+        species_identifiers=species_identifiers,
+        ontologies={"chebi"},
+    )
+
+    assert direct_interactions.shape == (2, 10)
+
+    indirect_interactions = filter_to_indirect_mechanistic_interactions(
+        formatted_edgelist=edgelist,
+        sbml_dfs=sbml_dfs_glucose_metabolism,
+        species_identifiers=species_identifiers,
+        napistu_graph=napistu_graph,
+        ontologies={"chebi"},
+        precomputed_distances=None,
+        max_path_length=10,
+    )
+
+    assert indirect_interactions.shape == (6, 12)
+
+    # confirm that we get the same thing even when using precomputed distances
+    precomputed_distances = precompute.precompute_distances(
+        napistu_graph, weights_vars=["weights"]
+    )
+
+    indirect_interactions_w_precompute = filter_to_indirect_mechanistic_interactions(
+        formatted_edgelist=edgelist,
+        sbml_dfs=sbml_dfs_glucose_metabolism,
+        species_identifiers=species_identifiers,
+        napistu_graph=napistu_graph,
+        ontologies={"chebi"},
+        precomputed_distances=precomputed_distances,
+        max_path_length=10,
+    )
+
+    assert all(
+        indirect_interactions["weight"] == indirect_interactions_w_precompute["weight"]
+    )