napistu 0.1.0__py3-none-any.whl

tests/test_rpy2.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+import sys
+from importlib import reload
+from unittest.mock import Mock
+from unittest.mock import patch
+
+import pytest
+
+
+# Patch rpy2_arrow.arrow to avoid ImportError
+# if the R env is not properly set up during testing
+sys.modules["rpy2_arrow.arrow"] = Mock()
+import napistu.rpy2.callr  # noqa: E402
+import napistu.rpy2.rids  # noqa: E402
+
+
+def test_rpy2_has_rpy2_false():
+    with patch.dict("sys.modules", {"rpy2": None}):
+        reload(napistu.rpy2)
+        assert napistu.rpy2.has_rpy2 is False
+        # Test if other napistu.rpy2 modules can be
+        # loaded without rpy2 installed
+        reload(napistu.rpy2.callr)
+        reload(napistu.rpy2.rids)
+
+
+# def test_rpy2_has_rpy2_true():
+#    with patch.dict("sys.modules", {"rpy2": "pytest"}):
+#        reload(napistu.rpy2)
+#        assert napistu.rpy2.has_rpy2 is True
+
+
+@patch("napistu.rpy2.has_rpy2", False)
+def test_warn_if_no_rpy2_false():
+    @napistu.rpy2.warn_if_no_rpy2
+    def test_func():
+        pass
+
+    with pytest.raises(ImportError):
+        test_func()
+
+
+@patch("napistu.rpy2.has_rpy2", True)
+def test_warn_if_no_rpy2_true():
+    @napistu.rpy2.warn_if_no_rpy2
+    def test_func():
+        pass
+
+    test_func()
+
+
+################################################
+# __main__
+################################################
+
+if __name__ == "__main__":
+    test_rpy2_has_rpy2_false()
+    # test_rpy2_has_rpy2_true()
+    test_warn_if_no_rpy2_false()
+    test_warn_if_no_rpy2_true()

tests/test_sbml.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import os
+
+import pandas as pd
+from napistu import sbml_dfs_core
+from napistu.ingestion import sbml
+
+
+def test_sbml_dfs(sbml_path):
+    sbml_model = sbml.SBML(sbml_path)
+    _ = sbml_model.model
+
+    dfs = sbml_dfs_core.SBML_dfs(sbml_model)
+    dfs.validate()
+
+    assert type(dfs.get_cspecies_features()) is pd.DataFrame
+    assert type(dfs.get_species_features()) is pd.DataFrame
+    assert type(dfs.get_identifiers("species")) is pd.DataFrame
+
+
+def test_adding_sbml_annotations(sbml_model):
+    annotations = pd.DataFrame(
+        [
+            {
+                "id": "compartment_12045",
+                "type": "compartment",
+                "uri": "http://identifiers.org/chebi/CHEBI:00000",
+            },
+            {
+                "id": "species_9033251",
+                "type": "species",
+                "uri": "http://identifiers.org/bigg.metabolite/fakemet",
+            },
+            {
+                "id": "species_9033251",
+                "type": "species",
+                "uri": "http://identifiers.org/chebi/CHEBI:00000",
+            },
+        ]
+    )
+
+    outpath = "/tmp/tmp_write_test.sbml"
+
+    sbml.add_sbml_annotations(sbml_model, annotations, save_path=outpath)
+    assert os.path.isfile(outpath) is True

tests/test_sbml_dfs_create.py

@@ -0,0 +1,307 @@
+from __future__ import annotations
+
+import os
+
+import pandas as pd
+import pytest
+from napistu import sbml_dfs_core
+from napistu.ingestion import sbml
+from napistu.modify import pathwayannot
+
+
+def test_drop_cofactors(sbml_dfs):
+    starting_rscs = sbml_dfs.reaction_species.shape[0]
+    reduced_dfs = pathwayannot.drop_cofactors(sbml_dfs)
+
+    assert starting_rscs - reduced_dfs.reaction_species.shape[0] == 20
+
+
+def test_sbml_dfs_from_dict_required(sbml_dfs):
+    val_dict = {k: getattr(sbml_dfs, k) for k in sbml_dfs._required_entities}
+    sbml_dfs2 = sbml_dfs_core.SBML_dfs(val_dict)
+    sbml_dfs2.validate()
+
+    for k in sbml_dfs._required_entities:
+        assert getattr(sbml_dfs2, k).equals(getattr(sbml_dfs, k))
+
+
+def test_sbml_dfs_species_data(sbml_dfs):
+    data = pd.DataFrame({"bla": [1, 2, 3]}, index=sbml_dfs.species.iloc[:3].index)
+    sbml_dfs.add_species_data("test", data)
+    sbml_dfs.validate()
+
+
+def test_sbml_dfs_species_data_existing(sbml_dfs):
+    data = pd.DataFrame({"bla": [1, 2, 3]}, index=sbml_dfs.species.iloc[:3].index)
+    sbml_dfs.add_species_data("test", data)
+    with pytest.raises(ValueError):
+        sbml_dfs.add_species_data("test", data)
+
+
+def test_sbml_dfs_species_data_validation(sbml_dfs):
+    data = pd.DataFrame({"bla": [1, 2, 3]})
+    sbml_dfs.species_data["test"] = data
+    with pytest.raises(ValueError):
+        sbml_dfs.validate()
+
+
+def test_sbml_dfs_species_data_missing_idx(sbml_dfs):
+    data = pd.DataFrame({"bla": [1, 2, 3]})
+    with pytest.raises(ValueError):
+        sbml_dfs.add_species_data("test", data)
+
+
+def test_sbml_dfs_species_data_duplicated_idx(sbml_dfs):
+    an_s_id = sbml_dfs.species.iloc[0].index[0]
+    dup_idx = pd.Series([an_s_id, an_s_id], name="s_id")
+    data = pd.DataFrame({"bla": [1, 2]}, index=dup_idx)
+
+    with pytest.raises(ValueError):
+        sbml_dfs.add_species_data("test", data)
+
+
+def test_sbml_dfs_species_data_wrong_idx(sbml_dfs):
+    data = pd.DataFrame(
+        {"bla": [1, 2, 3]}, index=pd.Series(["bla1", "bla2", "bla3"], name="s_id")
+    )
+    with pytest.raises(ValueError):
+        sbml_dfs.add_species_data("test", data)
+
+
+def test_sbml_dfs_reactions_data(sbml_dfs):
+    reactions_data = pd.DataFrame(
+        {"bla": [1, 2, 3]}, index=sbml_dfs.reactions.iloc[:3].index
+    )
+    sbml_dfs.add_reactions_data("test", reactions_data)
+    sbml_dfs.validate()
+
+
+def test_sbml_dfs_reactions_data_existing(sbml_dfs):
+    reactions_data = pd.DataFrame(
+        {"bla": [1, 2, 3]}, index=sbml_dfs.reactions.iloc[:3].index
+    )
+    sbml_dfs.add_reactions_data("test", reactions_data)
+    with pytest.raises(ValueError):
+        sbml_dfs.add_reactions_data("test", reactions_data)
+
+
+def test_sbml_dfs_reactions_data_validate(sbml_dfs):
+    data = pd.DataFrame({"bla": [1, 2, 3]})
+    sbml_dfs.reactions_data["test"] = data
+    with pytest.raises(ValueError):
+        sbml_dfs.validate()
+
+
+def test_sbml_dfs_reactions_data_missing_idx(sbml_dfs):
+    data = pd.DataFrame({"bla": [1, 2, 3]})
+    with pytest.raises(ValueError):
+        sbml_dfs.add_reactions_data("test", data)
+
+
+def test_sbml_dfs_reactions_data_duplicated_idx(sbml_dfs):
+    an_r_id = sbml_dfs.reactions.iloc[0].index[0]
+    dup_idx = pd.Series([an_r_id, an_r_id], name="r_id")
+    data = pd.DataFrame({"bla": [1, 2]}, index=dup_idx)
+    with pytest.raises(ValueError):
+        sbml_dfs.add_reactions_data("test", data)
+
+
+def test_sbml_dfs_reactions_data_wrong_idx(sbml_dfs):
+    data = pd.DataFrame(
+        {"bla": [1, 2, 3]}, index=pd.Series(["bla1", "bla2", "bla3"], name="r_id")
+    )
+    with pytest.raises(ValueError):
+        sbml_dfs.add_reactions_data("test", data)
+
+
+def test_sbml_dfs_remove_species_check_species(sbml_dfs):
+    s_id = [sbml_dfs.species.index[0]]
+    sbml_dfs._remove_species(s_id)
+    assert s_id[0] not in sbml_dfs.species.index
+    sbml_dfs.validate()
+
+
+def test_sbml_dfs_remove_species_check_cspecies(sbml_dfs):
+    s_id = [sbml_dfs.compartmentalized_species["s_id"].iloc[0]]
+    sbml_dfs._remove_species(s_id)
+    assert s_id[0] not in sbml_dfs.compartmentalized_species.index
+    sbml_dfs.validate()
+
+
+@pytest.fixture
+def sbml_dfs_w_data(sbml_dfs):
+    sbml_dfs.add_species_data(
+        "test_species",
+        pd.DataFrame({"test1": [1, 2]}, index=sbml_dfs.species.index[:2]),
+    )
+    sbml_dfs.add_reactions_data(
+        "test_reactions",
+        pd.DataFrame({"test2": [1, 2, 3]}, index=sbml_dfs.reactions.index[:3]),
+    )
+    return sbml_dfs
+
+
+def test_sbml_dfs_remove_species_check_data(sbml_dfs_w_data):
+    data = list(sbml_dfs_w_data.species_data.values())[0]
+    s_id = [data.index[0]]
+    sbml_dfs_w_data._remove_species(s_id)
+    data_2 = list(sbml_dfs_w_data.species_data.values())[0]
+    assert s_id[0] not in data_2.index
+    sbml_dfs_w_data.validate()
+
+
+def test_sbml_dfs_remove_cspecies_check_cspecies(sbml_dfs):
+    s_id = [sbml_dfs.compartmentalized_species.index[0]]
+    sbml_dfs._remove_compartmentalized_species(s_id)
+    assert s_id[0] not in sbml_dfs.compartmentalized_species.index
+    sbml_dfs.validate()
+
+
+def test_sbml_dfs_remove_cspecies_check_reaction_species(sbml_dfs):
+    sc_id = [sbml_dfs.reaction_species["sc_id"].iloc[0]]
+    sbml_dfs._remove_compartmentalized_species(sc_id)
+    assert sc_id[0] not in sbml_dfs.reaction_species["sc_id"]
+    sbml_dfs.validate()
+
+
+def test_sbml_dfs_remove_reactions_check_reactions(sbml_dfs):
+    r_id = [sbml_dfs.reactions.index[0]]
+    sbml_dfs.remove_reactions(r_id)
+    assert r_id[0] not in sbml_dfs.reactions.index
+    sbml_dfs.validate()
+
+
+def test_sbml_dfs_remove_reactions_check_reaction_species(sbml_dfs):
+    r_id = [sbml_dfs.reaction_species["r_id"].iloc[0]]
+    sbml_dfs.remove_reactions(r_id)
+    assert r_id[0] not in sbml_dfs.reaction_species["r_id"]
+    sbml_dfs.validate()
+
+
+def test_sbml_dfs_remove_reactions_check_data(sbml_dfs_w_data):
+    data = list(sbml_dfs_w_data.reactions_data.values())[0]
+    r_id = [data.index[0]]
+    sbml_dfs_w_data.remove_reactions(r_id)
+    data_2 = list(sbml_dfs_w_data.reactions_data.values())[0]
+    assert r_id[0] not in data_2.index
+    sbml_dfs_w_data.validate()
+
+
+def test_sbml_dfs_remove_reactions_check_species(sbml_dfs):
+    # find all r_ids for a species and check if
+    # removing all these reactions also removes the species
+    s_id = sbml_dfs.species.index[0]
+    dat = (
+        sbml_dfs.compartmentalized_species.query("s_id == @s_id").merge(
+            sbml_dfs.reaction_species, on="sc_id"
+        )
+    )[["r_id", "sc_id"]]
+    r_ids = dat["r_id"]
+    sc_ids = dat["sc_id"]
+    sbml_dfs.remove_reactions(r_ids, remove_species=True)
+    for sc_id in sc_ids:
+        assert sc_id not in sbml_dfs.compartmentalized_species.index
+    assert s_id not in sbml_dfs.species.index
+
+
+def test_formula(sbml_dfs):
+    # create a formula string
+
+    an_r_id = sbml_dfs.reactions.index[0]
+
+    reaction_species_df = sbml_dfs.reaction_species[
+        sbml_dfs.reaction_species["r_id"] == an_r_id
+    ].merge(sbml_dfs.compartmentalized_species, left_on="sc_id", right_index=True)
+
+    formula_str = sbml_dfs_core.construct_formula_string(
+        reaction_species_df, sbml_dfs.reactions, name_var="sc_name"
+    )
+
+    assert isinstance(formula_str, str)
+    assert (
+        formula_str
+        == "CO2 [extracellular region] -> CO2 [cytosol] ---- modifiers: AQP1 tetramer [plasma membrane]]"
+    )
+
+
+def test_read_sbml_with_invalid_ids():
+    SBML_W_BAD_IDS = "R-HSA-166658.sbml"
+    test_path = os.path.abspath(os.path.join(__file__, os.pardir))
+    sbml_w_bad_ids_path = os.path.join(test_path, "test_data", SBML_W_BAD_IDS)
+    assert os.path.isfile(sbml_w_bad_ids_path)
+
+    # invalid identifiers still create a valid sbml_dfs
+    sbml_w_bad_ids = sbml.SBML(sbml_w_bad_ids_path)
+    assert isinstance(sbml_dfs_core.SBML_dfs(sbml_w_bad_ids), sbml_dfs_core.SBML_dfs)
+
+
+def test_stubbed_compartment():
+    compartment = sbml_dfs_core._stub_compartments()
+
+    assert compartment["c_Identifiers"][0].ids[0] == {
+        "ontology": "go",
+        "identifier": "GO:0005575",
+        "url": "https://www.ebi.ac.uk/QuickGO/term/GO:0005575",
+        "bqb": "BQB_IS",
+    }
+
+
+def test_get_table(sbml_dfs):
+    assert isinstance(sbml_dfs.get_table("species"), pd.DataFrame)
+    assert isinstance(sbml_dfs.get_table("species", {"id"}), pd.DataFrame)
+
+    # invalid table
+    with pytest.raises(ValueError):
+        sbml_dfs.get_table("foo", {"id"})
+
+    # bad type
+    with pytest.raises(AssertionError):
+        sbml_dfs.get_table("reaction_species", "id")
+
+    # reaction species don't have ids
+    with pytest.raises(ValueError):
+        sbml_dfs.get_table("reaction_species", {"id"})
+
+
+def test_search_by_name(sbml_dfs_metabolism):
+    assert sbml_dfs_metabolism.search_by_name("atp", "species", False).shape[0] == 1
+    assert sbml_dfs_metabolism.search_by_name("pyr", "species").shape[0] == 3
+    assert sbml_dfs_metabolism.search_by_name("kinase", "reactions").shape[0] == 4
+
+
+def test_search_by_id(sbml_dfs_metabolism):
+    identifiers_tbl = sbml_dfs_metabolism.get_identifiers("species")
+    ids, species = sbml_dfs_metabolism.search_by_ids(
+        ["P40926"], "species", identifiers_tbl
+    )
+    assert ids.shape[0] == 1
+    assert species.shape[0] == 1
+
+    ids, species = sbml_dfs_metabolism.search_by_ids(
+        ["57540", "30744"], "species", identifiers_tbl, {"chebi"}
+    )
+    assert ids.shape[0] == 2
+    assert species.shape[0] == 2
+
+    ids, species = sbml_dfs_metabolism.search_by_ids(
+        ["baz"], "species", identifiers_tbl
+    )
+    assert ids.shape[0] == 0
+    assert species.shape[0] == 0
+
+
+def test_species_status(sbml_dfs):
+
+    species = sbml_dfs.species
+    select_species = species[species["s_name"] == "OxyHbA"]
+    assert select_species.shape[0] == 1
+
+    status = sbml_dfs_core.species_status(select_species.index[0], sbml_dfs)
+    assert (
+        status["r_formula_str"][0]
+        == "4.0 H+ + OxyHbA + 4.0 CO2 -> 4.0 O2 + Protonated Carbamino DeoxyHbA [cytosol]"
+    )
+
+
+# if __name__ == "__main__":
+#   test_get_table()

tests/test_sbml_dfs_utils.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from napistu import sbml_dfs_utils
+
+
+def test_id_formatter():
+    input_vals = range(50, 100)
+
+    # create standard IDs
+    ids = sbml_dfs_utils.id_formatter(input_vals, "s_id", id_len=8)
+    # invert standard IDs
+    inv_ids = sbml_dfs_utils.id_formatter_inv(ids)
+
+    assert list(input_vals) == inv_ids
+
+
+################################################
+# __main__
+################################################
+
+if __name__ == "__main__":
+    test_id_formatter()

tests/test_sbo.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from napistu.constants import MINI_SBO_FROM_NAME
+from napistu.constants import MINI_SBO_TO_NAME
+
+
+def test_sbo_to_from_name():
+    assert len(MINI_SBO_TO_NAME) == len(MINI_SBO_FROM_NAME)
+
+    for k, v in MINI_SBO_FROM_NAME.items():
+        assert MINI_SBO_TO_NAME[v] == k

tests/test_set_coverage.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from napistu import source
+from napistu.network import net_utils
+
+
+def test_get_minimal_source_edges(sbml_dfs_metabolism):
+    vertices = sbml_dfs_metabolism.reactions.reset_index().rename(
+        columns={"r_id": "node"}
+    )
+
+    minimal_source_edges = net_utils.get_minimal_sources_edges(
+        vertices, sbml_dfs_metabolism
+    )
+    # print(minimal_source_edges.shape)
+    assert minimal_source_edges.shape == (87, 3)
+
+
+def test_greedy_set_coverge_of_sources(sbml_dfs_metabolism):
+    table_schema = sbml_dfs_metabolism.schema["reactions"]
+
+    source_df = source.unnest_sources(
+        sbml_dfs_metabolism.reactions, source_var="r_Source"
+    )
+    # print(source_df.shape)
+    assert source_df.shape == (111, 7)
+
+    set_coverage = source.greedy_set_coverge_of_sources(source_df, table_schema)
+    # print(set_coverage.shape)
+    assert set_coverage.shape == (87, 6)
+
+
+################################################
+# __main__
+################################################
+
+if __name__ == "__main__":
+    import os
+    from napistu import indices
+    from napistu import consensus
+
+    test_path = os.path.abspath(os.path.join(__file__, os.pardir))
+    test_data = os.path.join(test_path, "test_data")
+
+    pw_index = indices.PWIndex(os.path.join(test_data, "pw_index_metabolism.tsv"))
+    sbml_dfs_dict = consensus.construct_sbml_dfs_dict(pw_index)
+    sbml_dfs_metabolism = consensus.construct_consensus_model(sbml_dfs_dict, pw_index)
+
+    test_get_minimal_source_edges(sbml_dfs_metabolism)
+    test_greedy_set_coverge_of_sources(sbml_dfs_metabolism)

tests/test_source.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import os
+
+import pandas as pd
+from napistu import indices
+from napistu import source
+
+test_path = os.path.abspath(os.path.join(__file__, os.pardir))
+test_data = os.path.join(test_path, "test_data")
+
+
+def test_source():
+    source_example_df = pd.DataFrame(
+        [
+            {"model": "fun", "id": "baz", "pathway_id": "fun"},
+            {"model": "fun", "id": "bot", "pathway_id": "fun"},
+            {"model": "time", "id": "boof", "pathway_id": "time"},
+            {"model": "time", "id": "bor", "pathway_id": "time"},
+        ]
+    )
+
+    source_obj = source.Source(source_example_df)
+    source_init = source.Source(init=True)
+
+    assert source.merge_sources([source_init, source_init]) == source_init
+
+    pd._testing.assert_frame_equal(
+        source.merge_sources([source_obj, source_init]).source, source_example_df
+    )
+
+    assert source.merge_sources([source_obj, source_obj]).source.shape[0] == 8
+
+    alt_source_df = pd.DataFrame(
+        [
+            {"model": "fun", "identifier": "baz", "pathway_id": "fun"},
+            {"model": "fun", "identifier": "baz", "pathway_id": "fun"},
+        ]
+    )
+    alt_source_obj = source.Source(alt_source_df)
+
+    assert source.merge_sources([source_obj, alt_source_obj]).source.shape == (6, 4)
+
+
+def test_source_w_pwindex():
+    # pathway_id not provided since this and other attributes will be found
+    # in pw_index.tsv
+    source_example_df = pd.DataFrame(
+        [
+            {"model": "R-HSA-1237044", "id": "baz"},
+            {"model": "R-HSA-1237044", "id": "bot"},
+        ]
+    )
+
+    pw_index = indices.PWIndex(os.path.join(test_data, "pw_index.tsv"))
+
+    source_obj = source.Source(source_example_df, pw_index=pw_index)
+    assert source_obj.source.shape == (2, 8)
+
+
+################################################
+# __main__
+################################################
+
+if __name__ == "__main__":
+    test_source()
+    test_source_w_pwindex()

tests/test_uncompartmentalize.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import os
+
+from napistu import sbml_dfs_core
+from napistu.ingestion import sbml
+from napistu.modify import uncompartmentalize
+
+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")
+
+
+def test_uncompartmentalize():
+    sbml_model = sbml.SBML(sbml_path)
+    sbml_dfs = sbml_dfs_core.SBML_dfs(sbml_model)
+    sbml_dfs.validate()
+
+    assert sbml_dfs.compartmentalized_species.shape[0] == 107
+    assert sbml_dfs.reactions.shape[0] == 50
+    assert sbml_dfs.reaction_species.shape[0] == 250
+
+    uncomp_sbml_dfs = uncompartmentalize.uncompartmentalize_sbml_dfs(sbml_dfs)
+    uncomp_sbml_dfs.validate()
+
+    assert uncomp_sbml_dfs.compartments.shape[0] == 1
+    # assert uncomp_sbml_dfs.species.shape[0] == sbml_dfs.species.shape[0]
+    assert uncomp_sbml_dfs.compartmentalized_species.shape[0] == 80
+    assert uncomp_sbml_dfs.reactions.shape[0] == 47
+    assert uncomp_sbml_dfs.reaction_species.shape[0] == 217
+
+
+################################################
+# __main__
+################################################
+
+if __name__ == "__main__":
+    test_uncompartmentalize()