napistu 0.4.5__py3-none-any.whl → 0.4.7__py3-none-any.whl

napistu/network/ng_utils.py

@@ -23,7 +23,7 @@ from napistu.constants import SBML_DFS
 from napistu.constants import SOURCE_SPEC
 from napistu.identifiers import _validate_assets_sbml_ids
 from napistu.network.constants import GRAPH_WIRING_APPROACHES
-from napistu.network.constants import NAPISTU_GRAPH_DIRECTEDNESS
+from napistu.network.constants import GRAPH_DIRECTEDNESS
 
 logger = logging.getLogger(__name__)
 
@@ -133,8 +133,8 @@ def get_minimal_sources_edges(
 
     Returns
     -------
-    edge_sources: pd.DataFrame
-        A table of edges and the sources they are assigned to.
+    reaction_sources: pd.DataFrame
+        A table of reactions and the sources they are assigned to.
     """
 
     nodes = vertices["node"].tolist()
@@ -148,10 +148,10 @@ def get_minimal_sources_edges(
     if source_df is None:
         return None
     else:
-        edge_sources = source.source_set_coverage(
+        reaction_sources = source.source_set_coverage(
             source_df, source_total_counts, sbml_dfs, min_pw_size=min_pw_size
         )
-        return edge_sources.reset_index()[
+        return reaction_sources.reset_index()[
             [SBML_DFS.R_ID, SOURCE_SPEC.PATHWAY_ID, SOURCE_SPEC.NAME]
         ]
 
@@ -406,9 +406,9 @@ def _create_network_save_string(
     model_prefix: str, outdir: str, directed: bool, wiring_approach: str
 ) -> str:
     if directed:
-        directed_str = NAPISTU_GRAPH_DIRECTEDNESS.DIRECTED
+        directed_str = GRAPH_DIRECTEDNESS.DIRECTED
     else:
-        directed_str = NAPISTU_GRAPH_DIRECTEDNESS.UNDIRECTED
+        directed_str = GRAPH_DIRECTEDNESS.UNDIRECTED
 
     export_pkl_path = os.path.join(
         outdir,

napistu/network/paths.py

@@ -11,13 +11,19 @@ from napistu import sbml_dfs_core
 from napistu import utils
 from napistu.network.ng_core import NapistuGraph
 from napistu.network.ng_utils import get_minimal_sources_edges
-from napistu.constants import NAPISTU_PATH_REQ_VARS
-from napistu.constants import MINI_SBO_NAME_TO_POLARITY
-from napistu.constants import MINI_SBO_TO_NAME
-from napistu.constants import SBML_DFS
-from napistu.network.constants import NET_POLARITY
-from napistu.network.constants import NAPISTU_GRAPH_EDGES
-from napistu.network.constants import VALID_LINK_POLARITIES
+from napistu.constants import (
+    MINI_SBO_NAME_TO_POLARITY,
+    MINI_SBO_TO_NAME,
+    NAPISTU_EDGELIST,
+    NAPISTU_PATH_REQ_VARS,
+    SBML_DFS,
+)
+from napistu.network.constants import (
+    NAPISTU_GRAPH_EDGES,
+    NAPISTU_GRAPH_VERTICES,
+    NET_POLARITY,
+    VALID_LINK_POLARITIES,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -273,8 +279,8 @@ def find_all_shortest_reaction_paths(
         Nodes in all shortest paths
     all_shortest_reaction_path_edges_df : pd.DataFrame
         Edges in all shortest paths
-    edge_sources : pd.DataFrame
-        Sources of edge identifying the models where they originated
+    reaction_sources : pd.DataFrame
+        Sources of reactions identifying the models where they originated
     paths_graph : igraph.Graph
         Network formed by all shortest paths
     """
@@ -297,8 +303,8 @@ def find_all_shortest_reaction_paths(
         paths = find_shortest_reaction_paths(
             napistu_graph,
             sbml_dfs,
-            origin=one_search["sc_id_origin"],
-            dest=one_search["sc_id_dest"],
+            origin=one_search[NAPISTU_EDGELIST.SC_ID_ORIGIN],
+            dest=one_search[NAPISTU_EDGELIST.SC_ID_DEST],
             weight_var=weight_var,
         )
 
@@ -309,12 +315,14 @@ def find_all_shortest_reaction_paths(
 
         all_shortest_reaction_paths.append(
             shortest_paths_df.assign(
-                origin=one_search["sc_id_origin"], dest=one_search["sc_id_dest"]
+                origin=one_search[NAPISTU_EDGELIST.SC_ID_ORIGIN],
+                dest=one_search[NAPISTU_EDGELIST.SC_ID_DEST],
             )
         )
         all_shortest_reaction_path_edges.append(
             shortest_path_edges_df.assign(
-                origin=one_search["sc_id_origin"], dest=one_search["sc_id_dest"]
+                origin=one_search[NAPISTU_EDGELIST.SC_ID_ORIGIN],
+                dest=one_search[NAPISTU_EDGELIST.SC_ID_DEST],
             )
         )
 
@@ -332,7 +340,7 @@ def find_all_shortest_reaction_paths(
     ).reset_index()
 
     # at a minimal set of pathway sources to organize reactions
-    edge_sources = get_minimal_sources_edges(
+    reaction_sources = get_minimal_sources_edges(
         all_shortest_reaction_paths_df,
         sbml_dfs,
         min_pw_size=min_pw_size,
@@ -353,13 +361,13 @@ def find_all_shortest_reaction_paths(
         edges=all_shortest_reaction_path_edges_df.to_dict("records"),
         directed=directed,
         vertex_name_attr="node",
-        edge_foreign_keys=("from", "to"),
+        edge_foreign_keys=(NAPISTU_GRAPH_EDGES.FROM, NAPISTU_GRAPH_EDGES.TO),
     )
 
     return (
         all_shortest_reaction_paths_df,
         all_shortest_reaction_path_edges_df,
-        edge_sources,
+        reaction_sources,
         paths_graph,
     )
 
@@ -387,9 +395,11 @@ def plot_shortest_paths(napistu_graph: NapistuGraph) -> NapistuGraph.plot:
     visual_style["vertex_label_size"] = 8
     visual_style["vertex_label_angle"] = 90
     visual_style["vertex_color"] = [
-        color_dict[x] for x in napistu_graph.vs["node_type"]
+        color_dict[x] for x in napistu_graph.vs[NAPISTU_GRAPH_VERTICES.NODE_TYPE]
+    ]
+    visual_style["edge_width"] = [
+        math.sqrt(x) for x in napistu_graph.es[NAPISTU_GRAPH_EDGES.WEIGHTS]
     ]
-    visual_style["edge_width"] = [math.sqrt(x) for x in napistu_graph.es["weights"]]
     visual_style["edge_color"] = "dimgray"
     visual_style["layout"] = paths_graph_layout
     visual_style["bbox"] = (2000, 2000)

{napistu-0.4.5.dist-info → napistu-0.4.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: napistu
-Version: 0.4.5
+Version: 0.4.7
 Summary: Connecting high-dimensional data to curated pathways
 Home-page: https://github.com/napistu/napistu-py
 Author: Sean Hackett

{napistu-0.4.5.dist-info → napistu-0.4.7.dist-info}/RECORD

@@ -59,16 +59,16 @@ napistu/modify/gaps.py,sha256=CV-bdSfanhrnCIFVWfNuQJbtjvj4hsEwheKYR-Z3tNA,26844
 napistu/modify/pathwayannot.py,sha256=xuBSMDFWbg_d6-Gzv0Td3Q5nnFTa-Qzic48g1b1AZtQ,48081
 napistu/modify/uncompartmentalize.py,sha256=y5LkXn5x6u80dB_McfAIh88BxZGIAVFLujkP7sPNRh0,9690
 napistu/network/__init__.py,sha256=dFXAhIqlTLJMwowS4BUDT08-Vy3Q0u1L0CMCErSZT1Y,239
-napistu/network/constants.py,sha256=nG_lUZYLgop8oxOGjDYqvxXJzVdOwKZ3aWnxlhtSaIo,6915
+napistu/network/constants.py,sha256=zQkBTeZ2_K_rId6IUvKKTv9chx_i6K5B8vPZ19-LkNQ,7782
 napistu/network/data_handling.py,sha256=KncrAKjXI3169BgVE-SnY8FkpVF60JnUwfMHtbqvsTc,14725
 napistu/network/ig_utils.py,sha256=MuyEyOVtSHndil6QuuRCimBZrJ2jTaF5qQESgYlu02M,17042
-napistu/network/neighborhoods.py,sha256=hi8FT5sGd1vtkR5Uu10wr0Ik5Z3fz9e5fhvXqfi7QPQ,57340
+napistu/network/neighborhoods.py,sha256=RNqaz91MTxuU4jNfrGdEcnm6rCykgdtHDPu2abAE-Kg,65516
 napistu/network/net_create.py,sha256=66kV_xoWnu4BVLaJZ1TAC7wBSsjPDqjoAXH-X9ShV3s,59091
 napistu/network/net_create_utils.py,sha256=zajwaz2xAij_9fEnD77SgBw_EnNAnJ8jBCmmK2rk_bA,24672
 napistu/network/net_propagation.py,sha256=Il5nDOWh3nLz8gRhDFHGp2LxcvJ9C1twiSZjDeiZMUo,23490
 napistu/network/ng_core.py,sha256=dGnTUKR4WtnvaYMyIHqqF55FY4mJSa7wjA2LZ4cVB6U,11720
-napistu/network/ng_utils.py,sha256=DkI_Ln2uFiNDjPEnUnf7kyy6XwyqvpeUkk8DRjTGZQQ,16078
-napistu/network/paths.py,sha256=BcoYNkCplaM_QPqWWfiwD89bsvwlyvvacSiEzHacfmA,17863
+napistu/network/ng_utils.py,sha256=LX9DzMnz0AQMhJGUh3r8bg4dyEgWs_tym1Olu1FwlbQ,16070
+napistu/network/paths.py,sha256=ZnIqwBIsgz4C4TLyg3c_pCO5zZ97gmCNepDmq2QNEQc,18020
 napistu/network/precompute.py,sha256=ARU2tktWnxFISaHAY8chpkg8pusZPv7TT5jSIB9eFF0,10081
 napistu/ontologies/__init__.py,sha256=dFXAhIqlTLJMwowS4BUDT08-Vy3Q0u1L0CMCErSZT1Y,239
 napistu/ontologies/constants.py,sha256=GyOFvezSxDK1VigATcruTKtNhjcYaid1ggulEf_HEtQ,4345
@@ -87,7 +87,7 @@ napistu/scverse/loading.py,sha256=jqiE71XB-wdV50GyZrauFNY0Lai4bX9Fm2Gv80VR8t8,27
 napistu/statistics/__init__.py,sha256=dFXAhIqlTLJMwowS4BUDT08-Vy3Q0u1L0CMCErSZT1Y,239
 napistu/statistics/hypothesis_testing.py,sha256=k0mBFAMF0XHVcKwS26aPnEbq_FIUVwXU1gZ6cKfFbCk,2190
 napistu/statistics/quantiles.py,sha256=1-LnmVzC2CQWxCKUh0yi6YfKrbsZM1-kkD7nu2-aS5s,3042
-napistu-0.4.5.dist-info/licenses/LICENSE,sha256=kW8wVT__JWoHjl2BbbJDAZInWa9AxzJeR_uv6-i5x1g,1063
+napistu-0.4.7.dist-info/licenses/LICENSE,sha256=kW8wVT__JWoHjl2BbbJDAZInWa9AxzJeR_uv6-i5x1g,1063
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/conftest.py,sha256=Rw0KtnVyykZhRjnlmNu4oV47lNIeYUJVHu4y47RnVq0,9990
 tests/test_consensus.py,sha256=Hzfrgp4SpkRDnEMVMD3f0UInSycndB8kKzC4wDDvRas,15076
@@ -109,14 +109,14 @@ tests/test_mcp_documentation_utils.py,sha256=OW0N2N_2IOktbYTcCWhhWz4bANi8IB60l1q
 tests/test_mcp_server.py,sha256=bP3PWVQsEfX6-lAgXKP32njdg__o65n2WuLvkxTTHkQ,11215
 tests/test_network_data_handling.py,sha256=4aS8z2AlKkVd-JhK4BQ8fjeiW8_bJ1hZ3cc71Jh7Glk,12716
 tests/test_network_ig_utils.py,sha256=XihmEpX890sr-LYmsb_t4aN0sKIDWCnXkTpDhpuTDmw,7199
-tests/test_network_neighborhoods.py,sha256=OvVfgGodbS3MpuSfj-__VKjBj99Ng4WWLmINlIIvbvo,5100
+tests/test_network_neighborhoods.py,sha256=3k0d-Pk_rWtGwxTg-Jpjv3CsVSj4qMn71MEHEKcqHII,8746
 tests/test_network_net_create.py,sha256=L0U91b4jVHDuC3DFo-_BUFVuv4GuSxZuLAo7r-7EJxY,12877
 tests/test_network_net_create_utils.py,sha256=0J6KIh2HBc4koFsvwMaul1QRtj5x92kR9HBdDZajnAw,18971
 tests/test_network_net_propagation.py,sha256=kZeDHD93iMrLVvxO4OyfRH5_vgsYeQyC40OI9Dsb0xY,14999
 tests/test_network_ng_core.py,sha256=w-iNBTtenennJhaLFauk952pEsk7W0-Fa8lPvIRqHyY,628
 tests/test_network_ng_utils.py,sha256=QVVuRnvCRfTSIlGdwQTIF9lr0wOwoc5gGeXAUY_AdgE,713
-tests/test_network_paths.py,sha256=TWZnxY5bF3m6gahcxcYJGrBIawh2-_vUcec1LyPmXV8,1686
-tests/test_network_precompute.py,sha256=IPr1KhtxBD0fXx_2TvZqnevrD-Iig35otb8yloRFpRc,10014
+tests/test_network_paths.py,sha256=Bx1uqyIAPw_i27s94dyjCQcV_04O9yovlrQgr1lFjS4,2143
+tests/test_network_precompute.py,sha256=MhmT6LQF-JcMR9YR78W-cLHbkQnp8ro-MHJ5yvMVhJE,10409
 tests/test_ontologies_genodexito.py,sha256=6fINyUiubHZqu7qxye09DQfJXw28ZMAJc3clPb-cCoY,2298
 tests/test_ontologies_id_tables.py,sha256=CpwpbmQvTc1BaVd6jbDKHAVE2etwN0vx93nC8jpnMlE,7265
 tests/test_ontologies_mygene.py,sha256=VkdRcKIWmcG6V-2dpfvsBiOJN5dO-j0RqZNxtJRcyBU,1583
@@ -136,8 +136,8 @@ tests/test_uncompartmentalize.py,sha256=nAk5kfAVLU9a2VWe2x2HYVcKqj-EnwmwddERIPRa
 tests/test_utils.py,sha256=qPSpV-Q9b6vmdycgaDmQqtcvzKnAVnN9j5xJ9x-T6bg,23959
 tests/utils.py,sha256=SoWQ_5roJteFGcMaOeEiQ5ucwq3Z2Fa3AAs9iXHTsJY,749
 tests/test_data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-napistu-0.4.5.dist-info/METADATA,sha256=JJzjckSlzdusT7COjo-FxaNRBGMWtfJc-kfUDvjyvW4,4078
-napistu-0.4.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-napistu-0.4.5.dist-info/entry_points.txt,sha256=_QnaPOvJNA3IltxmZgWIiBoen-L1bPYX18YQfC7oJgQ,41
-napistu-0.4.5.dist-info/top_level.txt,sha256=Gpvk0a_PjrtqhYcQ9IDr3zR5LqpZ-uIHidQMIpjlvhY,14
-napistu-0.4.5.dist-info/RECORD,,
+napistu-0.4.7.dist-info/METADATA,sha256=PgIDsBflFe6QmORKY6hfoEI9_Qqrpwa7Oc9126D47jc,4078
+napistu-0.4.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+napistu-0.4.7.dist-info/entry_points.txt,sha256=_QnaPOvJNA3IltxmZgWIiBoen-L1bPYX18YQfC7oJgQ,41
+napistu-0.4.7.dist-info/top_level.txt,sha256=Gpvk0a_PjrtqhYcQ9IDr3zR5LqpZ-uIHidQMIpjlvhY,14
+napistu-0.4.7.dist-info/RECORD,,

tests/test_network_neighborhoods.py

@@ -1,11 +1,17 @@
 import pandas as pd
+import pytest
 
 from napistu.network import ng_utils
 from napistu.network import neighborhoods
 from napistu import source
 
 from napistu.constants import SBML_DFS
-from napistu.network.constants import NEIGHBORHOOD_NETWORK_TYPES
+from napistu.network.constants import (
+    NAPISTU_GRAPH_VERTICES,
+    NAPISTU_GRAPH_NODE_TYPES,
+    NEIGHBORHOOD_DICT_KEYS,
+    NEIGHBORHOOD_NETWORK_TYPES,
+)
 
 
 def test_neighborhood(sbml_dfs, napistu_graph):
@@ -22,7 +28,7 @@ def test_neighborhood(sbml_dfs, napistu_graph):
         order=3,
     )
 
-    assert neighborhood["species_73473"]["vertices"].shape[0] == 6
+    assert neighborhood["species_73473"][NEIGHBORHOOD_DICT_KEYS.VERTICES].shape[0] == 6
 
 
 def test_find_and_prune_neighborhoods_with_source_counts(
@@ -32,7 +38,7 @@ def test_find_and_prune_neighborhoods_with_source_counts(
     Test find_and_prune_neighborhoods function with source_total_counts parameter.
 
     This test verifies that the function works correctly when source_total_counts
-    is provided, which enables source-based edge assignment in neighborhoods.
+    is provided, which enables source-based reaction assignment in neighborhoods.
     """
     # Create source_total_counts using the source module
     source_total_counts = source.get_source_total_counts(
@@ -59,6 +65,7 @@ def test_find_and_prune_neighborhoods_with_source_counts(
         sbml_dfs=sbml_dfs_metabolism,
         napistu_graph=napistu_graph_metabolism,
         compartmentalized_species=compartmentalized_species,
+        min_pw_size=1,
         source_total_counts=source_total_counts,
         network_type=NEIGHBORHOOD_NETWORK_TYPES.HOURGLASS,
         order=3,
@@ -73,34 +80,39 @@ def test_find_and_prune_neighborhoods_with_source_counts(
     # Check each neighborhood has the expected structure
     for sc_id, neighborhood in neighborhoods_result.items():
         assert isinstance(neighborhood, dict)
-        assert "graph" in neighborhood
-        assert "vertices" in neighborhood
-        assert "edges" in neighborhood
-        assert "edge_sources" in neighborhood
+        assert NEIGHBORHOOD_DICT_KEYS.GRAPH in neighborhood
+        assert NEIGHBORHOOD_DICT_KEYS.VERTICES in neighborhood
+        assert NEIGHBORHOOD_DICT_KEYS.EDGES in neighborhood
+        assert NEIGHBORHOOD_DICT_KEYS.REACTION_SOURCES in neighborhood
 
-        # Verify edge_sources is populated when source_total_counts is provided
+        # Verify reaction_sources is populated when source_total_counts is provided
         # (this is the key difference when source_total_counts is passed)
-        if neighborhood["edges"].shape[0] > 0:
-            # If there are edges, edge_sources should be populated
-            assert neighborhood["edge_sources"] is not None
-            assert isinstance(neighborhood["edge_sources"], pd.DataFrame)
-
-            # Check edge_sources has expected columns
+        if neighborhood[NEIGHBORHOOD_DICT_KEYS.EDGES].shape[0] > 0:
+            # If there are edges, reaction_sources should be populated
+            assert neighborhood[NEIGHBORHOOD_DICT_KEYS.REACTION_SOURCES] is not None
+            assert isinstance(
+                neighborhood[NEIGHBORHOOD_DICT_KEYS.REACTION_SOURCES], pd.DataFrame
+            )
+            assert neighborhood[NEIGHBORHOOD_DICT_KEYS.REACTION_SOURCES].shape[0] > 0
+
+            # Check reaction_sources has expected columns
             expected_columns = [SBML_DFS.R_ID, "pathway_id", "name"]
             for col in expected_columns:
-                assert col in neighborhood["edge_sources"].columns
+                assert (
+                    col in neighborhood[NEIGHBORHOOD_DICT_KEYS.REACTION_SOURCES].columns
+                )
 
         # Verify vertices structure
-        vertices = neighborhood["vertices"]
+        vertices = neighborhood[NEIGHBORHOOD_DICT_KEYS.VERTICES]
         assert isinstance(vertices, pd.DataFrame)
         assert vertices.shape[0] > 0
 
         # Verify edges structure
-        edges = neighborhood["edges"]
+        edges = neighborhood[NEIGHBORHOOD_DICT_KEYS.EDGES]
         assert isinstance(edges, pd.DataFrame)
 
         # Verify graph structure
-        graph = neighborhood["graph"]
+        graph = neighborhood[NEIGHBORHOOD_DICT_KEYS.GRAPH]
         assert hasattr(graph, "vcount")
         assert hasattr(graph, "ecount")
 
@@ -110,6 +122,7 @@ def test_find_and_prune_neighborhoods_with_source_counts(
         napistu_graph=napistu_graph_metabolism,
         compartmentalized_species=compartmentalized_species,
         source_total_counts=None,  # No source counts
+        min_pw_size=1,
         network_type=NEIGHBORHOOD_NETWORK_TYPES.DOWNSTREAM,
         order=3,
         verbose=False,
@@ -119,13 +132,99 @@ def test_find_and_prune_neighborhoods_with_source_counts(
     # Verify both results have the same basic structure
     assert len(neighborhoods_result) == len(neighborhoods_result_no_source)
 
-    # The main difference should be in edge_sources handling
+    # The main difference should be in reaction_sources handling
     for sc_id in neighborhoods_result:
-        with_source = neighborhoods_result[sc_id]["edge_sources"]
-        without_source = neighborhoods_result_no_source[sc_id]["edge_sources"]
+        with_source = neighborhoods_result[sc_id][
+            NEIGHBORHOOD_DICT_KEYS.REACTION_SOURCES
+        ]
+        without_source = neighborhoods_result_no_source[sc_id][
+            NEIGHBORHOOD_DICT_KEYS.REACTION_SOURCES
+        ]
 
         # Both should either be None or DataFrames, but the content may differ
         assert (with_source is None) == (without_source is None)
         if with_source is not None and without_source is not None:
             assert isinstance(with_source, pd.DataFrame)
             assert isinstance(without_source, pd.DataFrame)
+
+    # Test error handling for invalid parameters
+    # Test invalid network_type
+    with pytest.raises(ValueError):
+        neighborhoods.find_and_prune_neighborhoods(
+            sbml_dfs=sbml_dfs_metabolism,
+            napistu_graph=napistu_graph_metabolism,
+            compartmentalized_species=compartmentalized_species,
+            source_total_counts=source_total_counts,
+            min_pw_size=1,
+            network_type="invalid_network_type",
+            order=3,
+            verbose=False,
+            top_n=10,
+        )
+
+    # Test invalid order (negative)
+    with pytest.raises(ValueError):
+        neighborhoods.find_and_prune_neighborhoods(
+            sbml_dfs=sbml_dfs_metabolism,
+            napistu_graph=napistu_graph_metabolism,
+            compartmentalized_species=compartmentalized_species,
+            source_total_counts=source_total_counts,
+            min_pw_size=1,
+            network_type=NEIGHBORHOOD_NETWORK_TYPES.HOURGLASS,
+            order=-1,
+            verbose=False,
+            top_n=10,
+        )
+
+
+def test_add_vertices_uri_urls(sbml_dfs):
+    """
+    Test add_vertices_uri_urls function.
+
+    This test verifies that the function correctly adds URI URLs to vertices
+    DataFrame for both species and reactions.
+    """
+
+    # Get real species and reaction names from the sbml_dfs fixture
+    real_species = sbml_dfs.compartmentalized_species.index[0]  # Get first species
+    real_reaction = sbml_dfs.reactions.index[0]  # Get first reaction
+
+    # Create a test vertices DataFrame with real species and reactions
+    test_vertices = pd.DataFrame(
+        {
+            NAPISTU_GRAPH_VERTICES.NAME: [real_species, real_reaction],
+            NAPISTU_GRAPH_VERTICES.NODE_TYPE: [
+                NAPISTU_GRAPH_NODE_TYPES.SPECIES,
+                NAPISTU_GRAPH_NODE_TYPES.REACTION,
+            ],
+        }
+    )
+
+    # Test basic functionality
+    result = neighborhoods.add_vertices_uri_urls(test_vertices, sbml_dfs)
+
+    # Verify basic structure
+    assert isinstance(result, pd.DataFrame)
+    assert result.shape[0] == test_vertices.shape[0]  # Same number of rows
+    assert result.shape[1] >= test_vertices.shape[1]  # At least same number of columns
+
+    # Verify original columns are preserved
+    for col in test_vertices.columns:
+        assert col in result.columns
+        assert all(result[col] == test_vertices[col])
+
+    # Verify species vertices have s_id column
+    species_vertices = result[
+        result[NAPISTU_GRAPH_VERTICES.NODE_TYPE] == NAPISTU_GRAPH_NODE_TYPES.SPECIES
+    ]
+    assert SBML_DFS.S_ID in species_vertices.columns
+
+    # Test error handling
+    import pytest
+
+    # Test with empty DataFrame
+    empty_vertices = pd.DataFrame(
+        columns=[NAPISTU_GRAPH_VERTICES.NAME, NAPISTU_GRAPH_VERTICES.NODE_TYPE]
+    )
+    with pytest.raises(ValueError, match="vertices must have at least one row"):
+        neighborhoods.add_vertices_uri_urls(empty_vertices, sbml_dfs)

tests/test_network_paths.py

@@ -2,12 +2,17 @@ import pandas as pd
 
 from napistu.network import paths
 from napistu.network import ng_utils
+from napistu.constants import SBML_DFS
+from napistu.network.constants import (
+    NAPISTU_GRAPH_EDGES,
+    NET_POLARITY,
+)
 
 
 def test_shortest_paths(sbml_dfs, napistu_graph, napistu_graph_undirected):
     species = sbml_dfs.species
-    source_species = species[species["s_name"] == "NADH"]
-    dest_species = species[species["s_name"] == "NAD+"]
+    source_species = species[species[SBML_DFS.S_NAME] == "NADH"]
+    dest_species = species[species[SBML_DFS.S_NAME] == "NAD+"]
     target_species_paths = ng_utils.compartmentalize_species_pairs(
         sbml_dfs, source_species.index.tolist(), dest_species.index.tolist()
     )
@@ -18,17 +23,23 @@ def test_shortest_paths(sbml_dfs, napistu_graph, napistu_graph_undirected):
         _,
         _,
     ) = paths.find_all_shortest_reaction_paths(
-        napistu_graph, sbml_dfs, target_species_paths, weight_var="weights"
+        napistu_graph,
+        sbml_dfs,
+        target_species_paths,
+        weight_var=NAPISTU_GRAPH_EDGES.WEIGHTS,
     )
 
     # undirected graph
     (
         all_shortest_reaction_paths_df,
-        all_shortest_reaction_path_edges_df,
-        edge_sources,
-        paths_graph,
+        _,
+        _,
+        _,
     ) = paths.find_all_shortest_reaction_paths(
-        napistu_graph_undirected, sbml_dfs, target_species_paths, weight_var="weights"
+        napistu_graph_undirected,
+        sbml_dfs,
+        target_species_paths,
+        weight_var=NAPISTU_GRAPH_EDGES.WEIGHTS,
     )
 
     assert all_shortest_reaction_paths_df.shape[0] == 3
@@ -36,21 +47,34 @@ def test_shortest_paths(sbml_dfs, napistu_graph, napistu_graph_undirected):
 
 def test_net_polarity():
     polarity_series = pd.Series(
-        ["ambiguous", "ambiguous"], index=[0, 1], name="link_polarity"
+        [NET_POLARITY.AMBIGUOUS, NET_POLARITY.AMBIGUOUS],
+        index=[0, 1],
+        name=NET_POLARITY.LINK_POLARITY,
     )
     assert all(
-        [x == "ambiguous" for x in paths._calculate_net_polarity(polarity_series)]
+        [
+            x == NET_POLARITY.AMBIGUOUS
+            for x in paths._calculate_net_polarity(polarity_series)
+        ]
     )
 
     polarity_series = pd.Series(
-        ["activation", "inhibition", "inhibition", "ambiguous"],
+        [
+            NET_POLARITY.ACTIVATION,
+            NET_POLARITY.INHIBITION,
+            NET_POLARITY.INHIBITION,
+            NET_POLARITY.AMBIGUOUS,
+        ],
         index=range(0, 4),
-        name="link_polarity",
+        name=NET_POLARITY.LINK_POLARITY,
     )
     assert paths._calculate_net_polarity(polarity_series) == [
-        "activation",
-        "inhibition",
-        "activation",
-        "ambiguous activation",
+        NET_POLARITY.ACTIVATION,
+        NET_POLARITY.INHIBITION,
+        NET_POLARITY.ACTIVATION,
+        NET_POLARITY.AMBIGUOUS_ACTIVATION,
     ]
-    assert paths._terminal_net_polarity(polarity_series) == "ambiguous activation"
+    assert (
+        paths._terminal_net_polarity(polarity_series)
+        == NET_POLARITY.AMBIGUOUS_ACTIVATION
+    )

tests/test_network_precompute.py

@@ -14,6 +14,12 @@ from napistu.network import net_create
 from napistu.network import paths
 from napistu.network import precompute
 
+from napistu.network.constants import (
+    NAPISTU_GRAPH_VERTICES,
+    DISTANCES,
+    NEIGHBORHOOD_NETWORK_TYPES,
+)
+
 test_path = os.path.abspath(os.path.join(__file__, os.pardir))
 sbml_path = os.path.join(test_path, "test_data", "reactome_glucose_metabolism.sbml")
 if not os.path.isfile(sbml_path):
@@ -138,6 +144,7 @@ def test_precomputed_distances_shortest_paths():
 
 
 def test_precomputed_distances_neighborhoods():
+
     compartmentalized_species = sbml_dfs.compartmentalized_species[
         sbml_dfs.compartmentalized_species["s_id"] == "S00000000"
     ].index.tolist()
@@ -169,8 +176,12 @@ def test_precomputed_distances_neighborhoods():
         pruned_vert_otf = pruned_neighborhoods_otf[key]["vertices"]
         pruned_vert_precomp = pruned_neighborhoods_precomputed[key]["vertices"]
 
-        join_key = ["name", "node_name", "node_orientation"]
-        join_key_w_vars = [*join_key, *["path_weight", "path_length"]]
+        join_key = [
+            NAPISTU_GRAPH_VERTICES.NAME,
+            NAPISTU_GRAPH_VERTICES.NODE_NAME,
+            "node_orientation",
+        ]
+        join_key_w_vars = [*join_key, *[DISTANCES.PATH_WEIGHTS, DISTANCES.PATH_LENGTH]]
         neighbor_comparison = (
             pruned_vert_precomp[join_key_w_vars]
             .assign(in_precompute=True)
@@ -197,23 +208,27 @@ def test_precomputed_distances_neighborhoods():
     # which should be the same if we are pre-selecting the correct neighbors
     # as part of _precompute_neighbors()
     downstream_disagreement_w_precompute = (
-        comparison_df[comparison_df["node_orientation"] == "downstream"]
+        comparison_df[
+            comparison_df["node_orientation"] == NEIGHBORHOOD_NETWORK_TYPES.DOWNSTREAM
+        ]
         .merge(
             precomputed_distances,
-            left_on=["focal_sc_id", "name"],
-            right_on=["sc_id_origin", "sc_id_dest"],
+            left_on=["focal_sc_id", NAPISTU_GRAPH_VERTICES.NAME],
+            right_on=[DISTANCES.SC_ID_ORIGIN, DISTANCES.SC_ID_DEST],
         )
-        .query("abs(path_weight_x - path_weights) > 1e-13")
+        .query("abs(path_weights_x - path_weights) > 1e-13")
     )
 
     upstream_disagreement_w_precompute = (
-        comparison_df[comparison_df["node_orientation"] == "upstream"]
+        comparison_df[
+            comparison_df["node_orientation"] == NEIGHBORHOOD_NETWORK_TYPES.UPSTREAM
+        ]
         .merge(
             precomputed_distances,
-            left_on=["focal_sc_id", "name"],
-            right_on=["sc_id_dest", "sc_id_origin"],
+            left_on=["focal_sc_id", NAPISTU_GRAPH_VERTICES.NAME],
+            right_on=[DISTANCES.SC_ID_DEST, DISTANCES.SC_ID_ORIGIN],
         )
-        .query("abs(path_weight_x - path_upstream_weights) > 1e-13")
+        .query("abs(path_weights_x - path_upstream_weights) > 1e-13")
     )
 
     assert downstream_disagreement_w_precompute.shape[0] == 0