risk-network 0.0.8b26__py3-none-any.whl → 0.0.9__py3-none-any.whl

risk/network/io.py

@@ -1,8 +1,6 @@
 """
 risk/network/io
 ~~~~~~~~~~~~~~~
-
-This file contains the code for the RISK class and command-line access.
 """
 
 import copy
@@ -33,8 +31,6 @@ class NetworkIO:
         compute_sphere: bool = True,
         surface_depth: float = 0.0,
         min_edges_per_node: int = 0,
-        include_edge_weight: bool = True,
-        weight_label: str = "weight",
     ):
         """Initialize the NetworkIO class.
 
@@ -42,21 +38,15 @@ class NetworkIO:
             compute_sphere (bool, optional): Whether to map nodes to a sphere. Defaults to True.
             surface_depth (float, optional): Surface depth for the sphere. Defaults to 0.0.
             min_edges_per_node (int, optional): Minimum number of edges per node. Defaults to 0.
-            include_edge_weight (bool, optional): Whether to include edge weights in calculations. Defaults to True.
-            weight_label (str, optional): Label for edge weights. Defaults to "weight".
         """
         self.compute_sphere = compute_sphere
         self.surface_depth = surface_depth
         self.min_edges_per_node = min_edges_per_node
-        self.include_edge_weight = include_edge_weight
-        self.weight_label = weight_label
         # Log the initialization of the NetworkIO class
         params.log_network(
             compute_sphere=compute_sphere,
             surface_depth=surface_depth,
             min_edges_per_node=min_edges_per_node,
-            include_edge_weight=include_edge_weight,
-            weight_label=weight_label,
         )
 
     @staticmethod
@@ -65,8 +55,6 @@ class NetworkIO:
         compute_sphere: bool = True,
         surface_depth: float = 0.0,
         min_edges_per_node: int = 0,
-        include_edge_weight: bool = True,
-        weight_label: str = "weight",
     ) -> nx.Graph:
         """Load a network from a GPickle file.
 
@@ -75,8 +63,6 @@ class NetworkIO:
             compute_sphere (bool, optional): Whether to map nodes to a sphere. Defaults to True.
             surface_depth (float, optional): Surface depth for the sphere. Defaults to 0.0.
             min_edges_per_node (int, optional): Minimum number of edges per node. Defaults to 0.
-            include_edge_weight (bool, optional): Whether to include edge weights in calculations. Defaults to True.
-            weight_label (str, optional): Label for edge weights. Defaults to "weight".
 
         Returns:
             nx.Graph: Loaded and processed network.
@@ -85,8 +71,6 @@ class NetworkIO:
             compute_sphere=compute_sphere,
             surface_depth=surface_depth,
             min_edges_per_node=min_edges_per_node,
-            include_edge_weight=include_edge_weight,
-            weight_label=weight_label,
         )
         return networkio._load_gpickle_network(filepath=filepath)
 
@@ -116,8 +100,6 @@ class NetworkIO:
         compute_sphere: bool = True,
         surface_depth: float = 0.0,
         min_edges_per_node: int = 0,
-        include_edge_weight: bool = True,
-        weight_label: str = "weight",
     ) -> nx.Graph:
         """Load a NetworkX graph.
 
@@ -126,8 +108,6 @@ class NetworkIO:
             compute_sphere (bool, optional): Whether to map nodes to a sphere. Defaults to True.
             surface_depth (float, optional): Surface depth for the sphere. Defaults to 0.0.
             min_edges_per_node (int, optional): Minimum number of edges per node. Defaults to 0.
-            include_edge_weight (bool, optional): Whether to include edge weights in calculations. Defaults to True.
-            weight_label (str, optional): Label for edge weights. Defaults to "weight".
 
         Returns:
             nx.Graph: Loaded and processed network.
@@ -136,8 +116,6 @@ class NetworkIO:
             compute_sphere=compute_sphere,
             surface_depth=surface_depth,
             min_edges_per_node=min_edges_per_node,
-            include_edge_weight=include_edge_weight,
-            weight_label=weight_label,
         )
         return networkio._load_networkx_network(network=network)
 
@@ -165,12 +143,10 @@ class NetworkIO:
         filepath: str,
         source_label: str = "source",
         target_label: str = "target",
+        view_name: str = "",
         compute_sphere: bool = True,
         surface_depth: float = 0.0,
         min_edges_per_node: int = 0,
-        include_edge_weight: bool = True,
-        weight_label: str = "weight",
-        view_name: str = "",
     ) -> nx.Graph:
         """Load a network from a Cytoscape file.
 
@@ -178,12 +154,10 @@ class NetworkIO:
             filepath (str): Path to the Cytoscape file.
             source_label (str, optional): Source node label. Defaults to "source".
             target_label (str, optional): Target node label. Defaults to "target".
-            view_name (str, optional): Specific view name to load. Defaults to None.
+            view_name (str, optional): Specific view name to load. Defaults to "".
             compute_sphere (bool, optional): Whether to map nodes to a sphere. Defaults to True.
             surface_depth (float, optional): Surface depth for the sphere. Defaults to 0.0.
             min_edges_per_node (int, optional): Minimum number of edges per node. Defaults to 0.
-            include_edge_weight (bool, optional): Whether to include edge weights in calculations. Defaults to True.
-            weight_label (str, optional): Label for edge weights. Defaults to "weight".
 
         Returns:
             nx.Graph: Loaded and processed network.
@@ -192,8 +166,6 @@ class NetworkIO:
             compute_sphere=compute_sphere,
             surface_depth=surface_depth,
             min_edges_per_node=min_edges_per_node,
-            include_edge_weight=include_edge_weight,
-            weight_label=weight_label,
         )
         return networkio._load_cytoscape_network(
             filepath=filepath,
@@ -215,10 +187,13 @@ class NetworkIO:
             filepath (str): Path to the Cytoscape file.
             source_label (str, optional): Source node label. Defaults to "source".
             target_label (str, optional): Target node label. Defaults to "target".
-            view_name (str, optional): Specific view name to load. Defaults to None.
+            view_name (str, optional): Specific view name to load. Defaults to "".
 
         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
@@ -260,36 +235,59 @@ 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
+            # Skip first four rows, select source and target columns, and reset index
             attribute_table = attribute_table.iloc[4:, :]
-            # Conditionally select columns based on include_edge_weight
-            if self.include_edge_weight:
-                attribute_table = attribute_table[[source_label, target_label, self.weight_label]]
-            else:
+            try:
+                # Attempt to filter the attribute_table with the given labels
                 attribute_table = attribute_table[[source_label, target_label]]
+            except KeyError as e:
+                # Find which key(s) caused the issue
+                missing_keys = [
+                    key
+                    for key in [source_label, target_label]
+                    if key not in attribute_table.columns
+                ]
+                # Raise the KeyError with details about the issue and available options
+                available_columns = ", ".join(attribute_table.columns)
+                raise KeyError(
+                    f"The column(s) '{', '.join(missing_keys)}' do not exist in the table. "
+                    f"Available columns are: {available_columns}."
+                ) from e
 
             attribute_table = attribute_table.dropna().reset_index(drop=True)
+
             # Create a graph
             G = nx.Graph()
-            # Add edges and nodes, conditionally including weights
+            # Add edges and nodes
             for _, row in attribute_table.iterrows():
                 source = row[source_label]
                 target = row[target_label]
-                if self.include_edge_weight:
-                    weight = float(row[self.weight_label])
-                    G.add_edge(source, target, weight=weight)
-                else:
-                    G.add_edge(source, target)
-
+                G.add_edge(source, target)
                 if source not in G:
                     G.add_node(source)  # Optionally add x, y coordinates here if available
                 if target not in G:
@@ -298,12 +296,8 @@ class NetworkIO:
             # Add node attributes
             for node in G.nodes():
                 G.nodes[node]["label"] = node
-                G.nodes[node]["x"] = node_x_positions[
-                    node
-                ]  # Assuming you have a dict `node_x_positions` for x coordinates
-                G.nodes[node]["y"] = node_y_positions[
-                    node
-                ]  # Assuming you have a dict `node_y_positions` for y coordinates
+                G.nodes[node]["x"] = node_x_positions[node]
+                G.nodes[node]["y"] = node_y_positions[node]
 
             # Initialize the graph
             return self._initialize_graph(G)
@@ -321,8 +315,6 @@ class NetworkIO:
         compute_sphere: bool = True,
         surface_depth: float = 0.0,
         min_edges_per_node: int = 0,
-        include_edge_weight: bool = True,
-        weight_label: str = "weight",
     ) -> nx.Graph:
         """Load a network from a Cytoscape JSON (.cyjs) file.
 
@@ -333,8 +325,6 @@ class NetworkIO:
             compute_sphere (bool, optional): Whether to map nodes to a sphere. Defaults to True.
             surface_depth (float, optional): Surface depth for the sphere. Defaults to 0.0.
             min_edges_per_node (int, optional): Minimum number of edges per node. Defaults to 0.
-            include_edge_weight (bool, optional): Whether to include edge weights in calculations. Defaults to True.
-            weight_label (str, optional): Label for edge weights. Defaults to "weight".
 
         Returns:
             NetworkX graph: Loaded and processed network.
@@ -343,8 +333,6 @@ class NetworkIO:
             compute_sphere=compute_sphere,
             surface_depth=surface_depth,
             min_edges_per_node=min_edges_per_node,
-            include_edge_weight=include_edge_weight,
-            weight_label=weight_label,
         )
         return networkio._load_cytoscape_json_network(
             filepath=filepath,
@@ -379,21 +367,18 @@ class NetworkIO:
         node_y_positions = {}
         for node in cyjs_data["elements"]["nodes"]:
             node_data = node["data"]
-            node_id = node_data["id_original"]
+            # Use the original node ID if available, otherwise use the default ID
+            node_id = node_data.get("id_original", node_data.get("id"))
             node_x_positions[node_id] = node["position"]["x"]
             node_y_positions[node_id] = node["position"]["y"]
 
         # Process edges and add them to the graph
         for edge in cyjs_data["elements"]["edges"]:
             edge_data = edge["data"]
-            source = edge_data[f"{source_label}_original"]
-            target = edge_data[f"{target_label}_original"]
-            # Add the edge to the graph, optionally including weights
-            if self.weight_label is not None and self.weight_label in edge_data:
-                weight = float(edge_data[self.weight_label])
-                G.add_edge(source, target, weight=weight)
-            else:
-                G.add_edge(source, target)
+            # Use the original source and target labels if available, otherwise fall back to default labels
+            source = edge_data.get(f"{source_label}_original", edge_data.get(source_label))
+            target = edge_data.get(f"{target_label}_original", edge_data.get(target_label))
+            G.add_edge(source, target)
 
             # Ensure nodes exist in the graph and add them if not present
             if source not in G:
@@ -425,7 +410,7 @@ class NetworkIO:
         self._remove_invalid_graph_properties(G)
         # IMPORTANT: This is where the graph node labels are converted to integers
         # Make sure to perform this step after all other processing
-        G = nx.relabel_nodes(G, {node: idx for idx, node in enumerate(G.nodes)})
+        G = nx.convert_node_labels_to_integers(G)
         return G
 
     def _remove_invalid_graph_properties(self, G: nx.Graph) -> None:
@@ -435,22 +420,24 @@ class NetworkIO:
         Args:
             G (nx.Graph): A NetworkX graph object.
         """
-        # Count number of nodes and edges before cleaning
+        # Count the number of nodes and edges before cleaning
         num_initial_nodes = G.number_of_nodes()
         num_initial_edges = G.number_of_edges()
         # Remove self-loops to ensure correct edge count
-        G.remove_edges_from(list(nx.selfloop_edges(G)))
+        G.remove_edges_from(nx.selfloop_edges(G))
         # Iteratively remove nodes with fewer edges than the threshold
         while True:
-            nodes_to_remove = [node for node in G.nodes if G.degree(node) < self.min_edges_per_node]
+            nodes_to_remove = [
+                node
+                for node, degree in dict(G.degree()).items()
+                if degree < self.min_edges_per_node
+            ]
             if not nodes_to_remove:
-                break  # Exit loop if no more nodes need removal
+                break  # Exit loop if no nodes meet the condition
             G.remove_nodes_from(nodes_to_remove)
 
         # Remove isolated nodes
-        isolated_nodes = list(nx.isolates(G))
-        if isolated_nodes:
-            G.remove_nodes_from(isolated_nodes)
+        G.remove_nodes_from(nx.isolates(G))
 
         # Log the number of nodes and edges before and after cleaning
         num_final_nodes = G.number_of_nodes()
@@ -461,63 +448,69 @@ class NetworkIO:
         logger.debug(f"Final edge count: {num_final_edges}")
 
     def _assign_edge_weights(self, G: nx.Graph) -> None:
-        """Assign weights to the edges in the graph.
+        """Assign default edge weights to the graph.
 
         Args:
             G (nx.Graph): A NetworkX graph object.
         """
-        missing_weights = 0
-        # Assign user-defined edge weights to the "weight" attribute
-        for _, _, data in G.edges(data=True):
-            if self.weight_label not in data:
-                missing_weights += 1
-            data["weight"] = data.get(
-                self.weight_label, 1.0
-            )  # Default to 1.0 if 'weight' not present
-
-        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
+        nx.set_edge_attributes(G, default_weight, "weight")
 
     def _validate_nodes(self, G: nx.Graph) -> None:
         """Validate the graph structure and attributes with attribute fallback for positions and labels.
 
         Args:
             G (nx.Graph): A NetworkX graph object.
+
+        Raises:
+            ValueError: If a node is missing 'x', 'y', and a valid 'pos' attribute.
         """
-        # Keep track of nodes missing labels
+        # Retrieve all relevant attributes in bulk
+        pos_attrs = nx.get_node_attributes(G, "pos")
+        name_attrs = nx.get_node_attributes(G, "name")
+        id_attrs = nx.get_node_attributes(G, "id")
+        # Dictionaries to hold missing or fallback attributes
+        x_attrs = {}
+        y_attrs = {}
+        label_attrs = {}
         nodes_with_missing_labels = []
 
-        for node, attrs in G.nodes(data=True):
-            # Attribute fallback for 'x' and 'y' attributes
+        # Iterate through nodes to validate and assign missing attributes
+        for node in G.nodes:
+            attrs = G.nodes[node]
+            # Validate and assign 'x' and 'y' attributes
             if "x" not in attrs or "y" not in attrs:
                 if (
-                    "pos" in attrs
-                    and isinstance(attrs["pos"], (list, tuple, np.ndarray))
-                    and len(attrs["pos"]) >= 2
+                    node in pos_attrs
+                    and isinstance(pos_attrs[node], (list, tuple, np.ndarray))
+                    and len(pos_attrs[node]) >= 2
                 ):
-                    attrs["x"], attrs["y"] = attrs["pos"][
-                        :2
-                    ]  # Use only x and y, ignoring z if present
+                    x_attrs[node], y_attrs[node] = pos_attrs[node][:2]
                 else:
                     raise ValueError(
                         f"Node {node} is missing 'x', 'y', and a valid 'pos' attribute."
                     )
 
-            # Attribute fallback for 'label' attribute
+            # Validate and assign 'label' attribute
             if "label" not in attrs:
-                # Try alternative attribute names for label
-                if "name" in attrs:
-                    attrs["label"] = attrs["name"]
-                elif "id" in attrs:
-                    attrs["label"] = attrs["id"]
+                if node in name_attrs:
+                    label_attrs[node] = name_attrs[node]
+                elif node in id_attrs:
+                    label_attrs[node] = id_attrs[node]
                 else:
-                    # Collect nodes with missing labels
+                    # Assign node ID as label and log the missing label
+                    label_attrs[node] = str(node)
                     nodes_with_missing_labels.append(node)
-                    attrs["label"] = str(node)  # Use node ID as the label
 
-        # Issue a single warning if any labels were missing
+        # Batch update attributes in the graph
+        nx.set_node_attributes(G, x_attrs, "x")
+        nx.set_node_attributes(G, y_attrs, "y")
+        nx.set_node_attributes(G, label_attrs, "label")
+
+        # Log a warning if any labels were missing
         if nodes_with_missing_labels:
-            total_nodes = len(G.nodes)
+            total_nodes = G.number_of_nodes()
             fraction_missing_labels = len(nodes_with_missing_labels) / total_nodes
             logger.warning(
                 f"{len(nodes_with_missing_labels)} out of {total_nodes} nodes "
@@ -534,7 +527,6 @@ class NetworkIO:
             G,
             compute_sphere=self.compute_sphere,
             surface_depth=self.surface_depth,
-            include_edge_weight=self.include_edge_weight,
         )
 
     def _log_loading(
@@ -552,9 +544,6 @@ class NetworkIO:
         logger.debug(f"Filetype: {filetype}")
         if filepath:
             logger.debug(f"Filepath: {filepath}")
-        logger.debug(f"Edge weight: {'Included' if self.include_edge_weight else 'Excluded'}")
-        if self.include_edge_weight:
-            logger.debug(f"Weight label: {self.weight_label}")
         logger.debug(f"Minimum edges per node: {self.min_edges_per_node}")
         logger.debug(f"Projection: {'Sphere' if self.compute_sphere else 'Plane'}")
         if self.compute_sphere:

risk/network/plotter/__init__.py

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

risk/network/plotter/api.py

@@ -0,0 +1,54 @@
+"""
+risk/network/plotter/api
+~~~~~~~~~~~~~~~~~~~~~~~~
+"""
+
+from typing import List, Tuple, Union
+
+import numpy as np
+
+from risk.log import log_header
+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 Plotter objects for plotting network graphs.
+    """
+
+    def __init__() -> None:
+        pass
+
+    def load_plotter(
+        self,
+        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,
+    ) -> Plotter:
+        """Get a Plotter object for plotting.
+
+        Args:
+            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
+                any existing alpha values found in background_color. Defaults to 1.0.
+            pad (float, optional): Padding value to adjust the axis limits. Defaults to 0.3.
+
+        Returns:
+            Plotter: A Plotter object configured with the given parameters.
+        """
+        log_header("Loading plotter")
+
+        # Initialize and return a Plotter object
+        return Plotter(
+            graph,
+            figsize=figsize,
+            background_color=background_color,
+            background_alpha=background_alpha,
+            pad=pad,
+        )

risk/network/{plot → plotter}/canvas.py

@@ -1,6 +1,6 @@
 """
-risk/network/plot/canvas
-~~~~~~~~~~~~~~~~~~~~~~~~
+risk/network/plotter/canvas
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
 from typing import List, Tuple, Union
@@ -9,19 +9,19 @@ import matplotlib.pyplot as plt
 import numpy as np
 
 from risk.log import params
-from risk.network.graph import NetworkGraph
-from risk.network.plot.utils.color import to_rgba
-from risk.network.plot.utils.layout import calculate_bounding_box
+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
 
 
 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
@@ -36,6 +36,7 @@ class Canvas:
         font: str = "Arial",
         title_color: Union[str, List, Tuple, np.ndarray] = "black",
         subtitle_color: Union[str, List, Tuple, np.ndarray] = "gray",
+        title_x: float = 0.5,
         title_y: float = 0.975,
         title_space_offset: float = 0.075,
         subtitle_offset: float = 0.025,
@@ -52,6 +53,7 @@ class Canvas:
                 Defaults to "black".
             subtitle_color (str, List, Tuple, or np.ndarray, optional): Color of the subtitle text. Can be a string or an array of colors.
                 Defaults to "gray".
+            title_x (float, optional): X-axis position of the title. Defaults to 0.5.
             title_y (float, optional): Y-axis position of the title. Defaults to 0.975.
             title_space_offset (float, optional): Fraction of figure height to leave for the space above the plot. Defaults to 0.075.
             subtitle_offset (float, optional): Offset factor to position the subtitle below the title. Defaults to 0.025.
@@ -85,7 +87,7 @@ class Canvas:
                 fontsize=title_fontsize,
                 color=title_color,
                 fontname=font,
-                x=0.5,  # Center the title horizontally
+                x=title_x,
                 ha="center",
                 va="top",
                 y=title_y,
@@ -234,6 +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 Plotter
         self._draw_kde_contour(
             ax=self.ax,
             pos=scaled_coordinates,