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

napistu/network/constants.py

@@ -10,8 +10,14 @@ from napistu.constants import SBOTERM_NAMES
 
 NAPISTU_GRAPH = SimpleNamespace(VERTICES="vertices", EDGES="edges", METADATA="metadata")
 
-NAPISTU_GRAPH_DIRECTEDNESS = SimpleNamespace(
-    DIRECTED="directed", UNDIRECTED="undirected"
+GRAPH_DIRECTEDNESS = SimpleNamespace(DIRECTED="directed", UNDIRECTED="undirected")
+
+GRAPH_RELATIONSHIPS = SimpleNamespace(
+    ANCESTORS="ancestors",
+    CHILDREN="children",
+    DESCENDANTS="descendants",
+    FOCAL="focal",
+    PARENTS="parents",
 )
 
 NAPISTU_GRAPH_VERTICES = SimpleNamespace(
@@ -230,4 +236,17 @@ NEIGHBORHOOD_DICT_KEYS = SimpleNamespace(
     VERTICES="vertices",
     EDGES="edges",
     REACTION_SOURCES="reaction_sources",
+    NEIGHBORHOOD_PATH_ENTITIES="neighborhood_path_entities",
+)
+
+DISTANCES = SimpleNamespace(
+    # core attributes of precomputed distances
+    SC_ID_ORIGIN="sc_id_origin",
+    SC_ID_DEST="sc_id_dest",
+    PATH_LENGTH="path_length",
+    PATH_UPSTREAM_WEIGHTS="path_upstream_weights",
+    PATH_WEIGHTS="path_weights",
+    # other attributes associated with paths/distances
+    FINAL_FROM="final_from",
+    FINAL_TO="final_to",
 )

napistu/network/neighborhoods.py

@@ -22,11 +22,16 @@ from napistu.constants import (
     MINI_SBO_NAME_TO_POLARITY,
     MINI_SBO_TO_NAME,
     NAPISTU_EDGELIST,
+    ONTOLOGIES,
     SBML_DFS,
 )
 
 from napistu.network.constants import (
+    DISTANCES,
+    GRAPH_RELATIONSHIPS,
     GRAPH_WIRING_APPROACHES,
+    NAPISTU_GRAPH_EDGES,
+    NAPISTU_GRAPH_NODE_TYPES,
     NAPISTU_GRAPH_VERTICES,
     NEIGHBORHOOD_DICT_KEYS,
     NEIGHBORHOOD_NETWORK_TYPES,
@@ -102,6 +107,16 @@ def find_and_prune_neighborhoods(
     if not isinstance(compartmentalized_species, list):
         raise TypeError("compartmentalized_species must be a list")
 
+    invalid_cspecies = [
+        x
+        for x in compartmentalized_species
+        if x not in sbml_dfs.compartmentalized_species.index
+    ]
+    if len(invalid_cspecies) > 0:
+        raise ValueError(
+            f"compartmentalized_species contains invalid species: {invalid_cspecies}"
+        )
+
     if isinstance(precomputed_distances, pd.DataFrame):
         logger.info("Pre-computed neighbors based on precomputed_distances")
 
@@ -116,7 +131,7 @@ def find_and_prune_neighborhoods(
     else:
         precomputed_neighbors = None
 
-    neighborhoods = find_neighborhoods(
+    neighborhood_dicts = find_neighborhoods(
         sbml_dfs=sbml_dfs,
         napistu_graph=napistu_graph,
         compartmentalized_species=compartmentalized_species,
@@ -128,7 +143,7 @@ def find_and_prune_neighborhoods(
         verbose=verbose,
     )
 
-    pruned_neighborhoods = prune_neighborhoods(neighborhoods, top_n=top_n)
+    pruned_neighborhoods = prune_neighborhoods(neighborhood_dicts, top_n=top_n)
 
     return pruned_neighborhoods
 
@@ -176,7 +191,7 @@ def load_neighborhoods(
     -------
     all_neighborhoods_df: pd.DataFrame
         A table containing all species in each query s_ids neighborhood
-    neighborhoods_dict: dict
+    neighborhood_dicts: dict
         Outputs from find_and_prune_neighborhoods for each s_id
 
     """
@@ -190,16 +205,16 @@ def load_neighborhoods(
     neighborhood_paths = [vertices_path, networks_path]
 
     if all([os.path.isfile(x) for x in neighborhood_paths]) and overwrite is False:
-        print(f"loading existing neighborhoods for {neighborhood_prefix}")
+        logger.info(f"loading existing neighborhoods for {neighborhood_prefix}")
 
         all_neighborhoods_df = pd.read_csv(vertices_path, sep="\t")
         with open(networks_path, "rb") as in_file:
-            neighborhoods_dict = pickle.load(in_file)
+            neighborhood_dicts = pickle.load(in_file)
 
     else:
-        print(f"creating neighborhoods based on {neighborhood_prefix}")
+        logger.info(f"creating neighborhoods based on {neighborhood_prefix}")
 
-        all_neighborhoods_df, neighborhoods_dict = create_neighborhoods(
+        all_neighborhoods_df, neighborhood_dicts = create_neighborhoods(
             s_ids=s_ids,
             sbml_dfs=sbml_dfs,
             napistu_graph=napistu_graph,
@@ -214,9 +229,9 @@ def load_neighborhoods(
 
         # pickle neighborhoods
         with open(networks_path, "wb") as fh:
-            pickle.dump(neighborhoods_dict, fh)
+            pickle.dump(neighborhood_dicts, fh)
 
-    return all_neighborhoods_df, neighborhoods_dict
+    return all_neighborhoods_df, neighborhood_dicts
 
 
 def create_neighborhoods(
@@ -254,7 +269,7 @@ def create_neighborhoods(
     -------
     all_neighborhoods_df: pd.DataFrame
         A table containing all species in each query s_ids neighborhood
-    neighborhoods_dict: dict
+    neighborhood_dicts: dict
         Outputs from find_and_prune_neighborhoods for each s_id
     """
 
@@ -275,13 +290,13 @@ def create_neighborhoods(
         raise TypeError(f"top_n was a {type(top_n)} and must be an int")
 
     neighborhoods_list = list()
-    neighborhoods_dict = dict()
+    neighborhood_dicts = dict()
     for s_id in s_ids:
         query_sc_species = ng_utils.compartmentalize_species(sbml_dfs, s_id)
 
         compartmentalized_species = query_sc_species[SBML_DFS.SC_ID].tolist()
 
-        neighborhoods = find_and_prune_neighborhoods(
+        neighborhood_dicts = find_and_prune_neighborhoods(
             sbml_dfs,
             napistu_graph,
             compartmentalized_species=compartmentalized_species,
@@ -295,25 +310,25 @@ def create_neighborhoods(
 
         neighborhood_entities = pd.concat(
             [
-                neighborhoods[sc_id][NEIGHBORHOOD_DICT_KEYS.VERTICES].assign(
+                neighborhood_dicts[sc_id][NEIGHBORHOOD_DICT_KEYS.VERTICES].assign(
                     focal_sc_id=sc_id
                 )
-                for sc_id in neighborhoods.keys()
+                for sc_id in neighborhood_dicts.keys()
             ]
         ).assign(focal_s_id=s_id)
 
         neighborhood_species = neighborhood_entities.merge(
             sbml_dfs.compartmentalized_species[SBML_DFS.S_ID],
-            left_on="name",
+            left_on=NAPISTU_GRAPH_VERTICES.NAME,
             right_index=True,
         )
 
         neighborhoods_list.append(neighborhood_species)
-        neighborhoods_dict[s_id] = neighborhoods
+        neighborhood_dicts[s_id] = neighborhood_dicts
 
     all_neighborhoods_df = pd.concat(neighborhoods_list).reset_index(drop=True)
 
-    return all_neighborhoods_df, neighborhoods_dict
+    return all_neighborhoods_df, neighborhood_dicts
 
 
 def create_neighborhood_prefix(network_type: str, order: int, top_n: int) -> str:
@@ -383,7 +398,7 @@ def load_neighborhoods_by_partition(
     if parition_sids_df.shape[0] == 0:
         raise ValueError(f"No s_ids associated with partition {selected_partition}")
 
-    parition_sids = parition_sids_df["s_id"].tolist()
+    parition_sids = parition_sids_df[SBML_DFS.S_ID].tolist()
 
     # read pathway and network data
 
@@ -443,7 +458,7 @@ def read_paritioned_neighborhoods(
     -------
     all_neighborhoods_df: pd.DataFrame
         A table containing all species in each query s_ids neighborhood
-    neighborhoods_dict: dict
+    neighborhood_dicts: dict
         Outputs from find_and_prune_neighborhoods for each s_id
 
     """
@@ -508,7 +523,7 @@ def read_paritioned_neighborhoods(
 
     # combine all partitions' dfs and dicts
     all_neighborhoods_df = pd.concat(neighborhood_paths_list).reset_index(drop=True)
-    neighborhoods_dict = dict(ChainMap(*path_dict_list))
+    neighborhood_dicts = dict(ChainMap(*path_dict_list))
 
     # TO DO - remove s_id duplication (these are present in the vertices table in the partition outputs)
     if not all(all_neighborhoods_df["s_id_x"] == all_neighborhoods_df["s_id_y"]):
@@ -517,7 +532,7 @@ def read_paritioned_neighborhoods(
         {"s_id_x": "s_id"}, axis=1
     )
 
-    return all_neighborhoods_df, neighborhoods_dict
+    return all_neighborhoods_df, neighborhood_dicts
 
 
 def find_neighborhoods(
@@ -558,7 +573,7 @@ def find_neighborhoods(
         the minimum size of a pathway to be considered
     source_total_counts: pd.Series | None
         Optional, A series of the total counts of each source. As produced by
-        source.get_source_total_counts()\
+        source.get_source_total_counts()
     verbose: bool
         Extra reporting
 
@@ -579,6 +594,16 @@ def find_neighborhoods(
     if not isinstance(order, int):
         raise TypeError(f"order was a {type(order)} and must be an int")
 
+    invalid_cspecies = [
+        x
+        for x in compartmentalized_species
+        if x not in sbml_dfs.compartmentalized_species.index
+    ]
+    if len(invalid_cspecies) > 0:
+        raise ValueError(
+            f"compartmentalized_species contains invalid species: {invalid_cspecies}"
+        )
+
     # create a table which includes cspecies and reaction nearby each of the
     # focal compartmentalized_speecies
     neighborhood_df = _build_raw_neighborhood_df(
@@ -656,12 +681,12 @@ def create_neighborhood_dict_entry(
             focal node.
     """
 
-    one_neighborhood_df = neighborhood_df[neighborhood_df["sc_id"] == sc_id]
+    one_neighborhood_df = neighborhood_df[neighborhood_df[SBML_DFS.SC_ID] == sc_id]
 
     if verbose:
         _create_neighborhood_dict_entry_logging(sc_id, one_neighborhood_df, sbml_dfs)
 
-    if not one_neighborhood_df["name"].eq(sc_id).any():
+    if not one_neighborhood_df[NAPISTU_GRAPH_VERTICES.NAME].eq(sc_id).any():
         raise ValueError(
             f"The focal node sc_id = {sc_id} was not in 'one_neighborhood_df'.\
             By convention it should be part of its neighborhood"
@@ -677,19 +702,22 @@ def create_neighborhood_dict_entry(
 
     # add edge polarity: whether edges are activating, inhibiting or unknown
     if edges.shape[0] > 0:
-        edges["link_polarity"] = (
-            edges["sbo_term"].map(MINI_SBO_TO_NAME).map(MINI_SBO_NAME_TO_POLARITY)
+        edges[NET_POLARITY.LINK_POLARITY] = (
+            edges[SBML_DFS.SBO_TERM]
+            .map(MINI_SBO_TO_NAME)
+            .map(MINI_SBO_NAME_TO_POLARITY)
         )
 
     try:
         reaction_sources = ng_utils.get_minimal_sources_edges(
-            vertices.rename(columns={"name": "node"}),
+            vertices.rename(columns={NAPISTU_GRAPH_VERTICES.NAME: "node"}),
             sbml_dfs,
             min_pw_size=min_pw_size,
             # optional, counts of sources across the whole model
             source_total_counts=source_total_counts,
         )
     except Exception:
+        logger.warning(f"Could not get reaction sources for {sc_id}; returning None")
         reaction_sources = None
 
     # to add weights to the network solve the shortest path problem
@@ -697,75 +725,38 @@ def create_neighborhood_dict_entry(
     # solve this problem separately whether a given neighbor is an
     # ancestor or descendant
 
-    # focal node -> descendants
-
-    one_descendants_df = one_neighborhood_df[
-        one_neighborhood_df["relationship"] == "descendants"
-    ]
-    descendants_list = list(set(one_descendants_df["name"].tolist()).union({sc_id}))
-
-    # hide warnings which are mostly just Dijkstra complaining about not finding neighbors
-    with warnings.catch_warnings():
-        # igraph throws warnings for each pair of unconnected species
-        warnings.simplefilter("ignore")
-
-        neighborhood_paths = neighborhood_graph.get_shortest_paths(
-            # focal node
-            v=sc_id,
-            to=descendants_list,
-            weights="weights",
-            mode="out",
-            output="epath",
-        )
-
-    downstream_path_attrs, downstream_entity_dict = _calculate_path_attrs(
-        neighborhood_paths, edges, vertices=descendants_list, weight_var="weights"
-    )
-    downstream_path_attrs = downstream_path_attrs.assign(node_orientation="downstream")
-
-    # ancestors -> focal_node
-
-    one_ancestors_df = one_neighborhood_df[
-        one_neighborhood_df["relationship"] == "ancestors"
-    ]
-    ancestors_list = list(set(one_ancestors_df["name"].tolist()).union({sc_id}))
-
-    with warnings.catch_warnings():
-        # igraph throws warnings for each pair of unconnected species
-        warnings.simplefilter("ignore")
-
-        neighborhood_paths = neighborhood_graph.get_shortest_paths(
-            v=sc_id,
-            to=ancestors_list,
-            weights="upstream_weights",
-            mode="in",
-            output="epath",
-        )
-
-    upstream_path_attrs, upstream_entity_dict = _calculate_path_attrs(
-        neighborhood_paths,
+    (
+        downstream_path_attrs,
+        downstream_entity_dict,
+        upstream_path_attrs,
+        upstream_entity_dict,
+    ) = _find_neighbors_paths(
+        neighborhood_graph,
+        one_neighborhood_df,
+        sc_id,
         edges,
-        vertices=ancestors_list,
-        weight_var="upstream_weights",
     )
-    upstream_path_attrs = upstream_path_attrs.assign(node_orientation="upstream")
 
     # combine upstream and downstream shortest paths
     # in cases a node is upstream and downstream of the focal node
     # by taking the lowest path weight
     vertex_neighborhood_attrs = (
         pd.concat([downstream_path_attrs, upstream_path_attrs])
-        .sort_values("path_weight")
+        .sort_values(DISTANCES.PATH_WEIGHTS)
         .groupby("neighbor")
         .first()
     )
     # label the focal node
-    vertex_neighborhood_attrs.loc[sc_id, "node_orientation"] = "focal"
+    vertex_neighborhood_attrs.loc[sc_id, "node_orientation"] = GRAPH_RELATIONSHIPS.FOCAL
 
     # if the precomputed distances, graph and/or sbml_dfs are inconsistent
     # then the shortest paths search may just return empty lists
     # throw a clearer error message in this case.
-    EXPECTED_VERTEX_ATTRS = {"final_from", "final_to", "net_polarity"}
+    EXPECTED_VERTEX_ATTRS = {
+        DISTANCES.FINAL_FROM,
+        DISTANCES.FINAL_TO,
+        NET_POLARITY.NET_POLARITY,
+    }
     missing_vertex_attrs = EXPECTED_VERTEX_ATTRS.difference(
         set(vertex_neighborhood_attrs.columns.tolist())
     )
@@ -780,22 +771,22 @@ def create_neighborhood_dict_entry(
     # add net_polarity to edges in addition to nodes
     edges = edges.merge(
         vertex_neighborhood_attrs.reset_index()[
-            ["final_from", "final_to", "net_polarity"]
+            [DISTANCES.FINAL_FROM, DISTANCES.FINAL_TO, NET_POLARITY.NET_POLARITY]
         ].dropna(),
-        left_on=["from", "to"],
-        right_on=["final_from", "final_to"],
+        left_on=[NAPISTU_GRAPH_EDGES.FROM, NAPISTU_GRAPH_EDGES.TO],
+        right_on=[DISTANCES.FINAL_FROM, DISTANCES.FINAL_TO],
         how="left",
     )
 
     vertices = vertices.merge(
-        vertex_neighborhood_attrs, left_on="name", right_index=True
+        vertex_neighborhood_attrs, left_on=NAPISTU_GRAPH_VERTICES.NAME, right_index=True
     )
 
     # drop nodes with a path length / weight of zero
     # which are NOT the focal node
     # these were cases where no path to/from the focal node to the query node was found
     disconnected_neighbors = vertices.query(
-        "(not node_orientation == 'focal') and path_weight == 0"
+        f"(not node_orientation == '{GRAPH_RELATIONSHIPS.FOCAL}') and {DISTANCES.PATH_WEIGHTS} == 0"
     )
     vertices = vertices[~vertices.index.isin(disconnected_neighbors.index.tolist())]
 
@@ -803,8 +794,8 @@ def create_neighborhood_dict_entry(
     vertices = add_vertices_uri_urls(vertices, sbml_dfs)
 
     neighborhood_path_entities = {
-        "downstream": downstream_entity_dict,
-        "upstream": upstream_entity_dict,
+        NEIGHBORHOOD_NETWORK_TYPES.DOWNSTREAM: downstream_entity_dict,
+        NEIGHBORHOOD_NETWORK_TYPES.UPSTREAM: upstream_entity_dict,
     }
 
     # update graph with additional vertex and edge attributes
@@ -812,16 +803,16 @@ def create_neighborhood_dict_entry(
         vertices=vertices.to_dict("records"),
         edges=edges.to_dict("records"),
         directed=napistu_graph.is_directed(),
-        vertex_name_attr="name",
-        edge_foreign_keys=("from", "to"),
+        vertex_name_attr=NAPISTU_GRAPH_VERTICES.NAME,
+        edge_foreign_keys=(NAPISTU_GRAPH_EDGES.FROM, NAPISTU_GRAPH_EDGES.TO),
     )
 
     outdict = {
-        "graph": updated_napistu_graph,
-        "vertices": vertices,
-        "edges": edges,
-        "reaction_sources": reaction_sources,
-        "neighborhood_path_entities": neighborhood_path_entities,
+        NEIGHBORHOOD_DICT_KEYS.GRAPH: updated_napistu_graph,
+        NEIGHBORHOOD_DICT_KEYS.VERTICES: vertices,
+        NEIGHBORHOOD_DICT_KEYS.EDGES: edges,
+        NEIGHBORHOOD_DICT_KEYS.REACTION_SOURCES: reaction_sources,
+        NEIGHBORHOOD_DICT_KEYS.NEIGHBORHOOD_PATH_ENTITIES: neighborhood_path_entities,
     }
 
     return outdict
@@ -831,9 +822,11 @@ def _create_neighborhood_dict_entry_logging(
     sc_id: str, one_neighborhood_df: pd.DataFrame, sbml_dfs: sbml_dfs_core.SBML_dfs
 ):
     df_summary = one_neighborhood_df.copy()
-    df_summary["node_type"] = [
-        "species" if x else "reactions"
-        for x in df_summary["name"].isin(sbml_dfs.compartmentalized_species.index)
+    df_summary[NAPISTU_GRAPH_VERTICES.NODE_TYPE] = [
+        NAPISTU_GRAPH_NODE_TYPES.SPECIES if x else NAPISTU_GRAPH_NODE_TYPES.REACTION
+        for x in df_summary[NAPISTU_GRAPH_VERTICES.NAME].isin(
+            sbml_dfs.compartmentalized_species.index
+        )
     ]
     relationship_counts = df_summary.value_counts(
         ["relationship", "node_type"]
@@ -857,22 +850,45 @@ def add_vertices_uri_urls(
     vertices: pd.DataFrame, sbml_dfs: sbml_dfs_core.SBML_dfs
 ) -> pd.DataFrame:
     """
-    Add Vertices URI URLs
+    Add URI URLs to neighborhood vertices DataFrame.
 
-    Add a url variable to the neighborhood vertices pd.DataFrame
+    This function enriches a vertices DataFrame with URI URLs for both species and
+    reactions. For species, it adds standard reference identifiers and Pharos IDs
+    where available. For reactions, it adds reaction-specific URI URLs.
 
     Parameters
     ----------
     vertices: pd.DataFrame
-        table of neighborhood vertices
+        DataFrame containing neighborhood vertices with the following required columns:
+        - NAPISTU_GRAPH_VERTICES.NAME: The name/identifier of each vertex
+        - NAPISTU_GRAPH_VERTICES.NODE_TYPE: The type of node, either
+        NAPISTU_GRAPH_NODE_TYPES.SPECIES or NAPISTU_GRAPH_NODE_TYPES.REACTION
     sbml_dfs: sbml_dfs_core.SBML_dfs
-        consensus network model
+        Pathway model including species, compartmentalized species, reactions and ontologies
 
     Returns
     -------
-    vertices: pd.DataFrame
-        input table with a url field
+    pd.DataFrame
+        Input vertices DataFrame enriched with URI URL columns:
+        - For species: standard reference identifier URLs and Pharos IDs
+        - For reactions: reaction-specific URI URLs
+        - Empty strings for missing URLs
 
+    Raises
+    ------
+    ValueError
+        If vertices DataFrame is empty (no rows)
+    TypeError
+        If the output is not a pandas DataFrame
+    ValueError
+        If the output row count doesn't match the input row count
+
+    Notes
+    -----
+    - Species vertices are merged with compartmentalized_species to get s_id mappings
+    - Reaction vertices are processed directly using their names
+    - Missing URLs are filled with empty strings
+    - The function preserves the original row order and count
     """
 
     if vertices.shape[0] <= 0:
@@ -882,41 +898,53 @@ def add_vertices_uri_urls(
 
     # add s_ids
     neighborhood_species = vertices[
-        vertices[NAPISTU_GRAPH_VERTICES.NODE_TYPE] == "species"
+        vertices[NAPISTU_GRAPH_VERTICES.NODE_TYPE] == NAPISTU_GRAPH_NODE_TYPES.SPECIES
     ].merge(
         sbml_dfs.compartmentalized_species[SBML_DFS.S_ID],
-        left_on="name",
+        left_on=NAPISTU_GRAPH_VERTICES.NAME,
         right_index=True,
         how="left",
     )
 
     # add a standard reference identifier
     neighborhood_species_aug = neighborhood_species.merge(
-        sbml_dfs.get_uri_urls("species", neighborhood_species[SBML_DFS.S_ID]),
+        sbml_dfs.get_uri_urls(
+            NAPISTU_GRAPH_NODE_TYPES.SPECIES, neighborhood_species[SBML_DFS.S_ID]
+        ),
         left_on=SBML_DFS.S_ID,
         right_index=True,
         how="left",
         # add pharos ids where available
     ).merge(
         sbml_dfs.get_uri_urls(
-            "species", neighborhood_species[SBML_DFS.S_ID], required_ontology="pharos"
-        ).rename("pharos"),
+            NAPISTU_GRAPH_NODE_TYPES.SPECIES,
+            neighborhood_species[SBML_DFS.S_ID],
+            required_ontology=ONTOLOGIES.PHAROS,
+        ).rename(ONTOLOGIES.PHAROS),
         left_on=SBML_DFS.S_ID,
         right_index=True,
         how="left",
     )
 
-    if sum(vertices[NAPISTU_GRAPH_VERTICES.NODE_TYPE] == "reaction") > 0:
+    if (
+        sum(
+            vertices[NAPISTU_GRAPH_VERTICES.NODE_TYPE]
+            == NAPISTU_GRAPH_NODE_TYPES.REACTION
+        )
+        > 0
+    ):
         neighborhood_reactions = vertices[
-            vertices[NAPISTU_GRAPH_VERTICES.NODE_TYPE] == "reaction"
+            vertices[NAPISTU_GRAPH_VERTICES.NODE_TYPE]
+            == NAPISTU_GRAPH_NODE_TYPES.REACTION
         ].merge(
             sbml_dfs.get_uri_urls(
-                "reactions",
-                vertices[vertices[NAPISTU_GRAPH_VERTICES.NODE_TYPE] == "reaction"][
-                    "name"
-                ],
+                SBML_DFS.REACTIONS,
+                vertices[
+                    vertices[NAPISTU_GRAPH_VERTICES.NODE_TYPE]
+                    == NAPISTU_GRAPH_NODE_TYPES.REACTION
+                ][NAPISTU_GRAPH_VERTICES.NAME],
             ),
-            left_on="name",
+            left_on=NAPISTU_GRAPH_VERTICES.NAME,
             right_index=True,
             how="left",
         )
@@ -965,7 +993,7 @@ def prune_neighborhoods(neighborhoods: dict, top_n: int = 100) -> dict:
     if not isinstance(top_n, int):
         raise TypeError(f"top_n was a {type(top_n)} and must be an int")
 
-    pruned_neighborhoods_dict = dict()
+    pruned_neighborhood_dicts = dict()
 
     for an_sc_id in neighborhoods.keys():
         one_neighborhood = neighborhoods[an_sc_id]
@@ -977,14 +1005,14 @@ def prune_neighborhoods(neighborhoods: dict, top_n: int = 100) -> dict:
         # reduce neighborhood to this set of high-weight vertices
         all_neighbors = pd.DataFrame(
             {
-                NAPISTU_GRAPH_VERTICES.NODE_NAME: one_neighborhood[
+                NAPISTU_GRAPH_VERTICES.NAME: one_neighborhood[
                     NEIGHBORHOOD_DICT_KEYS.GRAPH
-                ].vs[NAPISTU_GRAPH_VERTICES.NODE_NAME]
+                ].vs[NAPISTU_GRAPH_VERTICES.NAME]
             }
         )
         pruned_vertices_indices = all_neighbors[
-            all_neighbors[NAPISTU_GRAPH_VERTICES.NODE_NAME].isin(
-                pruned_vertices[NAPISTU_GRAPH_VERTICES.NODE_NAME]
+            all_neighbors[NAPISTU_GRAPH_VERTICES.NAME].isin(
+                pruned_vertices[NAPISTU_GRAPH_VERTICES.NAME]
             )
         ].index.tolist()
 
@@ -996,8 +1024,9 @@ def prune_neighborhoods(neighborhoods: dict, top_n: int = 100) -> dict:
         pruned_edges = pd.DataFrame([e.attributes() for e in pruned_neighborhood.es])
 
         pruned_reactions = pruned_vertices[
-            pruned_vertices[NAPISTU_GRAPH_VERTICES.NODE_TYPE] == "reaction"
-        ][NAPISTU_GRAPH_VERTICES.NODE_NAME]
+            pruned_vertices[NAPISTU_GRAPH_VERTICES.NODE_TYPE]
+            == NAPISTU_GRAPH_NODE_TYPES.REACTION
+        ][NAPISTU_GRAPH_VERTICES.NAME]
 
         if pruned_reactions.shape[0] != 0:
             if one_neighborhood[NEIGHBORHOOD_DICT_KEYS.REACTION_SOURCES] is None:
@@ -1018,14 +1047,14 @@ def prune_neighborhoods(neighborhoods: dict, top_n: int = 100) -> dict:
                 NEIGHBORHOOD_DICT_KEYS.REACTION_SOURCES
             ]
 
-        pruned_neighborhoods_dict[an_sc_id] = {
+        pruned_neighborhood_dicts[an_sc_id] = {
             NEIGHBORHOOD_DICT_KEYS.GRAPH: pruned_neighborhood,
             NEIGHBORHOOD_DICT_KEYS.VERTICES: pruned_vertices,
             NEIGHBORHOOD_DICT_KEYS.EDGES: pruned_edges,
             NEIGHBORHOOD_DICT_KEYS.REACTION_SOURCES: pruned_reaction_sources,
         }
 
-    return pruned_neighborhoods_dict
+    return pruned_neighborhood_dicts
 
 
 def plot_neighborhood(
@@ -1065,8 +1094,8 @@ def plot_neighborhood(
         "focal disease": "lime",
         "disease": "aquamarine",
         "focal": "lightcoral",
-        "species": "firebrick",
-        "reaction": "dodgerblue",
+        NAPISTU_GRAPH_NODE_TYPES.SPECIES: "firebrick",
+        NAPISTU_GRAPH_NODE_TYPES.REACTION: "dodgerblue",
     }
 
     edge_polarity_colors = {
@@ -1173,7 +1202,7 @@ def _precompute_neighbors(
 
     # filter by distance
     close_cspecies_subset_precomputed_distances = cspecies_subset_precomputed_distances[
-        cspecies_subset_precomputed_distances["path_length"] <= order
+        cspecies_subset_precomputed_distances[DISTANCES.PATH_LENGTH] <= order
     ]
 
     # filter to retain top_n
@@ -1183,12 +1212,12 @@ def _precompute_neighbors(
     ]:
         top_descendants = (
             close_cspecies_subset_precomputed_distances[
-                close_cspecies_subset_precomputed_distances["sc_id_origin"].isin(
-                    compartmentalized_species
-                )
+                close_cspecies_subset_precomputed_distances[
+                    DISTANCES.SC_ID_ORIGIN
+                ].isin(compartmentalized_species)
             ]
             # sort by path_weight so we can retain the lowest weight neighbors
-            .sort_values("path_weights")
+            .sort_values(DISTANCES.PATH_WEIGHTS)
             .groupby(NAPISTU_EDGELIST.SC_ID_ORIGIN)
             .head(top_n)
         )
@@ -1216,7 +1245,7 @@ def _precompute_neighbors(
             # the logic is flipped if we are looking for ancestors where
             # we penalize based on the number of parents of a node when
             # we use it (i.e., the default upstream_weights).
-            .sort_values("path_upstream_weights")
+            .sort_values(DISTANCES.PATH_UPSTREAM_WEIGHTS)
             .groupby(NAPISTU_EDGELIST.SC_ID_DEST)
             .head(top_n)
         )
@@ -1233,7 +1262,7 @@ def _precompute_neighbors(
             precomputed_neighbors=top_descendants,
             compartmentalized_species=compartmentalized_species,
             sbml_dfs=sbml_dfs,
-            relationship="descendants",
+            relationship=GRAPH_RELATIONSHIPS.DESCENDANTS,
         )
 
         if downstream_reactions is not None:
@@ -1247,7 +1276,7 @@ def _precompute_neighbors(
             precomputed_neighbors=top_ancestors,
             compartmentalized_species=compartmentalized_species,
             sbml_dfs=sbml_dfs,
-            relationship="ancestors",
+            relationship=GRAPH_RELATIONSHIPS.ANCESTORS,
         )
 
         if upstream_reactions is not None:
@@ -1313,7 +1342,7 @@ def _build_raw_neighborhood_df(
         descendants_df = _find_neighbors(
             napistu_graph=napistu_graph,
             compartmentalized_species=compartmentalized_species,
-            relationship="descendants",
+            relationship=GRAPH_RELATIONSHIPS.DESCENDANTS,
             order=order,
             precomputed_neighbors=precomputed_neighbors,
         )
@@ -1326,7 +1355,7 @@ def _build_raw_neighborhood_df(
         ancestors_df = _find_neighbors(
             napistu_graph=napistu_graph,
             compartmentalized_species=compartmentalized_species,
-            relationship="ancestors",
+            relationship=GRAPH_RELATIONSHIPS.ANCESTORS,
             order=order,
             precomputed_neighbors=precomputed_neighbors,
         )
@@ -1342,8 +1371,9 @@ def _build_raw_neighborhood_df(
         raise NotImplementedError("invalid network_type")
 
     # add name since this is an easy way to lookup igraph vertices
-    neighborhood_df["name"] = [
-        x["name"] for x in napistu_graph.vs[neighborhood_df["neighbor"]]
+    neighborhood_df[NAPISTU_GRAPH_VERTICES.NAME] = [
+        x[NAPISTU_GRAPH_VERTICES.NAME]
+        for x in napistu_graph.vs[neighborhood_df["neighbor"]]
     ]
 
     return neighborhood_df
@@ -1369,15 +1399,21 @@ def _find_neighbors(
     if isinstance(precomputed_neighbors, pd.DataFrame):
         # add graph indices to neighbors
         nodes_to_names = (
-            pd.DataFrame({"name": napistu_graph.vs["name"]})
+            pd.DataFrame(
+                {
+                    NAPISTU_GRAPH_VERTICES.NAME: napistu_graph.vs[
+                        NAPISTU_GRAPH_VERTICES.NAME
+                    ]
+                }
+            )
             .reset_index()
             .rename({"index": "neighbor"}, axis=1)
         )
 
-        if relationship == "descendants":
+        if relationship == GRAPH_RELATIONSHIPS.DESCENDANTS:
             bait_id = NAPISTU_EDGELIST.SC_ID_ORIGIN
             target_id = NAPISTU_EDGELIST.SC_ID_DEST
-        elif relationship == "ancestors":
+        elif relationship == GRAPH_RELATIONSHIPS.ANCESTORS:
             bait_id = NAPISTU_EDGELIST.SC_ID_DEST
             target_id = NAPISTU_EDGELIST.SC_ID_ORIGIN
         else:
@@ -1389,15 +1425,17 @@ def _find_neighbors(
             precomputed_neighbors[
                 precomputed_neighbors[bait_id].isin(compartmentalized_species)
             ]
-            .merge(nodes_to_names.rename({"name": target_id}, axis=1))
+            .merge(
+                nodes_to_names.rename({NAPISTU_GRAPH_VERTICES.NAME: target_id}, axis=1)
+            )
             .rename({bait_id: SBML_DFS.SC_ID}, axis=1)
             .drop([target_id], axis=1)
             .assign(relationship=relationship)
         )
     else:
-        if relationship == "descendants":
+        if relationship == GRAPH_RELATIONSHIPS.DESCENDANTS:
             mode_type = "out"
-        elif relationship == "ancestors":
+        elif relationship == GRAPH_RELATIONSHIPS.ANCESTORS:
             mode_type = "in"
         else:
             raise ValueError(
@@ -1443,10 +1481,10 @@ def _find_reactions_by_relationship(
     if precomputed_neighbors.shape[0] == 0:
         return None
 
-    if relationship == "descendants":
+    if relationship == GRAPH_RELATIONSHIPS.DESCENDANTS:
         bait_id = NAPISTU_EDGELIST.SC_ID_ORIGIN
         target_id = NAPISTU_EDGELIST.SC_ID_DEST
-    elif relationship == "ancestors":
+    elif relationship == GRAPH_RELATIONSHIPS.ANCESTORS:
         bait_id = NAPISTU_EDGELIST.SC_ID_DEST
         target_id = NAPISTU_EDGELIST.SC_ID_ORIGIN
     else:
@@ -1525,10 +1563,11 @@ def _prune_vertex_set(one_neighborhood: dict, top_n: int) -> pd.DataFrame:
 
     """
 
-    neighborhood_vertices = one_neighborhood["vertices"]
+    neighborhood_vertices = one_neighborhood[NEIGHBORHOOD_DICT_KEYS.VERTICES]
 
     indexed_neighborhood_species = neighborhood_vertices[
-        neighborhood_vertices[NAPISTU_GRAPH_VERTICES.NODE_TYPE] == "species"
+        neighborhood_vertices[NAPISTU_GRAPH_VERTICES.NODE_TYPE]
+        == NAPISTU_GRAPH_NODE_TYPES.SPECIES
     ].set_index("node_orientation")
 
     pruned_oriented_neighbors = list()
@@ -1538,14 +1577,14 @@ def _prune_vertex_set(one_neighborhood: dict, top_n: int) -> pd.DataFrame:
             # handle cases where only one entry exists to DF->series coercion occurs
             vertex_subset = vertex_subset.to_frame().T
 
-        sorted_vertex_set = vertex_subset.sort_values("path_weight")
-        weight_cutoff = sorted_vertex_set["path_weight"].iloc[
+        sorted_vertex_set = vertex_subset.sort_values(DISTANCES.PATH_WEIGHTS)
+        weight_cutoff = sorted_vertex_set[DISTANCES.PATH_WEIGHTS].iloc[
             min(top_n - 1, sorted_vertex_set.shape[0] - 1)
         ]
 
         top_neighbors = sorted_vertex_set[
-            sorted_vertex_set["path_weight"] <= weight_cutoff
-        ]["name"].tolist()
+            sorted_vertex_set[DISTANCES.PATH_WEIGHTS] <= weight_cutoff
+        ][NAPISTU_GRAPH_VERTICES.NAME].tolist()
 
         # include reactions and other species necessary to reach the top neighbors
         # by pulling in the past solutions to weighted shortest paths problems
@@ -1564,7 +1603,7 @@ def _prune_vertex_set(one_neighborhood: dict, top_n: int) -> pd.DataFrame:
     # combine all neighbors
     pruned_neighbors = set().union(*pruned_oriented_neighbors)
     pruned_vertices = neighborhood_vertices[
-        neighborhood_vertices["name"].isin(pruned_neighbors)
+        neighborhood_vertices[NAPISTU_GRAPH_VERTICES.NAME].isin(pruned_neighbors)
     ].reset_index(drop=True)
 
     return pruned_vertices
@@ -1574,7 +1613,7 @@ def _calculate_path_attrs(
     neighborhood_paths: list[list],
     edges: pd.DataFrame,
     vertices: list,
-    weight_var: str = "weights",
+    weight_var: str = NAPISTU_GRAPH_EDGES.WEIGHTS,
 ) -> tuple[pd.DataFrame, dict[Any, set]]:
     """
     Calculate Path Attributes
@@ -1624,15 +1663,15 @@ def _calculate_path_attrs(
         # if all_path_edges.ngroups > 0:
         path_attributes_df = pd.concat(
             [
-                all_path_edges[weight_var].agg("sum").rename("path_weight"),
-                all_path_edges.agg("size").rename("path_length"),
-                all_path_edges["link_polarity"]
+                all_path_edges[weight_var].agg("sum").rename(DISTANCES.PATH_WEIGHTS),
+                all_path_edges.agg("size").rename(DISTANCES.PATH_LENGTH),
+                all_path_edges[NET_POLARITY.LINK_POLARITY]
                 .agg(paths._terminal_net_polarity)
-                .rename("net_polarity"),
+                .rename(NET_POLARITY.NET_POLARITY),
                 # add the final edge since this can be used to add path attributes to edges
                 # i.e., apply net_polarity to an edge
-                all_path_edges["from"].agg("last").rename("final_from"),
-                all_path_edges["to"].agg("last").rename("final_to"),
+                all_path_edges["from"].agg("last").rename(DISTANCES.FINAL_FROM),
+                all_path_edges["to"].agg("last").rename(DISTANCES.FINAL_TO),
             ],
             axis=1,
         ).reset_index()
@@ -1655,7 +1694,11 @@ def _calculate_path_attrs(
         if len(neighborhood_paths[i]) == 0
     ]
     edgeles_nodes_df = pd.DataFrame({"neighbor": edgeless_nodes}).assign(
-        path_length=0, path_weight=0, net_polarity=None
+        **{
+            DISTANCES.PATH_LENGTH: 0,
+            DISTANCES.PATH_WEIGHTS: 0,
+            NET_POLARITY.NET_POLARITY: None,
+        }
     )
 
     # add edgeless entries as entries in the two outputs
@@ -1672,3 +1715,118 @@ def _calculate_path_attrs(
         )
 
     return path_attributes_df, neighborhood_path_entities
+
+
+def _find_neighbors_paths(
+    neighborhood_graph: ig.Graph,
+    one_neighborhood_df: pd.DataFrame,
+    sc_id: str,
+    edges: pd.DataFrame,
+) -> tuple[pd.DataFrame, dict[Any, set], pd.DataFrame, dict[Any, set]]:
+    """
+    Find shortest paths between the focal node and its neighbors in both directions.
+
+    This function calculates shortest paths from the focal node to its descendants
+    (downstream) and ancestors (upstream) using igraph's shortest path algorithms.
+    It uses _calculate_path_attrs to compute path attributes including path weights,
+    lengths, and polarity information.
+
+    Parameters
+    ----------
+    neighborhood_graph: ig.Graph
+        The igraph Graph object representing the neighborhood network
+    one_neighborhood_df: pd.DataFrame
+        DataFrame containing neighborhood information with 'relationship' column
+        indicating 'descendants' or 'ancestors' for each node
+    sc_id: str
+        The compartmentalized species ID of the focal node
+    edges: pd.DataFrame
+        DataFrame containing edge information with columns for 'from', 'to',
+        weights, and link polarity
+
+    Returns
+    -------
+    downstream_path_attrs: pd.DataFrame
+        DataFrame containing path attributes for downstream paths from focal node
+        to descendants. Includes columns: neighbor, path_weight, path_length,
+        net_polarity, final_from, final_to, node_orientation
+    downstream_entity_dict: dict[Any, set]
+        Dictionary mapping each descendant neighbor to the set of entities
+        (nodes) connecting it to the focal node
+    upstream_path_attrs: pd.DataFrame
+        DataFrame containing path attributes for upstream paths from focal node
+        to ancestors. Includes columns: neighbor, path_weight, path_length,
+        net_polarity, final_from, final_to, node_orientation
+    upstream_entity_dict: dict[Any, set]
+        Dictionary mapping each ancestor neighbor to the set of entities
+        (nodes) connecting it to the focal node
+    """
+
+    one_descendants_df = one_neighborhood_df[
+        one_neighborhood_df["relationship"] == GRAPH_RELATIONSHIPS.DESCENDANTS
+    ]
+    descendants_list = list(
+        set(one_descendants_df[NAPISTU_GRAPH_VERTICES.NAME].tolist()).union({sc_id})
+    )
+
+    # hide warnings which are mostly just Dijkstra complaining about not finding neighbors
+    with warnings.catch_warnings():
+        # igraph throws warnings for each pair of unconnected species
+        warnings.simplefilter("ignore")
+
+        neighborhood_paths = neighborhood_graph.get_shortest_paths(
+            # focal node
+            v=sc_id,
+            to=descendants_list,
+            weights=NAPISTU_GRAPH_EDGES.WEIGHTS,
+            mode="out",
+            output="epath",
+        )
+
+    downstream_path_attrs, downstream_entity_dict = _calculate_path_attrs(
+        neighborhood_paths,
+        edges,
+        vertices=descendants_list,
+        weight_var=NAPISTU_GRAPH_EDGES.WEIGHTS,
+    )
+    downstream_path_attrs = downstream_path_attrs.assign(
+        node_orientation=NEIGHBORHOOD_NETWORK_TYPES.DOWNSTREAM
+    )
+
+    # ancestors -> focal_node
+
+    one_ancestors_df = one_neighborhood_df[
+        one_neighborhood_df["relationship"] == GRAPH_RELATIONSHIPS.ANCESTORS
+    ]
+    ancestors_list = list(
+        set(one_ancestors_df[NAPISTU_GRAPH_VERTICES.NAME].tolist()).union({sc_id})
+    )
+
+    with warnings.catch_warnings():
+        # igraph throws warnings for each pair of unconnected species
+        warnings.simplefilter("ignore")
+
+        neighborhood_paths = neighborhood_graph.get_shortest_paths(
+            v=sc_id,
+            to=ancestors_list,
+            weights=NAPISTU_GRAPH_EDGES.UPSTREAM_WEIGHTS,
+            mode="in",
+            output="epath",
+        )
+
+    upstream_path_attrs, upstream_entity_dict = _calculate_path_attrs(
+        neighborhood_paths,
+        edges,
+        vertices=ancestors_list,
+        weight_var=NAPISTU_GRAPH_EDGES.UPSTREAM_WEIGHTS,
+    )
+    upstream_path_attrs = upstream_path_attrs.assign(
+        node_orientation=NEIGHBORHOOD_NETWORK_TYPES.UPSTREAM
+    )
+
+    return (
+        downstream_path_attrs,
+        downstream_entity_dict,
+        upstream_path_attrs,
+        upstream_entity_dict,
+    )

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__)
 
@@ -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-0.4.6.dist-info → napistu-0.4.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: napistu
-Version: 0.4.6
+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.6.dist-info → napistu-0.4.7.dist-info}/RECORD

@@ -59,15 +59,15 @@ 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=tnLhxThPwuOmvp_eoF6kdcKcxtrYV4O5mn0J6MV8FSo,7203
+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=Cg-82QxBQUi2fYGs1Pv_e56CxPUAGq9hX1EiYAXlSJ0,58972
+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=3FrG-rln6NpGs538NP--IRcNVVoJghghJYBUGji94Sg,16094
+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
@@ -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.6.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=gMOiVIL7q5Feae6ziZbMs08IPxrVsRlbfVb0UV0SUgg,5622
+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=Bx1uqyIAPw_i27s94dyjCQcV_04O9yovlrQgr1lFjS4,2143
-tests/test_network_precompute.py,sha256=IPr1KhtxBD0fXx_2TvZqnevrD-Iig35otb8yloRFpRc,10014
+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.6.dist-info/METADATA,sha256=pmQ510PR2BSlSrqleSjf7FGULyIiI9Cr12MtbcEOe2M,4078
-napistu-0.4.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-napistu-0.4.6.dist-info/entry_points.txt,sha256=_QnaPOvJNA3IltxmZgWIiBoen-L1bPYX18YQfC7oJgQ,41
-napistu-0.4.6.dist-info/top_level.txt,sha256=Gpvk0a_PjrtqhYcQ9IDr3zR5LqpZ-uIHidQMIpjlvhY,14
-napistu-0.4.6.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_DICT_KEYS, 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):
@@ -87,6 +93,7 @@ def test_find_and_prune_neighborhoods_with_source_counts(
             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"]
@@ -139,3 +146,85 @@ def test_find_and_prune_neighborhoods_with_source_counts(
         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_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