napistu 0.3.1.dev1__tar.gz → 0.3.2.dev1__tar.gz

{napistu-0.3.1.dev1 → napistu-0.3.2.dev1}/PKG-INFO

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

{napistu-0.3.1.dev1 → napistu-0.3.2.dev1}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = napistu
-version = 0.3.1.dev1
+version = 0.3.2.dev1
 description = Connecting high-dimensional data to curated pathways
 long_description = file: README.md
 long_description_content_type = text/markdown

{napistu-0.3.1.dev1 → napistu-0.3.2.dev1}/src/napistu/__main__.py

@@ -753,7 +753,7 @@ def export_precomputed_distances(
         weights_vars=weights_vars_list,
     )
 
-    utils.save_json(output_uri, precomputed_distances.to_json())
+    precompute.save_precomputed_distances(precomputed_distances, output_uri)
 
 
 @exporter.command(name="export_smbl_dfs_tables")

{napistu-0.3.1.dev1 → napistu-0.3.2.dev1}/src/napistu/network/precompute.py

@@ -2,12 +2,16 @@ from __future__ import annotations
 
 import logging
 import math
+from pathlib import Path
+from typing import Union
 
 import numpy as np
 import pandas as pd
+from fs.errors import ResourceNotFound
 
 from napistu.network.napistu_graph_core import NapistuGraph
 from napistu.network.ig_utils import validate_edge_attributes
+from napistu.utils import load_json, save_json
 
 logger = logging.getLogger(__name__)
 
@@ -75,21 +79,17 @@ def precompute_distances(
     # interate through all partitions of "from" nodes and find their shortest and lowest weighted paths
     unique_partitions = vs_to_partition.index.unique().tolist()
 
-    precomputed_distances = (
-        pd.concat(
-            [
-                _calculate_distances_subset(
-                    napistu_graph,
-                    vs_to_partition,
-                    vs_to_partition.loc[uq_part],
-                    weights_vars=weights_vars,
-                )
-                for uq_part in unique_partitions
-            ]
-        )
-        .reset_index(drop=True)
-        .query("sc_id_origin != sc_id_dest")
-    )
+    precomputed_distances = pd.concat(
+        [
+            _calculate_distances_subset(
+                napistu_graph,
+                vs_to_partition,
+                vs_to_partition.loc[uq_part],
+                weights_vars=weights_vars,
+            )
+            for uq_part in unique_partitions
+        ]
+    ).query("sc_id_origin != sc_id_dest")
 
     # filter by path length and/or weight
     filtered_precomputed_distances = _filter_precomputed_distances(
@@ -97,11 +97,59 @@ def precompute_distances(
         max_steps=max_steps,
         max_score_q=max_score_q,
         path_weights_vars=["path_" + w for w in weights_vars],
-    )
+    ).reset_index(drop=True)
 
     return filtered_precomputed_distances
 
 
+def save_precomputed_distances(
+    precomputed_distances: pd.DataFrame, uri: Union[str, Path]
+) -> None:
+    """
+    Save a precomputed distances DataFrame to a JSON file.
+
+    Parameters
+    ----------
+    precomputed_distances : pd.DataFrame
+        The precomputed distances DataFrame to save
+    uri : Union[str, Path]
+        Path where to save the JSON file. Can be a local path or a GCS URI.
+
+    Raises
+    ------
+    OSError
+        If the file cannot be written to (permission issues, etc.)
+    """
+    save_json(str(uri), precomputed_distances.to_dict(orient="index"))
+
+
+def load_precomputed_distances(uri: Union[str, Path]) -> pd.DataFrame:
+    """
+    Load a precomputed distances DataFrame from a JSON file.
+
+    Parameters
+    ----------
+    uri : Union[str, Path]
+        Path to the JSON file to load
+
+    Returns
+    -------
+    pd.DataFrame
+        The reconstructed precomputed distances DataFrame
+
+    Raises
+    ------
+    FileNotFoundError
+        If the specified file does not exist
+    """
+    try:
+        data_dict = load_json(str(uri))
+    except ResourceNotFound as e:
+        raise FileNotFoundError(f"File not found: {uri}") from e
+
+    return pd.DataFrame.from_dict(data_dict, orient="index").rename(index=int)
+
+
 def _calculate_distances_subset(
     napistu_graph: NapistuGraph,
     vs_to_partition: pd.DataFrame,

{napistu-0.3.1.dev1 → napistu-0.3.2.dev1}/src/napistu.egg-info/PKG-INFO

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

{napistu-0.3.1.dev1 → napistu-0.3.2.dev1}/src/napistu.egg-info/SOURCES.txt

@@ -111,11 +111,11 @@ src/tests/test_matching_species.py
 src/tests/test_mcp_config.py
 src/tests/test_mcp_documentation_utils.py
 src/tests/test_mcp_server.py
-src/tests/test_net_propagation.py
 src/tests/test_network_data_handling.py
 src/tests/test_network_ig_utils.py
 src/tests/test_network_neighborhoods.py
 src/tests/test_network_net_create.py
+src/tests/test_network_net_propagation.py
 src/tests/test_network_ng_utils.py
 src/tests/test_network_paths.py
 src/tests/test_network_precompute.py

{napistu-0.3.1.dev1 → napistu-0.3.2.dev1}/src/tests/test_network_precompute.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
+import pytest
 import os
+import tempfile
 
 import numpy as np
 import pandas as pd
@@ -214,11 +216,59 @@ def test_precomputed_distances_neighborhoods():
     assert upstream_disagreement_w_precompute.shape[0] == 0
 
 
-################################################
-# __main__
-################################################
-
-if __name__ == "__main__":
-    test_precomputed_distances()
-    test_precomputed_distances_shortest_paths()
-    test_precomputed_distances_neighborhoods()
+@pytest.mark.skip_on_windows
+def test_precomputed_distances_serialization():
+    """
+    Test that validates the serialization -> deserialization approach works correctly.
+
+    Notes
+    -----
+    This function creates a sample DataFrame with the structure of precomputed
+    distances data, saves it to a temporary JSON file, loads it back, and
+    validates that all data is preserved correctly through the serialization
+    round-trip.
+    """
+    # Create a sample DataFrame that mimics the precomputed distances structure
+    sample_data = {
+        "sc_id_origin": {
+            1: "SC00000000",
+            3: "SC00000003",
+            4: "SC00000004",
+            5: "SC00000005",
+            6: "SC00000011",
+        },
+        "sc_id_dest": {
+            1: "SC00000001",
+            3: "SC00000001",
+            4: "SC00000001",
+            5: "SC00000001",
+            6: "SC00000001",
+        },
+        "path_length": {1: 1.0, 3: 4.0, 4: 6.0, 5: 6.0, 6: 1.0},
+        "path_upstream_weights": {1: 1.0, 3: 4.0, 4: 6.0, 5: 6.0, 6: 1.0},
+        "path_weights": {1: 1.0, 3: 4.0, 4: 6.0, 5: 6.0, 6: 1.0},
+    }
+
+    # Create original DataFrame
+    original_df = pd.DataFrame(sample_data)
+
+    # Create a temporary file path
+    with tempfile.NamedTemporaryFile(
+        mode="w", suffix=".json", delete=False
+    ) as tmp_file:
+        temp_path = tmp_file.name
+
+    try:
+        # Test serialization
+        precompute.save_precomputed_distances(original_df, temp_path)
+
+        # Test deserialization
+        loaded_df = precompute.load_precomputed_distances(temp_path)
+
+        # Validate that the loaded DataFrame is identical to the original
+        pd.testing.assert_frame_equal(original_df, loaded_df, check_like=True)
+
+    finally:
+        # Clean up the temporary file
+        if os.path.exists(temp_path):
+            os.remove(temp_path)