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

risk_network-0.0.9b26.dist-info/RECORD

@@ -0,0 +1,44 @@
+risk/__init__.py,sha256=vcWTNpBnxRYMGh8X2IkLccT4MfT6c0J94_SFHMe66Rk,127
+risk/constants.py,sha256=XInRaH78Slnw_sWgAsBFbUHkyA0h0jL0DKGuQNbOvjM,550
+risk/risk.py,sha256=s827_lRknFseOP9O4zW8sP-IcCd2EzrpV_tnVY_tz5s,1104
+risk/annotations/__init__.py,sha256=parsbcux1U4urpUqh9AdzbDWuLj9HlMidycMPkpSQFo,179
+risk/annotations/annotations.py,sha256=XmVuLL5NFAj6F30fZY22N8nb4LK6sig7fE0NXL1iZp8,14497
+risk/annotations/io.py,sha256=z1AJySsU-KL_IYuHa7j3nvuczmOHgK3WfaQ4TRunvrA,10499
+risk/log/__init__.py,sha256=7LxDysQu7doi0LAvlY2YbjN6iJH0fNknqy8lSLgeljo,217
+risk/log/console.py,sha256=PgjyEvyhYLUSHXPUKEqOmxsDsfrjPICIgqo_cAHq0N8,4575
+risk/log/parameters.py,sha256=VtwfMzLU1xI4yji3-Ch5vHjH-KdwTfwaEMmi7hFQTs0,5716
+risk/neighborhoods/__init__.py,sha256=Q74HwTH7okI-vaskJPy2bYwb5sNjGASTzJ6m8V8arCU,234
+risk/neighborhoods/api.py,sha256=KdUouMHJPwvePJGdz7Ck1GWYhN96QDb_SuPyTt3KwAc,23515
+risk/neighborhoods/community.py,sha256=VIDvB-SsMDDvWkUaYXf_E-gcg0HELMVv2MKshPwJAFQ,15480
+risk/neighborhoods/domains.py,sha256=jMJ4-Qzwgmo6Hya8h0E2_IcMaLpbuH_FWlmSjJl2ikc,12832
+risk/neighborhoods/neighborhoods.py,sha256=bBUY7hXqcsOoAEkPdRoRNuj36WsllXicmz_LxZfEuyw,21186
+risk/network/__init__.py,sha256=oVi3FA1XXKD84014Cykq-9bpX4_s0F3aAUfNOU-07Qw,73
+risk/network/geometry.py,sha256=omyb9afSKMUtQ-RKVHUoRyxJifOW0ASenHjyCjg43kg,6836
+risk/network/io.py,sha256=JV5hqf1oIwWUVw07BjhD0qACQGbtIeA8NSMDcFql88k,23465
+risk/network/graph/__init__.py,sha256=ziGJew3yhtqvrb9LUuneDu_LwW2Wa9vd4UuhoL5l1CA,91
+risk/network/graph/api.py,sha256=Ag4PjFTX6BUvmW7ZdfIgwdsr8URigX9jD9yEFRXUxrU,8220
+risk/network/graph/network.py,sha256=KdIBM_-flHMWcBK4RUjU_QRfOZIf_yv9fv4L7AOLkqU,12199
+risk/network/graph/summary.py,sha256=8IenFZfhyzcg5aGNJp7Zjb0Umy0mFNmJlfwXcO7y8MU,10311
+risk/network/plotter/__init__.py,sha256=ixXQxpBVpNIz1y9tUHZ7CiJmGfewvbvjuB1LQ-AIf1s,93
+risk/network/plotter/api.py,sha256=cLZHq-rn_5FJwIWM5hYlQMobPmaxCE-P2iqgxTDIOTQ,1860
+risk/network/plotter/canvas.py,sha256=l-Se86DMDJMHh8Yn-_hsl0_ipoazHLJGRCqXcc9HK4M,13498
+risk/network/plotter/contour.py,sha256=svi76suYlVYq2VoDQxXmun8Hmo0lI2CQRjAyHg0qdhk,15490
+risk/network/plotter/labels.py,sha256=QesD1ybseA6ldLmWMqVaAqSPR34yVEgEzXzg1AKQD6o,45513
+risk/network/plotter/network.py,sha256=wcBf1GaM1wPzW-iXTrLzOmlG2_9wwfll_hJUzUO2u2Y,19917
+risk/network/plotter/utils/colors.py,sha256=EFlIUZ3MGSKoHeZi9cgR6uLKK5GGJ4QzE6lmnrHViLw,18967
+risk/network/plotter/utils/layout.py,sha256=2P4Bqi1dGiX9KsriLYqiq1KlHpsMdZemAUza4WcYoNA,3634
+risk/stats/__init__.py,sha256=1CPRtT1LDwudrvFgkVtSom8cp4cM7b4X6b4fHPaNHw0,405
+risk/stats/binom.py,sha256=8Qwcxnq1u-AycwQs_sQxwuxgkgDpES-A-kIcj4fRc3g,2032
+risk/stats/chi2.py,sha256=MGFNrWP40i9TxnMsZYbDgqdMrN_Fe0xFsnWU8xNsVSs,3046
+risk/stats/hypergeom.py,sha256=VfQBtpgSGG826uBP1WyBMavP3ylZnhponUZ2rHFdGAE,2502
+risk/stats/poisson.py,sha256=_KHe9g8XNRD4-Q486zx2UgHCO2QyvBOiHuX3hRZLEqc,2050
+risk/stats/stats.py,sha256=y2DMJF3uKRIWRyYiCd2Kwxa-EqOzX5HsMBms_Vw6wK8,7322
+risk/stats/zscore.py,sha256=Jx9cLKAHiDnrgW_Su9KZYYQiTVsuyJMC7vXBusnEI-c,2648
+risk/stats/permutation/__init__.py,sha256=OLmYLm2uj96hPsSaUs0vUqFYw6Thwch_aHtpL7L0ZFw,127
+risk/stats/permutation/permutation.py,sha256=BWjgdBpLVcHvmwHy0bmD4aJFccxifNBSrrCBPppyKf4,10569
+risk/stats/permutation/test_functions.py,sha256=D3XMPM8CasUNytWSRce22TI6KK6XulYn5uGG4lWxaHs,3120
+risk_network-0.0.9b26.dist-info/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+risk_network-0.0.9b26.dist-info/METADATA,sha256=7nzWmesgQYNnymMbG9WejhChWxobBvbFgQQD0VKd3n0,47627
+risk_network-0.0.9b26.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+risk_network-0.0.9b26.dist-info/top_level.txt,sha256=NX7C2PFKTvC1JhVKv14DFlFAIFnKc6Lpsu1ZfxvQwVw,5
+risk_network-0.0.9b26.dist-info/RECORD,,

{risk_network-0.0.8b18.dist-info → risk_network-0.0.9b26.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.2.0)
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

risk/network/graph.py

@@ -1,159 +0,0 @@
-"""
-risk/network/graph
-~~~~~~~~~~~~~~~~~~
-"""
-
-from collections import defaultdict
-from typing import Any, Dict, List
-
-import networkx as nx
-import numpy as np
-import pandas as pd
-
-
-class NetworkGraph:
-    """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,
-    including managing domains, annotations, and node enrichment data. It also includes methods
-    for transforming and mapping graph coordinates, as well as generating colors based on node
-    enrichment.
-    """
-
-    def __init__(
-        self,
-        network: nx.Graph,
-        top_annotations: pd.DataFrame,
-        domains: pd.DataFrame,
-        trimmed_domains: pd.DataFrame,
-        node_label_to_node_id_map: Dict[str, Any],
-        node_enrichment_sums: np.ndarray,
-    ):
-        """Initialize the NetworkGraph object.
-
-        Args:
-            network (nx.Graph): The network graph.
-            top_annotations (pd.DataFrame): DataFrame containing annotations data for the network nodes.
-            domains (pd.DataFrame): DataFrame containing domain data for the network nodes.
-            trimmed_domains (pd.DataFrame): DataFrame containing trimmed domain data for the network nodes.
-            node_label_to_node_id_map (dict): A dictionary mapping node labels to their corresponding IDs.
-            node_enrichment_sums (np.ndarray): Array containing the enrichment sums for the nodes.
-        """
-        self.top_annotations = top_annotations
-        self.domain_id_to_node_ids_map = self._create_domain_id_to_node_ids_map(domains)
-        self.domains = domains
-        self.domain_id_to_domain_terms_map = self._create_domain_id_to_domain_terms_map(
-            trimmed_domains
-        )
-        self.node_enrichment_sums = node_enrichment_sums
-        self.node_id_to_node_label_map = {v: k for k, v in node_label_to_node_id_map.items()}
-        self.node_label_to_enrichment_map = dict(
-            zip(node_label_to_node_id_map.keys(), node_enrichment_sums)
-        )
-        self.node_label_to_node_id_map = node_label_to_node_id_map
-        # NOTE: Below this point, instance attributes (i.e., self) will be used!
-        self.domain_id_to_node_labels_map = self._create_domain_id_to_node_labels_map()
-        # Unfold the network's 3D coordinates to 2D and extract node coordinates
-        self.network = _unfold_sphere_to_plane(network)
-        self.node_coordinates = _extract_node_coordinates(self.network)
-
-    def _create_domain_id_to_node_ids_map(self, domains: pd.DataFrame) -> Dict[str, Any]:
-        """Create a mapping from domains to the list of node IDs belonging to each domain.
-
-        Args:
-            domains (pd.DataFrame): DataFrame containing domain information, including the 'primary domain' for each node.
-
-        Returns:
-            dict: A dictionary where keys are domain IDs and values are lists of node IDs belonging to each domain.
-        """
-        cleaned_domains_matrix = domains.reset_index()[["index", "primary domain"]]
-        node_to_domains_map = cleaned_domains_matrix.set_index("index")["primary domain"].to_dict()
-        domain_id_to_node_ids_map = defaultdict(list)
-        for k, v in node_to_domains_map.items():
-            domain_id_to_node_ids_map[v].append(k)
-
-        return domain_id_to_node_ids_map
-
-    def _create_domain_id_to_domain_terms_map(
-        self, trimmed_domains: pd.DataFrame
-    ) -> Dict[str, Any]:
-        """Create a mapping from domain IDs to their corresponding terms.
-
-        Args:
-            trimmed_domains (pd.DataFrame): DataFrame containing domain IDs and their corresponding labels.
-
-        Returns:
-            dict: A dictionary mapping domain IDs to their corresponding terms.
-        """
-        return dict(
-            zip(
-                trimmed_domains.index,
-                trimmed_domains["label"],
-            )
-        )
-
-    def _create_domain_id_to_node_labels_map(self) -> Dict[int, List[str]]:
-        """Create a map from domain IDs to node labels.
-
-        Returns:
-            dict: A dictionary mapping domain IDs to the corresponding node labels.
-        """
-        domain_id_to_label_map = {}
-        for domain_id, node_ids in self.domain_id_to_node_ids_map.items():
-            domain_id_to_label_map[domain_id] = [
-                self.node_id_to_node_label_map[node_id] for node_id in node_ids
-            ]
-
-        return domain_id_to_label_map
-
-
-def _unfold_sphere_to_plane(G: nx.Graph) -> nx.Graph:
-    """Convert 3D coordinates to 2D by unfolding a sphere to a plane.
-
-    Args:
-        G (nx.Graph): A network graph with 3D coordinates. Each node should have 'x', 'y', and 'z' attributes.
-
-    Returns:
-        nx.Graph: The network graph with updated 2D coordinates (only 'x' and 'y').
-    """
-    for node in G.nodes():
-        if "z" in G.nodes[node]:
-            # Extract 3D coordinates
-            x, y, z = G.nodes[node]["x"], G.nodes[node]["y"], G.nodes[node]["z"]
-            # Calculate spherical coordinates theta and phi from Cartesian coordinates
-            r = np.sqrt(x**2 + y**2 + z**2)
-            theta = np.arctan2(y, x)
-            phi = np.arccos(z / r)
-
-            # Convert spherical coordinates to 2D plane coordinates
-            unfolded_x = (theta + np.pi) / (2 * np.pi)  # Shift and normalize theta to [0, 1]
-            unfolded_x = unfolded_x + 0.5 if unfolded_x < 0.5 else unfolded_x - 0.5
-            unfolded_y = (np.pi - phi) / np.pi  # Reflect phi and normalize to [0, 1]
-            # Update network node attributes
-            G.nodes[node]["x"] = unfolded_x
-            G.nodes[node]["y"] = -unfolded_y
-            # Remove the 'z' coordinate as it's no longer needed
-            del G.nodes[node]["z"]
-
-    return G
-
-
-def _extract_node_coordinates(G: nx.Graph) -> np.ndarray:
-    """Extract 2D coordinates of nodes from the graph.
-
-    Args:
-        G (nx.Graph): The network graph with node coordinates.
-
-    Returns:
-        np.ndarray: Array of node coordinates with shape (num_nodes, 2).
-    """
-    # Extract x and y coordinates from graph nodes
-    x_coords = dict(G.nodes.data("x"))
-    y_coords = dict(G.nodes.data("y"))
-    coordinates_dicts = [x_coords, y_coords]
-    # Combine x and y coordinates into a single array
-    node_positions = {
-        node: np.array([coords[node] for coords in coordinates_dicts]) for node in x_coords
-    }
-    node_coordinates = np.vstack(list(node_positions.values()))
-    return node_coordinates

risk/network/plot/__init__.py

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

risk/network/plot/network.py

@@ -1,282 +0,0 @@
-"""
-risk/network/plot/network
-~~~~~~~~~~~~~~~~~~~~~~~~~
-"""
-
-from typing import Any, List, Tuple, Union
-
-import networkx as nx
-import numpy as np
-
-from risk.log import params
-from risk.network.graph import NetworkGraph
-from risk.network.plot.utils.color import get_domain_colors, to_rgba
-
-
-class Network:
-    """Class for plotting nodes and edges in a network graph."""
-
-    def __init__(self, graph: NetworkGraph, ax: Any = None) -> None:
-        """Initialize the NetworkPlotter class.
-
-        Args:
-            graph (NetworkGraph): The network data and attributes to be visualized.
-            ax (Any, optional): Axes object to plot the network graph. Defaults to None.
-        """
-        self.graph = graph
-        self.ax = ax
-
-    def plot_network(
-        self,
-        node_size: Union[int, np.ndarray] = 50,
-        node_shape: str = "o",
-        node_edgewidth: float = 1.0,
-        edge_width: float = 1.0,
-        node_color: Union[str, List, Tuple, np.ndarray] = "white",
-        node_edgecolor: Union[str, List, Tuple, np.ndarray] = "black",
-        edge_color: Union[str, List, Tuple, np.ndarray] = "black",
-        node_alpha: Union[float, None] = 1.0,
-        edge_alpha: Union[float, None] = 1.0,
-    ) -> None:
-        """Plot the network graph with customizable node colors, sizes, edge widths, and node edge widths.
-
-        Args:
-            node_size (int or np.ndarray, optional): Size of the nodes. Can be a single integer or an array of sizes. Defaults to 50.
-            node_shape (str, optional): Shape of the nodes. Defaults to "o".
-            node_edgewidth (float, optional): Width of the node edges. Defaults to 1.0.
-            edge_width (float, optional): Width of the edges. Defaults to 1.0.
-            node_color (str, list, tuple, or np.ndarray, optional): Color of the nodes. Can be a single color or an array of colors.
-                Defaults to "white".
-            node_edgecolor (str, list, tuple, or np.ndarray, optional): Color of the node edges. Can be a single color or an array of colors.
-                Defaults to "black".
-            edge_color (str, list, tuple, or np.ndarray, optional): Color of the edges. Can be a single color or an array of colors.
-                Defaults to "black".
-            node_alpha (float, None, optional): Alpha value (transparency) for the nodes. If provided, it overrides any existing alpha
-                values found in node_color. Defaults to 1.0. Annotated node_color alphas will override this value.
-            edge_alpha (float, None, optional): Alpha value (transparency) for the edges. If provided, it overrides any existing alpha
-                values found in edge_color. Defaults to 1.0.
-        """
-        # Log the plotting parameters
-        params.log_plotter(
-            network_node_size=(
-                "custom" if isinstance(node_size, np.ndarray) else node_size
-            ),  # np.ndarray usually indicates custom sizes
-            network_node_shape=node_shape,
-            network_node_edgewidth=node_edgewidth,
-            network_edge_width=edge_width,
-            network_node_color=(
-                "custom" if isinstance(node_color, np.ndarray) else node_color
-            ),  # np.ndarray usually indicates custom colors
-            network_node_edgecolor=node_edgecolor,
-            network_edge_color=edge_color,
-            network_node_alpha=node_alpha,
-            network_edge_alpha=edge_alpha,
-        )
-
-        # Convert colors to RGBA using the to_rgba helper function
-        # If node_colors was generated using get_annotated_node_colors, its alpha values will override node_alpha
-        node_color = to_rgba(
-            color=node_color, alpha=node_alpha, num_repeats=len(self.graph.network.nodes)
-        )
-        node_edgecolor = to_rgba(
-            color=node_edgecolor, alpha=1.0, num_repeats=len(self.graph.network.nodes)
-        )
-        edge_color = to_rgba(
-            color=edge_color, alpha=edge_alpha, num_repeats=len(self.graph.network.edges)
-        )
-
-        # Extract node coordinates from the network graph
-        node_coordinates = self.graph.node_coordinates
-
-        # Draw the nodes of the graph
-        nx.draw_networkx_nodes(
-            self.graph.network,
-            pos=node_coordinates,
-            node_size=node_size,
-            node_shape=node_shape,
-            node_color=node_color,
-            edgecolors=node_edgecolor,
-            linewidths=node_edgewidth,
-            ax=self.ax,
-        )
-        # Draw the edges of the graph
-        nx.draw_networkx_edges(
-            self.graph.network,
-            pos=node_coordinates,
-            width=edge_width,
-            edge_color=edge_color,
-            ax=self.ax,
-        )
-
-    def plot_subnetwork(
-        self,
-        nodes: Union[List, Tuple, np.ndarray],
-        node_size: Union[int, np.ndarray] = 50,
-        node_shape: str = "o",
-        node_edgewidth: float = 1.0,
-        edge_width: float = 1.0,
-        node_color: Union[str, List, Tuple, np.ndarray] = "white",
-        node_edgecolor: Union[str, List, Tuple, np.ndarray] = "black",
-        edge_color: Union[str, List, Tuple, np.ndarray] = "black",
-        node_alpha: Union[float, None] = None,
-        edge_alpha: Union[float, None] = None,
-    ) -> None:
-        """Plot a subnetwork of selected nodes with customizable node and edge attributes.
-
-        Args:
-            nodes (list, tuple, or np.ndarray): List of node labels to include in the subnetwork. Accepts nested lists.
-            node_size (int or np.ndarray, optional): Size of the nodes. Can be a single integer or an array of sizes. Defaults to 50.
-            node_shape (str, optional): Shape of the nodes. Defaults to "o".
-            node_edgewidth (float, optional): Width of the node edges. Defaults to 1.0.
-            edge_width (float, optional): Width of the edges. Defaults to 1.0.
-            node_color (str, list, tuple, or np.ndarray, optional): Color of the nodes. Defaults to "white".
-            node_edgecolor (str, list, tuple, or np.ndarray, optional): Color of the node edges. Defaults to "black".
-            edge_color (str, list, tuple, or np.ndarray, optional): Color of the edges. Defaults to "black".
-            node_alpha (float, None, optional): Transparency for the nodes. If provided, it overrides any existing alpha values
-                found in node_color. Defaults to 1.0.
-            edge_alpha (float, None, optional): Transparency for the edges. If provided, it overrides any existing alpha values
-                found in node_color. Defaults to 1.0.
-
-        Raises:
-            ValueError: If no valid nodes are found in the network graph.
-        """
-        # Flatten nested lists of nodes, if necessary
-        if any(isinstance(item, (list, tuple, np.ndarray)) for item in nodes):
-            nodes = [node for sublist in nodes for node in sublist]
-
-        # Filter to get node IDs and their coordinates
-        node_ids = [
-            self.graph.node_label_to_node_id_map.get(node)
-            for node in nodes
-            if node in self.graph.node_label_to_node_id_map
-        ]
-        if not node_ids:
-            raise ValueError("No nodes found in the network graph.")
-
-        # Check if node_color is a single color or a list of colors
-        if not isinstance(node_color, (str, tuple, np.ndarray)):
-            node_color = [
-                node_color[nodes.index(node)]
-                for node in nodes
-                if node in self.graph.node_label_to_node_id_map
-            ]
-
-        # Convert colors to RGBA using the to_rgba helper function
-        node_color = to_rgba(color=node_color, alpha=node_alpha, num_repeats=len(node_ids))
-        node_edgecolor = to_rgba(color=node_edgecolor, alpha=1.0, num_repeats=len(node_ids))
-        edge_color = to_rgba(
-            color=edge_color, alpha=edge_alpha, num_repeats=len(self.graph.network.edges)
-        )
-
-        # Get the coordinates of the filtered nodes
-        node_coordinates = {node_id: self.graph.node_coordinates[node_id] for node_id in node_ids}
-
-        # Draw the nodes in the subnetwork
-        nx.draw_networkx_nodes(
-            self.graph.network,
-            pos=node_coordinates,
-            nodelist=node_ids,
-            node_size=node_size,
-            node_shape=node_shape,
-            node_color=node_color,
-            edgecolors=node_edgecolor,
-            linewidths=node_edgewidth,
-            ax=self.ax,
-        )
-        # Draw the edges between the specified nodes in the subnetwork
-        subgraph = self.graph.network.subgraph(node_ids)
-        nx.draw_networkx_edges(
-            subgraph,
-            pos=node_coordinates,
-            width=edge_width,
-            edge_color=edge_color,
-            ax=self.ax,
-        )
-
-    def get_annotated_node_colors(
-        self,
-        cmap: str = "gist_rainbow",
-        color: Union[str, list, tuple, np.ndarray, None] = None,
-        min_scale: float = 0.8,
-        max_scale: float = 1.0,
-        scale_factor: float = 1.0,
-        alpha: Union[float, None] = 1.0,
-        nonenriched_color: Union[str, list, tuple, np.ndarray] = "white",
-        nonenriched_alpha: Union[float, None] = 1.0,
-        random_seed: int = 888,
-    ) -> np.ndarray:
-        """Adjust the colors of nodes in the network graph based on enrichment.
-
-        Args:
-            cmap (str, optional): Colormap to use for coloring the nodes. Defaults to "gist_rainbow".
-            color (str, list, tuple, np.ndarray, or None, optional): Color to use for the nodes. Can be a single color or an array of colors.
-                If None, the colormap will be used. Defaults to None.
-            min_scale (float, optional): Minimum scale for color intensity. Defaults to 0.8.
-            max_scale (float, optional): Maximum scale for color intensity. Defaults to 1.0.
-            scale_factor (float, optional): Factor for adjusting the color scaling intensity. Defaults to 1.0.
-            alpha (float, None, optional): Alpha value for enriched nodes. If provided, it overrides any existing alpha values found in `color`.
-                Defaults to 1.0.
-            nonenriched_color (str, list, tuple, or np.ndarray, optional): Color for non-enriched nodes. Can be a single color or an array of colors.
-                Defaults to "white".
-            nonenriched_alpha (float, None, optional): Alpha value for non-enriched nodes. If provided, it overrides any existing alpha values found
-                in `nonenriched_color`. Defaults to 1.0.
-            random_seed (int, optional): Seed for random number generation. Defaults to 888.
-
-        Returns:
-            np.ndarray: Array of RGBA colors adjusted for enrichment status.
-        """
-        # Get the initial domain colors for each node, which are returned as RGBA
-        network_colors = get_domain_colors(
-            graph=self.graph,
-            cmap=cmap,
-            color=color,
-            min_scale=min_scale,
-            max_scale=max_scale,
-            scale_factor=scale_factor,
-            random_seed=random_seed,
-        )
-        # Apply the alpha value for enriched nodes
-        network_colors[:, 3] = alpha  # Apply the alpha value to the enriched nodes' A channel
-        # Convert the non-enriched color to RGBA using the to_rgba helper function
-        nonenriched_color = to_rgba(
-            color=nonenriched_color, alpha=nonenriched_alpha, num_repeats=1
-        )  # num_repeats=1 for a single color
-        # Adjust node colors: replace any nodes where all three RGB values are equal and less than 0.1
-        # 0.1 is a predefined threshold for the minimum color intensity
-        adjusted_network_colors = np.where(
-            (
-                np.all(network_colors[:, :3] < 0.1, axis=1)
-                & np.all(network_colors[:, :3] == network_colors[:, 0:1], axis=1)
-            )[:, None],
-            np.tile(
-                np.array(nonenriched_color), (network_colors.shape[0], 1)
-            ),  # Replace with the full RGBA non-enriched color
-            network_colors,  # Keep the original colors where no match is found
-        )
-        return adjusted_network_colors
-
-    def get_annotated_node_sizes(
-        self, enriched_size: int = 50, nonenriched_size: int = 25
-    ) -> np.ndarray:
-        """Adjust the sizes of nodes in the network graph based on whether they are enriched or not.
-
-        Args:
-            enriched_size (int): Size for enriched nodes. Defaults to 50.
-            nonenriched_size (int): Size for non-enriched nodes. Defaults to 25.
-
-        Returns:
-            np.ndarray: Array of node sizes, with enriched nodes larger than non-enriched ones.
-        """
-        # Merge all enriched nodes from the domain_id_to_node_ids_map dictionary
-        enriched_nodes = set()
-        for _, node_ids in self.graph.domain_id_to_node_ids_map.items():
-            enriched_nodes.update(node_ids)
-
-        # Initialize all node sizes to the non-enriched size
-        node_sizes = np.full(len(self.graph.network.nodes), nonenriched_size)
-        # Set the size for enriched nodes
-        for node in enriched_nodes:
-            if node in self.graph.network.nodes:
-                node_sizes[node] = enriched_size
-
-        return node_sizes

risk/network/plot/plotter.py

@@ -1,137 +0,0 @@
-"""
-risk/network/plot/plotter
-~~~~~~~~~~~~~~~~~~~~~~~~~
-"""
-
-from typing import List, Tuple, Union
-
-import matplotlib.pyplot as plt
-import numpy as np
-
-from risk.log import params
-from risk.network.graph import NetworkGraph
-from risk.network.plot.canvas import Canvas
-from risk.network.plot.contour import Contour
-from risk.network.plot.labels import Labels
-from risk.network.plot.network import Network
-from risk.network.plot.utils.color import to_rgba
-from risk.network.plot.utils.layout import calculate_bounding_box
-
-
-class NetworkPlotter(Canvas, Network, Contour, Labels):
-    """A class for visualizing network graphs with customizable options.
-
-    The NetworkPlotter class uses a NetworkGraph object and provides methods to plot the network with
-    flexible node and edge properties. It also supports plotting labels, contours, drawing the network's
-    perimeter, and adjusting background colors.
-    """
-
-    def __init__(
-        self,
-        graph: NetworkGraph,
-        figsize: Tuple = (10, 10),
-        background_color: Union[str, List, Tuple, np.ndarray] = "white",
-        background_alpha: Union[float, None] = 1.0,
-        pad: float = 0.3,
-    ) -> None:
-        """Initialize the NetworkPlotter with a NetworkGraph object and plotting parameters.
-
-        Args:
-            graph (NetworkGraph): The network data and attributes to be visualized.
-            figsize (tuple, optional): Size of the figure in inches (width, height). Defaults to (10, 10).
-            background_color (str, list, tuple, np.ndarray, 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.
-        """
-        self.graph = graph
-        # Initialize the plot with the specified parameters
-        self.ax = self._initialize_plot(
-            graph=graph,
-            figsize=figsize,
-            background_color=background_color,
-            background_alpha=background_alpha,
-            pad=pad,
-        )
-        super().__init__(graph=graph, ax=self.ax)
-
-    def _initialize_plot(
-        self,
-        graph: NetworkGraph,
-        figsize: Tuple,
-        background_color: Union[str, list, tuple, np.ndarray],
-        background_alpha: Union[float, None],
-        pad: float,
-    ) -> plt.Axes:
-        """Set up the plot with figure size and background color.
-
-        Args:
-            graph (NetworkGraph): The network data and attributes to be visualized.
-            figsize (tuple): Size of the figure in inches (width, height).
-            background_color (str, list, tuple, or np.ndarray): Background color of the plot. Can be a single color or an array of colors.
-            background_alpha (float, None, optional): Transparency level of the background color. If provided, it overrides any existing
-                alpha values found in `background_color`.
-            pad (float, optional): Padding value to adjust the axis limits.
-
-        Returns:
-            plt.Axes: The axis object for the plot.
-        """
-        # Log the plotter settings
-        params.log_plotter(
-            figsize=figsize,
-            background_color=background_color,
-            background_alpha=background_alpha,
-            pad=pad,
-        )
-
-        # Extract node coordinates from the network graph
-        node_coordinates = graph.node_coordinates
-        # Calculate the center and radius of the bounding box around the network
-        center, radius = calculate_bounding_box(node_coordinates)
-
-        # Create a new figure and axis for plotting
-        fig, ax = plt.subplots(figsize=figsize)
-        fig.tight_layout()  # Adjust subplot parameters to give specified padding
-        # Set axis limits based on the calculated bounding box and radius
-        ax.set_xlim([center[0] - radius - pad, center[0] + radius + pad])
-        ax.set_ylim([center[1] - radius - pad, center[1] + radius + pad])
-        ax.set_aspect("equal")  # Ensure the aspect ratio is equal
-
-        # Set the background color of the plot
-        # Convert color to RGBA using the to_rgba helper function
-        fig.patch.set_facecolor(
-            to_rgba(color=background_color, alpha=background_alpha, num_repeats=1)
-        )  # num_repeats=1 for single color
-        ax.invert_yaxis()  # Invert the y-axis to match typical image coordinates
-        # Remove axis spines for a cleaner look
-        for spine in ax.spines.values():
-            spine.set_visible(False)
-
-        # Hide axis ticks and labels
-        ax.set_xticks([])
-        ax.set_yticks([])
-        ax.patch.set_visible(False)  # Hide the axis background
-
-        return ax
-
-    @staticmethod
-    def savefig(*args, pad_inches: float = 0.5, dpi: int = 100, **kwargs) -> None:
-        """Save the current plot to a file with additional export options.
-
-        Args:
-            *args: Positional arguments passed to `plt.savefig`.
-            pad_inches (float, optional): Padding around the figure when saving. Defaults to 0.5.
-            dpi (int, optional): Dots per inch (DPI) for the exported image. Defaults to 300.
-            **kwargs: Keyword arguments passed to `plt.savefig`, such as filename and format.
-        """
-        plt.savefig(*args, bbox_inches="tight", pad_inches=pad_inches, dpi=dpi, **kwargs)
-
-    @staticmethod
-    def show(*args, **kwargs) -> None:
-        """Display the current plot.
-
-        Args:
-            *args: Positional arguments passed to `plt.show`.
-            **kwargs: Keyword arguments passed to `plt.show`.
-        """
-        plt.show(*args, **kwargs)