risk-network 0.0.9b26__py3-none-any.whl → 0.0.9b28__py3-none-any.whl

risk/neighborhoods/neighborhoods.py

@@ -9,6 +9,7 @@ from typing import Any, Dict, List, Tuple, Union
 
 import networkx as nx
 import numpy as np
+from scipy.sparse import csr_matrix
 from sklearn.exceptions import DataConversionWarning
 from sklearn.metrics.pairwise import cosine_similarity
 
@@ -34,43 +35,43 @@ def get_network_neighborhoods(
     louvain_resolution: float = 0.1,
     leiden_resolution: float = 1.0,
     random_seed: int = 888,
-) -> np.ndarray:
-    """Calculate the combined neighborhoods for each node based on the specified community detection algorithm(s).
+) -> csr_matrix:
+    """Calculate the combined neighborhoods for each node using sparse matrices.
 
     Args:
         network (nx.Graph): The network graph.
         distance_metric (str, List, Tuple, or np.ndarray, optional): The distance metric(s) to use.
-        fraction_shortest_edges (float, List, Tuple, or np.ndarray, optional): Shortest edge rank fraction threshold(s) for creating subgraphs.
+        fraction_shortest_edges (float, List, Tuple, or np.ndarray, optional): Shortest edge rank fraction thresholds.
         louvain_resolution (float, optional): Resolution parameter for the Louvain method.
         leiden_resolution (float, optional): Resolution parameter for the Leiden method.
         random_seed (int, optional): Random seed for methods requiring random initialization.
 
     Returns:
-        np.ndarray: Summed neighborhood matrix from all selected algorithms.
+        csr_matrix: The combined neighborhood matrix.
     """
     # Set random seed for reproducibility
     random.seed(random_seed)
     np.random.seed(random_seed)
 
-    # Ensure distance_metric is a list/tuple for multi-algorithm handling
+    # Ensure distance_metric is a list for multi-algorithm handling
     if isinstance(distance_metric, (str, np.ndarray)):
         distance_metric = [distance_metric]
-    # Ensure fraction_shortest_edges is a list/tuple for multi-threshold handling
+    # Ensure fraction_shortest_edges is a list for multi-threshold handling
     if isinstance(fraction_shortest_edges, (float, int)):
         fraction_shortest_edges = [fraction_shortest_edges] * len(distance_metric)
-    # Check that the number of distance metrics matches the number of edge length thresholds
+    # Validate matching lengths of distance metrics and thresholds
     if len(distance_metric) != len(fraction_shortest_edges):
         raise ValueError(
             "The number of distance metrics must match the number of edge length thresholds."
         )
 
-    # Initialize combined neighborhood matrix
+    # Initialize a sparse LIL matrix for incremental updates
     num_nodes = network.number_of_nodes()
-    combined_neighborhoods = np.zeros((num_nodes, num_nodes), dtype=int)
-
+    # Initialize a sparse matrix with the same shape as the network
+    combined_neighborhoods = csr_matrix((num_nodes, num_nodes), dtype=np.uint8)
     # Loop through each distance metric and corresponding edge rank fraction
     for metric, percentile in zip(distance_metric, fraction_shortest_edges):
-        # Call the appropriate neighborhood function based on the metric
+        # Compute neighborhoods for the specified metric
         if metric == "greedy_modularity":
             neighborhoods = calculate_greedy_modularity_neighborhoods(
                 network, fraction_shortest_edges=percentile
@@ -107,22 +108,37 @@ def get_network_neighborhoods(
             )
         else:
             raise ValueError(
-                "Incorrect distance metric specified. Please choose from 'greedy_modularity', 'label_propagation',"
+                "Invalid distance metric. Choose from: 'greedy_modularity', 'label_propagation',"
                 "'leiden', 'louvain', 'markov_clustering', 'spinglass', 'walktrap'."
             )
 
-        # Sum the neighborhood matrices
+        # Add the sparse neighborhood matrix
         combined_neighborhoods += neighborhoods
 
-    # Ensure that the maximum value in each row is set to 1
-    # This ensures that for each row, only the strongest relationship (the maximum value) is retained,
-    # while all other values are reset to 0. This transformation simplifies the neighborhood matrix by
-    # focusing on the most significant connection per row (or nodes).
-    combined_neighborhoods = _set_max_row_value_to_one(combined_neighborhoods)
+    # Ensure maximum value in each row is set to 1
+    combined_neighborhoods = _set_max_row_value_to_one_sparse(combined_neighborhoods)
 
     return combined_neighborhoods
 
 
+def _set_max_row_value_to_one_sparse(matrix: csr_matrix) -> csr_matrix:
+    """Set the maximum value in each row of a sparse matrix to 1.
+
+    Args:
+        matrix (csr_matrix): The input sparse matrix.
+
+    Returns:
+        csr_matrix: The modified sparse matrix where only the maximum value in each row is set to 1.
+    """
+    # Iterate over each row and set the maximum value to 1
+    for i in range(matrix.shape[0]):
+        row_data = matrix[i].data
+        if len(row_data) > 0:
+            row_data[:] = (row_data == max(row_data)).astype(int)
+
+    return matrix
+
+
 def _set_max_row_value_to_one(matrix: np.ndarray) -> np.ndarray:
     """For each row in the input matrix, set the maximum value(s) to 1 and all other values to 0. This is particularly
     useful for neighborhood matrices that have undergone multiple neighborhood detection algorithms, where the

risk/network/geometry.py

@@ -3,8 +3,6 @@ risk/network/geometry
 ~~~~~~~~~~~~~~~~~~~~~
 """
 
-import copy
-
 import networkx as nx
 import numpy as np
 
@@ -31,44 +29,43 @@ def assign_edge_lengths(
         """Compute distances between pairs of coordinates."""
         u_coords, v_coords = coords[:, 0, :], coords[:, 1, :]
         if is_sphere:
-            u_norm = np.linalg.norm(u_coords, axis=1, keepdims=True)
-            v_norm = np.linalg.norm(v_coords, axis=1, keepdims=True)
-            u_coords /= u_norm
-            v_coords /= v_norm
+            u_coords /= np.linalg.norm(u_coords, axis=1, keepdims=True)
+            v_coords /= np.linalg.norm(v_coords, axis=1, keepdims=True)
             dot_products = np.einsum("ij,ij->i", u_coords, v_coords)
             return np.arccos(np.clip(dot_products, -1.0, 1.0))
-
         return np.linalg.norm(u_coords - v_coords, axis=1)
 
     # Normalize graph coordinates and weights
     _normalize_graph_coordinates(G)
     _normalize_weights(G)
+
     # Map nodes to sphere and adjust depth if required
     if compute_sphere:
         _map_to_sphere(G)
-        G_depth = _create_depth(copy.deepcopy(G), surface_depth=surface_depth)
+        G_depth = _create_depth(G, surface_depth=surface_depth)
     else:
-        G_depth = copy.deepcopy(G)
-
-    # Precompute edge coordinate arrays for vectorized computation
-    edge_data = []
-    for u, v in G_depth.edges:
-        u_coords = np.array([G_depth.nodes[u]["x"], G_depth.nodes[u]["y"]])
-        v_coords = np.array([G_depth.nodes[v]["x"], G_depth.nodes[v]["y"]])
-        if compute_sphere:
-            u_coords = np.append(u_coords, G_depth.nodes[u].get("z", 0))
-            v_coords = np.append(v_coords, G_depth.nodes[v].get("z", 0))
-        edge_data.append([u_coords, v_coords, (u, v)])
-
-    # Convert to numpy for faster processing
-    edge_coords = np.array([(e[0], e[1]) for e in edge_data])
-    edge_indices = [e[2] for e in edge_data]
-    # Compute distances in bulk
-    distances = compute_distance_vectorized(edge_coords, compute_sphere)
+        G_depth = G
+
+    # Precompute edge coordinate arrays and compute distances in bulk
+    edge_data = np.array(
+        [
+            [
+                np.array(
+                    [G_depth.nodes[u]["x"], G_depth.nodes[u]["y"], G_depth.nodes[u].get("z", 0)]
+                ),
+                np.array(
+                    [G_depth.nodes[v]["x"], G_depth.nodes[v]["y"], G_depth.nodes[v].get("z", 0)]
+                ),
+            ]
+            for u, v in G_depth.edges
+        ]
+    )
+    # Compute distances
+    distances = compute_distance_vectorized(edge_data, compute_sphere)
     # Assign distances back to the graph
-    for (u, v), distance in zip(edge_indices, distances):
+    for (u, v), distance in zip(G_depth.edges, distances):
         if include_edge_weight:
-            weight = G.edges[u, v].get("normalized_weight", 0) + 1e-6
+            weight = G.edges[u, v].get("normalized_weight", 1e-6)  # Avoid divide-by-zero
             G.edges[u, v]["length"] = distance / np.sqrt(weight)
         else:
             G.edges[u, v]["length"] = distance

risk/network/graph/api.py

@@ -16,7 +16,7 @@ from risk.neighborhoods import (
     process_neighborhoods,
     trim_domains,
 )
-from risk.network.graph.network import NetworkGraph
+from risk.network.graph.graph import Graph
 from risk.stats import calculate_significance_matrices
 
 
@@ -44,7 +44,7 @@ class GraphAPI:
         linkage_metric: str = "yule",
         min_cluster_size: int = 5,
         max_cluster_size: int = 1000,
-    ) -> NetworkGraph:
+    ) -> Graph:
         """Load and process the network graph, defining top annotations and domains.
 
         Args:
@@ -63,7 +63,7 @@ class GraphAPI:
             max_cluster_size (int, optional): Maximum size for clusters. Defaults to 1000.
 
         Returns:
-            NetworkGraph: A fully initialized and processed NetworkGraph object.
+            Graph: A fully initialized and processed Graph object.
         """
         # Log the parameters and display headers
         log_header("Finding significant neighborhoods")
@@ -139,13 +139,13 @@ class GraphAPI:
             max_cluster_size=max_cluster_size,
         )
 
-        # Prepare node mapping and significance sums for the final NetworkGraph object
+        # Prepare node mapping and significance sums for the final Graph object
         ordered_nodes = annotations["ordered_nodes"]
         node_label_to_id = dict(zip(ordered_nodes, range(len(ordered_nodes))))
         node_significance_sums = processed_neighborhoods["node_significance_sums"]
 
-        # Return the fully initialized NetworkGraph object
-        return NetworkGraph(
+        # Return the fully initialized Graph object
+        return Graph(
             network=network,
             annotations=annotations,
             neighborhoods=neighborhoods,

risk/network/graph/{network.py → graph.py}

@@ -1,6 +1,6 @@
 """
-risk/network/graph/network
-~~~~~~~~~~~~~~~~~~~~~~~~~~
+risk/network/graph/graph
+~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
 from collections import defaultdict
@@ -10,13 +10,13 @@ import networkx as nx
 import numpy as np
 import pandas as pd
 
-from risk.network.graph.summary import AnalysisSummary
+from risk.network.graph.summary import Summary
 
 
-class NetworkGraph:
+class Graph:
     """A class to represent a network graph and process its nodes and edges.
 
-    The NetworkGraph class provides functionality to handle and manipulate a network graph,
+    The Graph class provides functionality to handle and manipulate a network graph,
     including managing domains, annotations, and node significance data. It also includes methods
     for transforming and mapping graph coordinates, as well as generating colors based on node
     significance.
@@ -32,7 +32,7 @@ class NetworkGraph:
         node_label_to_node_id_map: Dict[str, Any],
         node_significance_sums: np.ndarray,
     ):
-        """Initialize the NetworkGraph object.
+        """Initialize the Graph object.
 
         Args:
             network (nx.Graph): The network graph.
@@ -69,7 +69,7 @@ class NetworkGraph:
         self.node_coordinates = _extract_node_coordinates(self.network)
 
         # NOTE: Only after the above attributes are initialized, we can create the summary
-        self.summary = AnalysisSummary(annotations, neighborhoods, self)
+        self.summary = Summary(annotations, neighborhoods, self)
 
     def pop(self, domain_id: str) -> None:
         """Remove domain ID from instance domain ID mappings. This can be useful for cleaning up

risk/network/graph/summary.py

@@ -12,7 +12,7 @@ from statsmodels.stats.multitest import fdrcorrection
 from risk.log.console import logger, log_header
 
 
-class AnalysisSummary:
+class Summary:
     """Handles the processing, storage, and export of network analysis results.
 
     The Results class provides methods to process significance and depletion data, compute
@@ -25,14 +25,14 @@ class AnalysisSummary:
         self,
         annotations: Dict[str, Any],
         neighborhoods: Dict[str, Any],
-        graph,  # Avoid type hinting NetworkGraph to prevent circular imports
+        graph,  # Avoid type hinting Graph to prevent circular imports
     ):
         """Initialize the Results object with analysis components.
 
         Args:
             annotations (Dict[str, Any]): Annotation data, including ordered annotations and matrix of associations.
             neighborhoods (Dict[str, Any]): Neighborhood data containing p-values for significance and depletion analysis.
-            graph (NetworkGraph): Graph object representing domain-to-node and node-to-label mappings.
+            graph (Graph): Graph object representing domain-to-node and node-to-label mappings.
         """
         self.annotations = annotations
         self.neighborhoods = neighborhoods

risk/network/io.py

@@ -217,6 +217,9 @@ class NetworkIO:
 
         Returns:
             nx.Graph: Loaded and processed network.
+
+        Raises:
+            ValueError: If no matching attribute metadata file is found.
         """
         filetype = "Cytoscape"
         # Log the loading of the Cytoscape file
@@ -258,13 +261,29 @@ class NetworkIO:
 
             # Read the node attributes (from /tables/)
             attribute_metadata_keywords = ["/tables/", "SHARED_ATTRS", "edge.cytable"]
-            attribute_metadata = [
-                os.path.join(tmp_dir, cf)
-                for cf in cys_files
-                if all(keyword in cf for keyword in attribute_metadata_keywords)
-            ][0]
-            # Load attributes file from Cytoscape as pandas data frame
-            attribute_table = pd.read_csv(attribute_metadata, sep=",", header=None, skiprows=1)
+            # Use a generator to find the first matching file
+            attribute_metadata = next(
+                (
+                    os.path.join(tmp_dir, cf)
+                    for cf in cys_files
+                    if all(keyword in cf for keyword in attribute_metadata_keywords)
+                ),
+                None,  # Default if no file matches
+            )
+            if attribute_metadata:
+                # Optimize `read_csv` by leveraging proper options
+                attribute_table = pd.read_csv(
+                    attribute_metadata,
+                    sep=",",
+                    header=None,
+                    skiprows=1,
+                    dtype=str,  # Use specific dtypes to reduce memory usage
+                    engine="c",  # Use the C engine for parsing if compatible
+                    low_memory=False,  # Optimize memory handling for large files
+                )
+            else:
+                raise ValueError("No matching attribute metadata file found.")
+
             # Set columns
             attribute_table.columns = attribute_table.iloc[0]
             # Skip first four rows
@@ -464,14 +483,19 @@ class NetworkIO:
         Args:
             G (nx.Graph): A NetworkX graph object.
         """
-        missing_weights = 0
-        # Assign user-defined edge weights to the "weight" attribute
-        nx.set_edge_attributes(G, 1.0, "weight")  # Set default weight
-        if self.weight_label in nx.get_edge_attributes(G, self.weight_label):
-            nx.set_edge_attributes(G, nx.get_edge_attributes(G, self.weight_label), "weight")
-
-        if self.include_edge_weight and missing_weights:
-            logger.debug(f"Total edges missing weights: {missing_weights}")
+        # Set default weight for all edges in bulk
+        default_weight = 1.0
+        nx.set_edge_attributes(G, default_weight, "weight")
+        # Check and assign user-defined edge weights if available
+        weight_attributes = nx.get_edge_attributes(G, self.weight_label)
+        if weight_attributes:
+            nx.set_edge_attributes(G, weight_attributes, "weight")
+
+        # Log missing weights if include_edge_weight is enabled
+        if self.include_edge_weight:
+            missing_weights = len(G.edges) - len(weight_attributes)
+            if missing_weights > 0:
+                logger.debug(f"Total edges missing weights: {missing_weights}")
 
     def _validate_nodes(self, G: nx.Graph) -> None:
         """Validate the graph structure and attributes with attribute fallback for positions and labels.

risk/network/plotter/__init__.py

@@ -1,6 +1,6 @@
 """
-risk/network/plot
-~~~~~~~~~~~~~~~~~
+risk/network/plotter
+~~~~~~~~~~~~~~~~~~~~
 """
 
 from risk.network.plotter.api import PlotterAPI

risk/network/plotter/api.py

@@ -1,6 +1,6 @@
 """
-risk/network/graph/api
-~~~~~~~~~~~~~~~~~~~~~~
+risk/network/plotter/api
+~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
 from typing import List, Tuple, Union
@@ -8,14 +8,14 @@ from typing import List, Tuple, Union
 import numpy as np
 
 from risk.log import log_header
-from risk.network.graph.network import NetworkGraph
-from risk.network.plotter.network import NetworkPlotter
+from risk.network.graph.graph import Graph
+from risk.network.plotter.plotter import Plotter
 
 
 class PlotterAPI:
     """Handles the loading of network plotter objects.
 
-    The PlotterAPI class provides methods to load and configure NetworkPlotter objects for plotting network graphs.
+    The PlotterAPI class provides methods to load and configure Plotter objects for plotting network graphs.
     """
 
     def __init__() -> None:
@@ -23,16 +23,16 @@ class PlotterAPI:
 
     def load_plotter(
         self,
-        graph: NetworkGraph,
+        graph: Graph,
         figsize: Union[List, Tuple, np.ndarray] = (10, 10),
         background_color: str = "white",
         background_alpha: Union[float, None] = 1.0,
         pad: float = 0.3,
-    ) -> NetworkPlotter:
-        """Get a NetworkPlotter object for plotting.
+    ) -> Plotter:
+        """Get a Plotter object for plotting.
 
         Args:
-            graph (NetworkGraph): The graph to plot.
+            graph (Graph): The graph to plot.
             figsize (List, Tuple, or np.ndarray, optional): Size of the plot. Defaults to (10, 10)., optional): Size of the figure. Defaults to (10, 10).
             background_color (str, optional): Background color of the plot. Defaults to "white".
             background_alpha (float, None, optional): Transparency level of the background color. If provided, it overrides
@@ -40,12 +40,12 @@ class PlotterAPI:
             pad (float, optional): Padding value to adjust the axis limits. Defaults to 0.3.
 
         Returns:
-            NetworkPlotter: A NetworkPlotter object configured with the given parameters.
+            Plotter: A Plotter object configured with the given parameters.
         """
         log_header("Loading plotter")
 
-        # Initialize and return a NetworkPlotter object
-        return NetworkPlotter(
+        # Initialize and return a Plotter object
+        return Plotter(
             graph,
             figsize=figsize,
             background_color=background_color,

risk/network/plotter/canvas.py

@@ -1,6 +1,6 @@
 """
-risk/network/plot/canvas
-~~~~~~~~~~~~~~~~~~~~~~~~
+risk/network/plotter/canvas
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
 from typing import List, Tuple, Union
@@ -9,7 +9,7 @@ import matplotlib.pyplot as plt
 import numpy as np
 
 from risk.log import params
-from risk.network.graph.network import NetworkGraph
+from risk.network.graph.graph import Graph
 from risk.network.plotter.utils.colors import to_rgba
 from risk.network.plotter.utils.layout import calculate_bounding_box
 
@@ -17,11 +17,11 @@ from risk.network.plotter.utils.layout import calculate_bounding_box
 class Canvas:
     """A class for laying out the canvas in a network graph."""
 
-    def __init__(self, graph: NetworkGraph, ax: plt.Axes) -> None:
-        """Initialize the Canvas with a NetworkGraph and axis for plotting.
+    def __init__(self, graph: Graph, ax: plt.Axes) -> None:
+        """Initialize the Canvas with a Graph and axis for plotting.
 
         Args:
-            graph (NetworkGraph): The NetworkGraph object containing the network data.
+            graph (Graph): The Graph object containing the network data.
             ax (plt.Axes): The axis to plot the canvas on.
         """
         self.graph = graph
@@ -236,7 +236,7 @@ class Canvas:
         # Scale the node coordinates if needed
         scaled_coordinates = node_coordinates * scale
         # Use the existing _draw_kde_contour method
-        # NOTE: This is a technical debt that should be refactored in the future - only works when inherited by NetworkPlotter
+        # NOTE: This is a technical debt that should be refactored in the future - only works when inherited by Plotter
         self._draw_kde_contour(
             ax=self.ax,
             pos=scaled_coordinates,

risk/network/plotter/contour.py

@@ -1,6 +1,6 @@
 """
-risk/network/plot/contour
-~~~~~~~~~~~~~~~~~~~~~~~~~
+risk/network/plotter/contour
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
 from typing import Any, Dict, List, Tuple, Union
@@ -12,18 +12,18 @@ from scipy.ndimage import label
 from scipy.stats import gaussian_kde
 
 from risk.log import params, logger
-from risk.network.graph.network import NetworkGraph
+from risk.network.graph.graph import Graph
 from risk.network.plotter.utils.colors import get_annotated_domain_colors, to_rgba
 
 
 class Contour:
     """Class to generate Kernel Density Estimate (KDE) contours for nodes in a network graph."""
 
-    def __init__(self, graph: NetworkGraph, ax: plt.Axes) -> None:
-        """Initialize the Contour with a NetworkGraph and axis for plotting.
+    def __init__(self, graph: Graph, ax: plt.Axes) -> None:
+        """Initialize the Contour with a Graph and axis for plotting.
 
         Args:
-            graph (NetworkGraph): The NetworkGraph object containing the network data.
+            graph (Graph): The Graph object containing the network data.
             ax (plt.Axes): The axis to plot the contours on.
         """
         self.graph = graph

risk/network/plotter/labels.py

@@ -1,6 +1,6 @@
 """
-risk/network/plot/labels
-~~~~~~~~~~~~~~~~~~~~~~~~
+risk/network/plotter/labels
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
 import copy
@@ -11,7 +11,7 @@ import numpy as np
 import pandas as pd
 
 from risk.log import params
-from risk.network.graph.network import NetworkGraph
+from risk.network.graph.graph import Graph
 from risk.network.plotter.utils.colors import get_annotated_domain_colors, to_rgba
 from risk.network.plotter.utils.layout import calculate_bounding_box
 
@@ -21,11 +21,11 @@ TERM_DELIMITER = "::::"  # String used to separate multiple domain terms when co
 class Labels:
     """Class to handle the annotation of network graphs with labels for different domains."""
 
-    def __init__(self, graph: NetworkGraph, ax: plt.Axes):
+    def __init__(self, graph: Graph, ax: plt.Axes):
         """Initialize the Labeler object with a network graph and matplotlib axes.
 
         Args:
-            graph (NetworkGraph): NetworkGraph object containing the network data.
+            graph (Graph): Graph object containing the network data.
             ax (plt.Axes): Matplotlib axes object to plot the labels on.
         """
         self.graph = graph