napistu 0.2.5.dev7__py3-none-any.whl → 0.3.1__py3-none-any.whl

tests/test_set_coverage.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from napistu import source
-from napistu.network import net_utils
+from napistu.network import ng_utils
 
 
 def test_get_minimal_source_edges(sbml_dfs_metabolism):
@@ -9,7 +9,7 @@ def test_get_minimal_source_edges(sbml_dfs_metabolism):
         columns={"r_id": "node"}
     )
 
-    minimal_source_edges = net_utils.get_minimal_sources_edges(
+    minimal_source_edges = ng_utils.get_minimal_sources_edges(
         vertices, sbml_dfs_metabolism
     )
     # print(minimal_source_edges.shape)

tests/test_utils.py

@@ -9,13 +9,13 @@ from unittest.mock import patch
 import numpy as np
 import pandas as pd
 import pytest
-from napistu import utils
 from fs.tarfs import TarFS
 from fs.zipfs import ZipFS
 from google.cloud import storage
 from pytest import fixture
 from testcontainers.core.container import DockerContainer
 
+from napistu import utils
 from napistu.utils import drop_extra_cols
 
 
@@ -556,6 +556,7 @@ def test_drop_extra_cols():
         {"col1": [1, 2, 3], "col3": [7, 8, 9], "col4": [10, 11, 12]}
     )
     result_subset = drop_extra_cols(df_in, df_out_subset)
+
     assert list(result_subset.columns) == ["col1", "col3"]
     pd.testing.assert_frame_equal(result_subset, df_out_subset[["col1", "col3"]])
 
@@ -566,3 +567,122 @@ def test_drop_extra_cols():
     pd.testing.assert_frame_equal(
         result_subset_with_include, df_out_subset[["col1", "col3", "col4"]]
     )
+
+
+def test_merge_and_log_overwrites(caplog):
+    """Test merge_and_log_overwrites function."""
+
+    # Test basic merge with no conflicts
+    df1 = pd.DataFrame({"id": [1, 2], "value1": ["a", "b"]})
+    df2 = pd.DataFrame({"id": [1, 2], "value2": ["c", "d"]})
+    result = utils._merge_and_log_overwrites(df1, df2, "test", on="id")
+    assert set(result.columns) == {"id", "value1", "value2"}
+    assert len(caplog.records) == 0
+
+    # Test merge with column conflict
+    df1 = pd.DataFrame({"id": [1, 2], "name": ["a", "b"], "value": [10, 20]})
+    df2 = pd.DataFrame({"id": [1, 2], "name": ["c", "d"]})
+    result = utils._merge_and_log_overwrites(df1, df2, "test", on="id")
+
+    # Check that the right columns exist
+    assert set(result.columns) == {"id", "name", "value"}
+    # Check that we got df2's values for the overlapping column
+    assert list(result["name"]) == ["c", "d"]
+    # Check that we kept df1's non-overlapping column
+    assert list(result["value"]) == [10, 20]
+    # Check that the warning was logged
+    assert len(caplog.records) == 1
+    assert "test merge" in caplog.records[0].message
+    assert "name" in caplog.records[0].message
+
+    # Test merge with multiple column conflicts
+    caplog.clear()
+    df1 = pd.DataFrame(
+        {"id": [1, 2], "name": ["a", "b"], "value": [10, 20], "status": ["ok", "ok"]}
+    )
+    df2 = pd.DataFrame(
+        {"id": [1, 2], "name": ["c", "d"], "status": ["pending", "done"]}
+    )
+    result = utils._merge_and_log_overwrites(df1, df2, "test", on="id")
+
+    # Check that the right columns exist
+    assert set(result.columns) == {"id", "name", "value", "status"}
+    # Check that we got df2's values for the overlapping columns
+    assert list(result["name"]) == ["c", "d"]
+    assert list(result["status"]) == ["pending", "done"]
+    # Check that we kept df1's non-overlapping column
+    assert list(result["value"]) == [10, 20]
+    # Check that the warning was logged with both column names
+    assert len(caplog.records) == 1
+    assert "test merge" in caplog.records[0].message
+    assert "name" in caplog.records[0].message
+    assert "status" in caplog.records[0].message
+
+    # Test merge with index
+    caplog.clear()
+    df1 = pd.DataFrame({"name": ["a", "b"], "value": [10, 20]}, index=[1, 2])
+    df2 = pd.DataFrame({"name": ["c", "d"]}, index=[1, 2])
+    result = utils._merge_and_log_overwrites(
+        df1, df2, "test", left_index=True, right_index=True
+    )
+
+    # Check that the right columns exist
+    assert set(result.columns) == {"name", "value"}
+    # Check that we got df2's values for the overlapping column
+    assert list(result["name"]) == ["c", "d"]
+    # Check that we kept df1's non-overlapping column
+    assert list(result["value"]) == [10, 20]
+    # Check that the warning was logged
+    assert len(caplog.records) == 1
+    assert "test merge" in caplog.records[0].message
+    assert "name" in caplog.records[0].message
+
+
+def test_matrix_to_edgelist():
+    # Test case 1: Basic functionality with numeric indices
+    matrix = np.array([[1, 2, np.nan], [np.nan, 3, 4], [5, np.nan, 6]])
+    expected_edgelist = pd.DataFrame(
+        {
+            "row": [0, 0, 1, 1, 2, 2],
+            "column": [0, 1, 1, 2, 0, 2],
+            "value": np.array([1, 2, 3, 4, 5, 6], dtype=np.float64),
+        }
+    )
+    result = utils.matrix_to_edgelist(matrix)
+    pd.testing.assert_frame_equal(result, expected_edgelist)
+
+    # Test case 2: With row and column labels
+    row_labels = ["A", "B", "C"]
+    col_labels = ["X", "Y", "Z"]
+    expected_labeled_edgelist = pd.DataFrame(
+        {
+            "row": ["A", "A", "B", "B", "C", "C"],
+            "column": ["X", "Y", "Y", "Z", "X", "Z"],
+            "value": np.array([1, 2, 3, 4, 5, 6], dtype=np.float64),
+        }
+    )
+    result_labeled = utils.matrix_to_edgelist(
+        matrix, row_labels=row_labels, col_labels=col_labels
+    )
+    pd.testing.assert_frame_equal(result_labeled, expected_labeled_edgelist)
+
+    # Test case 3: Empty matrix (all NaN)
+    empty_matrix = np.full((2, 2), np.nan)
+    empty_result = utils.matrix_to_edgelist(empty_matrix)
+    assert empty_result.empty
+
+    # Test case 4: Single value matrix
+    single_matrix = np.array([[1]])
+    expected_single = pd.DataFrame(
+        {"row": [0], "column": [0], "value": np.array([1], dtype=np.int64)}
+    )
+    result_single = utils.matrix_to_edgelist(single_matrix)
+    pd.testing.assert_frame_equal(result_single, expected_single)
+
+
+def test_safe_fill():
+    safe_fill_test = ["a_very_long stringggg", ""]
+    assert [utils.safe_fill(x) for x in safe_fill_test] == [
+        "a_very_long\nstringggg",
+        "",
+    ]