napistu 0.1.0__py3-none-any.whl → 0.2.4.dev3__py3-none-any.whl

tests/conftest.py

@@ -61,23 +61,29 @@ def sbml_dfs_glucose_metabolism():
 def pytest_configure(config):
     config.addinivalue_line("markers", "skip_on_windows: mark test to skip on Windows")
     config.addinivalue_line("markers", "skip_on_macos: mark test to skip on macOS")
-    config.addinivalue_line("markers", "unix_only: mark test to run only on Unix/Linux systems")
+    config.addinivalue_line(
+        "markers", "unix_only: mark test to run only on Unix/Linux systems"
+    )
+
 
 # Define platform conditions
 is_windows = sys.platform == "win32"
 is_macos = sys.platform == "darwin"
 is_unix = not (is_windows or is_macos)
 
+
 # Apply skipping based on platform
 def pytest_runtest_setup(item):
     # Skip tests marked to be skipped on Windows
-    if is_windows and any(mark.name == "skip_on_windows" for mark in item.iter_markers()):
+    if is_windows and any(
+        mark.name == "skip_on_windows" for mark in item.iter_markers()
+    ):
         skip("Test skipped on Windows")
-    
+
     # Skip tests marked to be skipped on macOS
     if is_macos and any(mark.name == "skip_on_macos" for mark in item.iter_markers()):
         skip("Test skipped on macOS")
-    
+
     # Skip tests that should run only on Unix
     if not is_unix and any(mark.name == "unix_only" for mark in item.iter_markers()):
-        skip("Test runs only on Unix systems")
+        skip("Test runs only on Unix systems")

tests/test_consensus.py

@@ -140,6 +140,7 @@ def test_source_tracking():
 
 
 def test_passing_entity_data():
+
     pw_index = indices.PWIndex(os.path.join(test_data, "pw_index.tsv"))
     sbml_dfs_dict = consensus.construct_sbml_dfs_dict(pw_index)
 
@@ -187,7 +188,9 @@ def test_passing_entity_data():
     # in different models has a different value for its reactions_data
     minimal_pw_index = pw_index
     minimal_pw_index.index = minimal_pw_index.index.iloc[0:2]
-    minimal_pw_index.index["file"].loc[1] = minimal_pw_index.index["file"][0]
+
+    # Since we're working with a DataFrame, we can use loc to update the file value directly
+    minimal_pw_index.index.loc[1, "file"] = minimal_pw_index.index.loc[0, "file"]
 
     duplicated_sbml_dfs_dict = consensus.construct_sbml_dfs_dict(minimal_pw_index)
     # explicitely define the order we'll loop through models so that

tests/test_gaps.py

@@ -0,0 +1,127 @@
+import pandas as pd
+import numpy as np
+import warnings
+
+from napistu.sbml_dfs_core import SBML_dfs
+from napistu.constants import SBML_DFS
+from napistu.constants import MINI_SBO_FROM_NAME
+from napistu.identifiers import Identifiers
+
+from napistu.modify import gaps
+
+
+# Minimal compartments table
+def _create_sbml_dfs_missing_transport_rxns():
+
+    compartments = pd.DataFrame(
+        {
+            SBML_DFS.C_NAME: ["mitochondria", "nucleus", "cytosol"],
+            SBML_DFS.C_IDENTIFIERS: [None],
+            SBML_DFS.C_SOURCE: [None],
+        },
+        index=["c_mito", "c_nucl", "c_cytosol"],
+    ).rename_axis(SBML_DFS.C_ID)
+
+    # Minimal species table
+    species = pd.DataFrame(
+        {
+            SBML_DFS.S_NAME: ["A"],
+            SBML_DFS.S_IDENTIFIERS: [
+                Identifiers(
+                    [
+                        {
+                            "ontology": "uniprot",
+                            "identifier": "PFAKE1",
+                            "bqb": "BQB_IS",
+                            "url": None,
+                        }
+                    ]
+                )
+            ],
+            SBML_DFS.S_SOURCE: [None],
+        },
+        index=["s_A"],
+    ).rename_axis(SBML_DFS.S_ID)
+
+    # Minimal compartmentalized_species table
+    compartmentalized_species = pd.DataFrame(
+        {
+            SBML_DFS.SC_NAME: ["A [mitochondria]", "A [nucleus]"],
+            SBML_DFS.S_ID: ["s_A", "s_A"],
+            SBML_DFS.C_ID: ["c_mito", "c_nucl"],
+            SBML_DFS.SC_SOURCE: [None],
+        },
+        index=["sc_A_mito", "sc_A_nucl"],
+    ).rename_axis(SBML_DFS.SC_ID)
+
+    # Minimal reactions table
+    reactions = pd.DataFrame(
+        {
+            SBML_DFS.R_NAME: ["A [mito] -> A [mito]", "A [nucl] -> A [nucl]"],
+            SBML_DFS.R_IDENTIFIERS: [None],
+            SBML_DFS.R_SOURCE: [None],
+            SBML_DFS.R_ISREVERSIBLE: [True, True],
+        },
+        index=["r_A_mito", "r_A_nucl"],
+    ).rename_axis(SBML_DFS.R_ID)
+
+    # Minimal reaction_species table
+    reaction_species = pd.DataFrame(
+        {
+            SBML_DFS.R_ID: ["r_A_mito", "r_A_mito", "r_A_nucl", "r_A_nucl"],
+            SBML_DFS.SC_ID: ["sc_A_mito", "sc_A_mito", "sc_A_nucl", "sc_A_nucl"],
+            SBML_DFS.STOICHIOMETRY: [-1, 1, -1, 1],
+            SBML_DFS.SBO_TERM: [
+                MINI_SBO_FROM_NAME["reactant"],
+                MINI_SBO_FROM_NAME["product"],
+                MINI_SBO_FROM_NAME["reactant"],
+                MINI_SBO_FROM_NAME["product"],
+            ],
+        },
+        index=[
+            "rsc_A_mito_sub",
+            "rsc_A_mito_prod",
+            "rsc_A_nucl_sub",
+            "rsc_A_nucl_prod",
+        ],
+    ).rename_axis(SBML_DFS.RSC_ID)
+
+    # Assemble the dict
+    sbml_dict = {
+        SBML_DFS.COMPARTMENTS: compartments,
+        SBML_DFS.SPECIES: species,
+        SBML_DFS.COMPARTMENTALIZED_SPECIES: compartmentalized_species,
+        SBML_DFS.REACTIONS: reactions,
+        SBML_DFS.REACTION_SPECIES: reaction_species,
+    }
+
+    # Create the SBML_dfs object
+    sbml_dfs = SBML_dfs(sbml_dict)
+
+    return sbml_dfs
+
+
+def test_add_transportation_reactions():
+
+    sbml_dfs = _create_sbml_dfs_missing_transport_rxns()
+    sbml_dfs_w_transport = gaps.update_sbml_df_with_exchange(
+        np.array(["s_A"]), sbml_dfs, exchange_compartment="cytosol"
+    )
+    assert sbml_dfs_w_transport.reactions.shape[0] == 4, "Should add 2 reactions"
+    assert sbml_dfs_w_transport.reactions[
+        SBML_DFS.R_ISREVERSIBLE
+    ].all(), "Should be reversible"
+
+
+def test_identify_species_needing_transport_reactions(sbml_dfs):
+    result = gaps._identify_species_needing_transport_reactions(sbml_dfs)
+    assert isinstance(result, np.ndarray)
+    assert result.size == 0
+
+    sbml_dfs = _create_sbml_dfs_missing_transport_rxns()
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", RuntimeWarning)
+        result = gaps._identify_species_needing_transport_reactions(sbml_dfs)
+    assert isinstance(result, np.ndarray)
+    assert result.size == 1
+    assert result[0] == "s_A"

tests/test_gcs.py

@@ -4,12 +4,13 @@ import os
 import pytest
 import shutil
 
-from napistu.gcs.downloads import load_public_cpr_asset
+from napistu.gcs.downloads import load_public_napistu_asset
+
 
 @pytest.mark.skip_on_windows
 def test_download_and_load_gcs_asset():
 
-    local_path = load_public_cpr_asset(
+    local_path = load_public_napistu_asset(
         asset="test_pathway", subasset="sbml_dfs", data_dir="/tmp"
     )
 

tests/test_igraph.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import os
+import pytest
 
 import pandas as pd
 from napistu import sbml_dfs_core
@@ -109,10 +110,23 @@ def test_create_cpr_graph():
     _ = net_create.create_cpr_graph(sbml_dfs, graph_type="surrogate")
 
 
+def test_create_cpr_graph_none_attrs():
+    # Should not raise when reaction_graph_attrs is None
+    _ = net_create.create_cpr_graph(
+        sbml_dfs, reaction_graph_attrs=None, graph_type="bipartite"
+    )
+
+
 def test_igraph_construction():
     _ = net_create.process_cpr_graph(sbml_dfs)
 
 
+def test_process_cpr_graph_none_attrs():
+    # Should not raise when reaction_graph_attrs is None
+    _ = net_create.process_cpr_graph(sbml_dfs, reaction_graph_attrs=None)
+
+
+@pytest.mark.skip_on_windows
 def test_igraph_loading():
     # test read/write of an igraph network
     directeds = [True, False]

tests/test_mcp_documentation_utils.py

@@ -0,0 +1,13 @@
+import pytest
+from napistu.mcp.documentation_utils import load_readme_content
+from napistu.mcp.constants import READMES
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("name,url", READMES.items())
+async def test_load_readme_content(name, url):
+    content = await load_readme_content(url)
+    assert isinstance(content, str)
+    assert len(content) > 0
+    # Optionally, check for a keyword in the content
+    assert "napistu" in content.lower() or "Napistu" in content