napistu 0.1.0__py3-none-any.whl

tests/test_mechanism_matching.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+import pandas as pd
+
+from napistu import mechanism_matching
+from napistu.network import net_create
+from napistu.network import precompute
+
+
+def test_features_to_pathway_species(sbml_dfs):
+
+    species_identifiers = sbml_dfs.get_identifiers("species")
+    feature_identifiers = pd.DataFrame({"chebis": ["17627", "15379", "29105", "-1"]})
+
+    matching_df = (
+        mechanism_matching.features_to_pathway_species(
+            feature_identifiers, species_identifiers, {"chebi"}, "chebis"
+        )
+        .value_counts("identifier")
+        .sort_index()
+    )
+
+    assert matching_df.index.tolist() == ["15379", "17627", "29105"]
+    assert matching_df.tolist() == [2, 3, 2]
+
+
+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 = mechanism_matching.edgelist_to_pathway_species(
+        edgelist, species_identifiers, ontologies={"chebi", "uniprot"}
+    )
+    assert edgelist_w_sids.shape == (4, 4)
+
+    egelist_w_scids = mechanism_matching.edgelist_to_scids(
+        edgelist, sbml_dfs, species_identifiers, ontologies={"chebi"}
+    )
+
+    assert egelist_w_scids.shape == (12, 6)
+
+    direct_interactions = mechanism_matching.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):
+
+    cpr_graph = net_create.process_cpr_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 = mechanism_matching.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 = (
+        mechanism_matching.filter_to_indirect_mechanistic_interactions(
+            formatted_edgelist=edgelist,
+            sbml_dfs=sbml_dfs_glucose_metabolism,
+            species_identifiers=species_identifiers,
+            cpr_graph=cpr_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(
+        cpr_graph, weights_vars=["weights"]
+    )
+
+    indirect_interactions_w_precompute = (
+        mechanism_matching.filter_to_indirect_mechanistic_interactions(
+            formatted_edgelist=edgelist,
+            sbml_dfs=sbml_dfs_glucose_metabolism,
+            species_identifiers=species_identifiers,
+            cpr_graph=cpr_graph,
+            ontologies={"chebi"},
+            precomputed_distances=precomputed_distances,
+            max_path_length=10,
+        )
+    )
+
+    assert all(
+        indirect_interactions["weight"] == indirect_interactions_w_precompute["weight"]
+    )

tests/test_net_utils.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+import pytest
+
+import igraph as ig
+import pandas as pd
+from napistu.network import net_utils
+from napistu.network import net_create
+
+
+def test_safe_fill():
+    safe_fill_test = ["a_very_long stringggg", ""]
+    assert [net_utils.safe_fill(x) for x in safe_fill_test] == [
+        "a_very_long\nstringggg",
+        "",
+    ]
+
+
+def test_cpr_graph_to_pandas_dfs():
+    graph_data = [
+        (0, 1),
+        (0, 2),
+        (2, 3),
+        (3, 4),
+        (4, 2),
+        (2, 5),
+        (5, 0),
+        (6, 3),
+        (5, 6),
+    ]
+
+    g = ig.Graph(graph_data, directed=True)
+    vs, es = net_utils.cpr_graph_to_pandas_dfs(g)
+
+    assert all(vs["index"] == list(range(0, 7)))
+    assert (
+        pd.DataFrame(graph_data)
+        .rename({0: "source", 1: "target"}, axis=1)
+        .sort_values(["source", "target"])
+        .equals(es.sort_values(["source", "target"]))
+    )
+
+
+def test_validate_graph_attributes(sbml_dfs):
+
+    cpr_graph = net_create.process_cpr_graph(
+        sbml_dfs, directed=True, weighting_strategy="topology"
+    )
+
+    assert (
+        net_utils._validate_edge_attributes(cpr_graph, ["weights", "upstream_weights"])
+        is None
+    )
+    assert net_utils._validate_vertex_attributes(cpr_graph, "node_type") is None
+    with pytest.raises(ValueError):
+        net_utils._validate_vertex_attributes(cpr_graph, "baz")
+
+
+################################################
+# __main__
+################################################
+
+if __name__ == "__main__":
+    test_safe_fill()
+    test_cpr_graph_to_pandas_dfs()
+    test_validate_graph_attributes()

tests/test_netcontextr.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+import pandas as pd
+import pytest
+from napistu import sbml_dfs_core
+from napistu.identifiers import Identifiers
+from napistu.rpy2 import netcontextr
+from napistu.source import Source
+
+
+@pytest.fixture
+def sbml_dfs_one_reaction():
+    """An sbml_dfs with one reaction and one annotated reactant"""
+    interaction_edgelist = pd.DataFrame(
+        {
+            "upstream_name": ["a"],
+            "downstream_name": ["b"],
+            "upstream_compartment": ["nucleoplasm"],
+            "downstream_compartment": ["nucleoplasm"],
+            "r_name": ["a b of a"],
+            "sbo_term": ["SBO:0000010"],
+            "r_Identifiers": Identifiers([]),
+            "r_isreversible": False,
+        }
+    )
+    species = pd.DataFrame(
+        {
+            "s_name": ["a", "b"],
+            "s_Identifiers": [
+                Identifiers([{"ontology": "ensembl_gene", "identifier": "test"}]),
+                Identifiers([]),
+            ],
+        }
+    )
+    compartments = pd.DataFrame(
+        {"c_name": ["nucleoplasm"], "c_Identifiers": Identifiers([])}
+    )
+    interaction_source = Source(init=True)
+    sbml_dfs = sbml_dfs_core.sbml_dfs_from_edgelist(
+        interaction_edgelist, species, compartments, interaction_source
+    )
+    return sbml_dfs
+
+
+@pytest.fixture
+def sbml_dfs_one_reaction_duplicated_identifiers():
+    """
+    An sbml_dfs with one reactions and one annotated reactant
+    that has two identifiers
+    """
+    interaction_edgelist = pd.DataFrame(
+        {
+            "upstream_name": ["a"],
+            "downstream_name": ["b"],
+            "upstream_compartment": ["nucleoplasm"],
+            "downstream_compartment": ["nucleoplasm"],
+            "r_name": ["a b of a"],
+            "sbo_term": ["SBO:0000010"],
+            "r_Identifiers": Identifiers([]),
+            "r_isreversible": False,
+        }
+    )
+    species = pd.DataFrame(
+        {
+            "s_name": ["a", "b"],
+            "s_Identifiers": [
+                Identifiers(
+                    [
+                        {"ontology": "ensembl_gene", "identifier": "test"},
+                        {"ontology": "ensembl_gene", "identifier": "test2"},
+                    ]
+                ),
+                Identifiers([]),
+            ],
+        }
+    )
+    compartments = pd.DataFrame(
+        {"c_name": ["nucleoplasm"], "c_Identifiers": Identifiers([])}
+    )
+    interaction_source = Source(init=True)
+    sbml_dfs = sbml_dfs_core.sbml_dfs_from_edgelist(
+        interaction_edgelist, species, compartments, interaction_source
+    )
+    return sbml_dfs
+
+
+def test_get_reactions_one_reaction(sbml_dfs_one_reaction):
+    reactions = netcontextr._get_reactions(sbml_dfs_one_reaction)
+    assert not reactions[netcontextr.COL_GENE].isna().any()
+    assert reactions.shape[0] == 1
+
+
+def test_get_reactions_outcols(sbml_dfs_one_reaction):
+    reactions = netcontextr._get_reactions(sbml_dfs_one_reaction)
+    assert netcontextr.COL_GENE in reactions.columns
+    assert netcontextr.COL_REACTION_ID in reactions.columns
+    assert netcontextr.COL_ROLE in reactions.columns
+
+
+def test_get_reactions_one_reaction_duplicated_ids(
+    sbml_dfs_one_reaction_duplicated_identifiers,
+):
+    reactions = netcontextr._get_reactions(sbml_dfs_one_reaction_duplicated_identifiers)
+    assert not reactions[netcontextr.COL_GENE].isna().any()
+    assert reactions.shape[0] == 2

tests/test_obo.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from napistu.ingestion import obo
+
+
+def test_formatting_obo_attributes():
+    assert obo._format_entry_tuple("foo: bar: baz") == ("foo", "bar: baz")
+    assert obo._format_entry_tuple("foo") is None
+
+
+def test_formatting_go_isa_attributes():
+    go_parents_test_entries = [
+        ([], list()),
+        (["foo ! bar"], [{"parent_id": "foo", "parent_name": "bar"}]),
+        (
+            ["foo ! bar", "fun ! baz"],
+            [
+                {"parent_id": "foo", "parent_name": "bar"},
+                {"parent_id": "fun", "parent_name": "baz"},
+            ],
+        ),
+    ]
+
+    for val_list, expected in go_parents_test_entries:
+        assert obo._isa_str_list_to_dict_list(val_list) == expected
+
+
+################################################
+# __main__
+################################################
+
+if __name__ == "__main__":
+    test_formatting_obo_attributes()
+    test_formatting_go_isa_attributes()

tests/test_pathwayannot.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import os
+
+from napistu.modify import pathwayannot
+
+from napistu.constants import SBML_DFS
+from napistu.modify.constants import COFACTOR_SCHEMA
+from napistu.modify.constants import COFACTOR_CHEBI_IDS
+
+test_path = os.path.abspath(os.path.join(__file__, os.pardir))
+test_data = os.path.join(test_path, "test_data")
+reduced_neo4j_members_path = os.path.join(test_data, "reduced_neo4j_members.csv")
+reduced_neo4j_cross_refs_path = os.path.join(test_data, "reduced_neo4j_members.csv")
+
+
+def test_cofactor_specifications():
+    # cofactors are manually annotated with their ChEBI ID so that they can be matched
+    # to the corresponding ChEBI ID of molecular species
+
+    cofactor_labels_set = set(COFACTOR_CHEBI_IDS["cofactor"].tolist())
+
+    deep_cofactor_list = [list(v.values()) for v in COFACTOR_SCHEMA.values()]
+    shallow_cofactor_list = [item for sublist in deep_cofactor_list for item in sublist]
+    unique_cofactors = {item for sublist in shallow_cofactor_list for item in sublist}
+
+    # check whether all species in cofactor schema are tied with an ID
+    undefined_labels = unique_cofactors.difference(cofactor_labels_set)
+    if len(undefined_labels) != 0:
+        raise ValueError(
+            f"{', '.join(undefined_labels)} are not defined in \"COFACTOR_CHEBI_IDS\""
+        )
+
+
+def test_add_reactome_entity_sets(sbml_dfs_glucose_metabolism):
+
+    # annotate the GPCR sbml_df with a reduced subset of the
+    # Reactome entity set exports
+
+    sbml_dfs_with_entity_sets = pathwayannot.add_entity_sets(
+        sbml_dfs_glucose_metabolism, reduced_neo4j_members_path
+    )
+
+    lost_species = set(sbml_dfs_glucose_metabolism.species[SBML_DFS.S_NAME]).difference(
+        sbml_dfs_with_entity_sets.species[SBML_DFS.S_NAME]
+    )
+    assert len(lost_species) == 0
+    new_species = set(sbml_dfs_with_entity_sets.species[SBML_DFS.S_NAME]).difference(
+        sbml_dfs_glucose_metabolism.species[SBML_DFS.S_NAME]
+    )
+    assert new_species == {
+        "HK1",
+        "HK2",
+        "HK3",
+        "PRKACA",
+        "PRKACB",
+        "PRKACG",
+        "SLC25A12",
+        "SLC25A13",
+        "SLC37A1",
+    }
+
+    lost_reactions = set(
+        sbml_dfs_glucose_metabolism.reactions[SBML_DFS.R_NAME]
+    ).difference(sbml_dfs_with_entity_sets.reactions[SBML_DFS.R_NAME])
+    assert len(lost_reactions) == 0
+    new_reactions = set(
+        sbml_dfs_with_entity_sets.reactions[SBML_DFS.R_NAME]
+    ).difference(sbml_dfs_glucose_metabolism.reactions[SBML_DFS.R_NAME])
+    assert len(new_reactions) == 10
+
+
+def test_add_reactome_cross_refs(sbml_dfs_glucose_metabolism):
+
+    # test adding cross-references to a Reactome model
+
+    sbml_dfs_with_cross_refs = pathwayannot.add_reactome_identifiers(
+        sbml_dfs_glucose_metabolism,
+        os.path.join(test_data, "reduced_neo4j_cross_refs.csv"),
+    )
+
+    sbml_dfs_glucose_metabolism.reaction_species.shape[
+        0
+    ] == sbml_dfs_with_cross_refs.reaction_species.shape[0]
+
+    previous_species_identifiers = sbml_dfs_glucose_metabolism.get_identifiers(
+        SBML_DFS.SPECIES
+    )
+    updated_species_identifiers = sbml_dfs_with_cross_refs.get_identifiers(
+        SBML_DFS.SPECIES
+    )
+    assert (
+        updated_species_identifiers.shape[0] - previous_species_identifiers.shape[0]
+        == 88
+    )

tests/test_precomputed_distances.py

@@ -0,0 +1,222 @@
+from __future__ import annotations
+
+import os
+
+import numpy as np
+import pandas as pd
+from napistu import sbml_dfs_core
+from napistu.ingestion import sbml
+from napistu.network import neighborhoods
+from napistu.network import net_create
+from napistu.network import paths
+from napistu.network import precompute
+
+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):
+    raise ValueError(f"{sbml_path} not found")
+
+sbml_model = sbml.SBML(sbml_path).model
+sbml_dfs = sbml_dfs_core.SBML_dfs(sbml_model)
+sbml_dfs.validate()
+
+cpr_graph = net_create.process_cpr_graph(
+    sbml_dfs, graph_type="bipartite", directed=True, weighting_strategy="topology"
+)
+
+# number of species to include when finding all x all paths
+N_SPECIES = 12
+
+# setting for neighborhoods
+NETWORK_TYPE = "hourglass"
+ORDER = 20
+TOP_N = 20
+
+precomputed_distances = precompute.precompute_distances(
+    cpr_graph, max_steps=30000, max_score_q=1
+)
+
+
+def test_precomputed_distances():
+    assert precomputed_distances.shape == (3934, 5)
+
+
+def test_precomputed_distances_shortest_paths():
+    cspecies_subset = sbml_dfs.compartmentalized_species.index.tolist()[0:N_SPECIES]
+
+    # we should get the same answer for shortest paths whether or not we use pre-computed distances
+    all_species_pairs = pd.DataFrame(
+        np.array([(x, y) for x in cspecies_subset for y in cspecies_subset]),
+        columns=["sc_id_origin", "sc_id_dest"],
+    )
+
+    (
+        path_vertices,
+        _,
+        _,
+        _,
+    ) = paths.find_all_shortest_reaction_paths(cpr_graph, sbml_dfs, all_species_pairs)
+
+    shortest_path_weights = (
+        path_vertices.groupby(["origin", "dest", "path"])["weights"]
+        .sum()
+        .reset_index()
+        .sort_values("weights")
+        .groupby(["origin", "dest"])
+        .first()
+        .reset_index()
+    )
+
+    precomputed_distance_subset_mask = [
+        True if x and y else False
+        for x, y in zip(
+            precomputed_distances["sc_id_origin"].isin(cspecies_subset).tolist(),
+            precomputed_distances["sc_id_dest"].isin(cspecies_subset).tolist(),
+        )
+    ]
+    precomputed_distance_subset = precomputed_distances[
+        precomputed_distance_subset_mask
+    ]
+
+    path_method_comparison_full_merge = shortest_path_weights.merge(
+        precomputed_distance_subset,
+        left_on=["origin", "dest"],
+        right_on=["sc_id_origin", "sc_id_dest"],
+        how="outer",
+    )
+
+    # tables have identical pairs with a valid path
+    assert (
+        path_method_comparison_full_merge.shape[0]
+        == precomputed_distance_subset.shape[0]
+    )
+    assert path_method_comparison_full_merge.shape[0] == shortest_path_weights.shape[0]
+    assert all(
+        abs(
+            path_method_comparison_full_merge["weights"]
+            - path_method_comparison_full_merge["path_weights"]
+        )
+        < 1e-13
+    )
+
+    # using the precomputed distances generates the same result as excluding it
+    (precompute_path_vertices, _, _, _) = paths.find_all_shortest_reaction_paths(
+        cpr_graph,
+        sbml_dfs,
+        all_species_pairs,
+        precomputed_distances=precomputed_distances,
+    )
+
+    precompute_shortest_path_weights = (
+        precompute_path_vertices.groupby(["origin", "dest", "path"])["weights"]
+        .sum()
+        .reset_index()
+        .sort_values("weights")
+        .groupby(["origin", "dest"])
+        .first()
+        .reset_index()
+    )
+
+    precompute_full_merge = shortest_path_weights.merge(
+        precompute_shortest_path_weights,
+        left_on=["origin", "dest", "path"],
+        right_on=["origin", "dest", "path"],
+        how="outer",
+    )
+
+    assert precompute_full_merge.shape[0] == precompute_shortest_path_weights.shape[0]
+    assert precompute_full_merge.shape[0] == shortest_path_weights.shape[0]
+    assert all(
+        abs(precompute_full_merge["weights_x"] - precompute_full_merge["weights_y"])
+        < 1e-13
+    )
+
+
+def test_precomputed_distances_neighborhoods():
+    compartmentalized_species = sbml_dfs.compartmentalized_species[
+        sbml_dfs.compartmentalized_species["s_id"] == "S00000000"
+    ].index.tolist()
+
+    pruned_neighborhoods_precomputed = neighborhoods.find_and_prune_neighborhoods(
+        sbml_dfs,
+        cpr_graph,
+        compartmentalized_species,
+        precomputed_distances=precomputed_distances,
+        network_type=NETWORK_TYPE,
+        order=ORDER,
+        verbose=True,
+        top_n=TOP_N,
+    )
+
+    pruned_neighborhoods_otf = neighborhoods.find_and_prune_neighborhoods(
+        sbml_dfs,
+        cpr_graph,
+        compartmentalized_species,
+        precomputed_distances=None,
+        network_type=NETWORK_TYPE,
+        order=ORDER,
+        verbose=True,
+        top_n=TOP_N,
+    )
+
+    comparison_l = list()
+    for key in pruned_neighborhoods_precomputed.keys():
+        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"]]
+        neighbor_comparison = (
+            pruned_vert_precomp[join_key_w_vars]
+            .assign(in_precompute=True)
+            .merge(
+                pruned_vert_otf[join_key_w_vars].assign(in_otf=True),
+                left_on=join_key,
+                right_on=join_key,
+                how="outer",
+            )
+            .fillna(False)
+        )
+        comparison_l.append(neighbor_comparison.assign(focal_sc_id=key))
+
+    comparison_df = pd.concat(comparison_l)
+    comparison_df_disagreements = comparison_df.query("in_precompute != in_otf")
+
+    # pruned neighborhoods are identical with and without using precalculated neighbors
+    assert comparison_df_disagreements.shape[0] == 0
+
+    # compare shortest paths calculated through neighborhoods with precomputed distances
+    # 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"]
+        .merge(
+            precomputed_distances,
+            left_on=["focal_sc_id", "name"],
+            right_on=["sc_id_origin", "sc_id_dest"],
+        )
+        .query("abs(path_weight_x - path_weights) > 1e-13")
+    )
+
+    upstream_disagreement_w_precompute = (
+        comparison_df[comparison_df["node_orientation"] == "upstream"]
+        .merge(
+            precomputed_distances,
+            left_on=["focal_sc_id", "name"],
+            right_on=["sc_id_dest", "sc_id_origin"],
+        )
+        .query("abs(path_weight_x - path_upstream_weights) > 1e-13")
+    )
+
+    assert downstream_disagreement_w_precompute.shape[0] == 0
+    assert upstream_disagreement_w_precompute.shape[0] == 0
+
+
+################################################
+# __main__
+################################################
+
+if __name__ == "__main__":
+    test_precomputed_distances()
+    test_precomputed_distances_shortest_paths()
+    test_precomputed_distances_neighborhoods()