risk-network 0.0.7b11__py3-none-any.whl → 0.0.8__py3-none-any.whl

risk/network/graph.py

@@ -4,12 +4,11 @@ risk/network/graph
 """
 
 from collections import defaultdict
-from typing import Any, Dict, List, Tuple, Union
+from typing import Any, Dict, List
 
 import networkx as nx
 import numpy as np
 import pandas as pd
-import matplotlib
 
 
 class NetworkGraph:
@@ -37,7 +36,7 @@ class NetworkGraph:
             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_label_to_node_id_map (Dict[str, Any]): 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
@@ -46,7 +45,14 @@ class NetworkGraph:
         self.domain_id_to_domain_terms_map = self._create_domain_id_to_domain_terms_map(
             trimmed_domains
         )
+        self.domain_id_to_domain_info_map = self._create_domain_id_to_domain_info_map(
+            trimmed_domains
+        )
+        self.trimmed_domains = trimmed_domains
         self.node_enrichment_sums = node_enrichment_sums
+        self.node_id_to_domain_ids_and_enrichments_map = (
+            self._create_node_id_to_domain_ids_and_enrichments(domains)
+        )
         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)
@@ -58,179 +64,107 @@ class NetworkGraph:
         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]:
+    @staticmethod
+    def _create_domain_id_to_node_ids_map(domains: pd.DataFrame) -> Dict[int, 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.
+            Dict[int, Any]: 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()
+        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]:
+    @staticmethod
+    def _create_domain_id_to_domain_terms_map(trimmed_domains: pd.DataFrame) -> Dict[int, 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.
+            Dict[int, Any]: A dictionary mapping domain IDs to their corresponding terms.
         """
         return dict(
             zip(
                 trimmed_domains.index,
-                trimmed_domains["label"],
+                trimmed_domains["normalized_description"],
             )
         )
 
-    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 get_domain_colors(
-        self,
-        cmap: str = "gist_rainbow",
-        color: Union[str, None] = None,
-        min_scale: float = 0.8,
-        max_scale: float = 1.0,
-        scale_factor: float = 1.0,
-        random_seed: int = 888,
-    ) -> np.ndarray:
-        """Generate composite colors for domains based on enrichment or specified colors.
+    @staticmethod
+    def _create_domain_id_to_domain_info_map(
+        trimmed_domains: pd.DataFrame,
+    ) -> Dict[int, Dict[str, Any]]:
+        """Create a mapping from domain IDs to their corresponding full description and enrichment score.
 
         Args:
-            cmap (str, optional): Name of the colormap to use for generating domain colors. Defaults to "gist_rainbow".
-            color (str or None, optional): A specific color to use for all generated colors. Defaults to None.
-            min_scale (float, optional): Minimum intensity scale for the colors generated by the colormap.
-                Controls the dimmest colors. Defaults to 0.8.
-            max_scale (float, optional): Maximum intensity scale for the colors generated by the colormap.
-                Controls the brightest colors. Defaults to 1.0.
-            scale_factor (float, optional): Exponent for adjusting the color scaling based on enrichment scores.
-                A higher value increases contrast by dimming lower scores more. Defaults to 1.0.
-            random_seed (int, optional): Seed for random number generation to ensure reproducibility of color assignments.
-                Defaults to 888.
+            trimmed_domains (pd.DataFrame): DataFrame containing domain IDs, full descriptions, and enrichment scores.
 
         Returns:
-            np.ndarray: Array of RGBA colors generated for each domain, based on enrichment or the specified color.
+            Dict[int, Dict[str, Any]]: A dictionary mapping domain IDs (int) to a dictionary with 'full_descriptions' and 'enrichment_scores'.
         """
-        # Get colors for each domain
-        domain_colors = self._get_domain_colors(cmap=cmap, color=color, random_seed=random_seed)
-        # Generate composite colors for nodes
-        node_colors = self._get_composite_node_colors(domain_colors)
-        # Transform colors to ensure proper alpha values and intensity
-        transformed_colors = _transform_colors(
-            node_colors,
-            self.node_enrichment_sums,
-            min_scale=min_scale,
-            max_scale=max_scale,
-            scale_factor=scale_factor,
-        )
-
-        return transformed_colors
-
-    def _get_composite_node_colors(self, domain_colors: np.ndarray) -> np.ndarray:
-        """Generate composite colors for nodes based on domain colors and counts.
+        return {
+            int(id_): {
+                "full_descriptions": trimmed_domains.at[id_, "full_descriptions"],
+                "enrichment_scores": trimmed_domains.at[id_, "enrichment_scores"],
+            }
+            for id_ in trimmed_domains.index
+        }
+
+    @staticmethod
+    def _create_node_id_to_domain_ids_and_enrichments(domains: pd.DataFrame) -> Dict[int, Dict]:
+        """Creates a dictionary mapping each node ID to its corresponding domain IDs and enrichment values.
 
         Args:
-            domain_colors (np.ndarray): Array of colors corresponding to each domain.
+            domains (pd.DataFrame): A DataFrame containing domain information for each node. Assumes the last
+                two columns are 'all domains' and 'primary domain', which are excluded from processing.
 
         Returns:
-            np.ndarray: Array of composite colors for each node.
+            Dict[int, Dict]: A dictionary where the key is the node ID (index of the DataFrame), and the value is another dictionary
+                with 'domain' (a list of domain IDs with non-zero enrichment) and 'enrichment'
+                (a dict of domain IDs and their corresponding enrichment values).
         """
-        # Determine the number of nodes
-        num_nodes = len(self.node_coordinates)
-        # Initialize composite colors array with shape (number of nodes, 4) for RGBA
-        composite_colors = np.zeros((num_nodes, 4))
-        # Assign colors to nodes based on domain_colors
-        for domain_id, nodes in self.domain_id_to_node_ids_map.items():
-            color = domain_colors[domain_id]
-            for node in nodes:
-                composite_colors[node] = color
-
-        return composite_colors
-
-    def _get_domain_colors(
-        self,
-        cmap: str = "gist_rainbow",
-        color: Union[str, None] = None,
-        random_seed: int = 888,
-    ) -> Dict[str, Any]:
-        """Get colors for each domain.
+        # Initialize an empty dictionary to store the result
+        node_id_to_domain_ids_and_enrichments = {}
+        # Get the list of domain columns (excluding 'all domains' and 'primary domain')
+        domain_columns = domains.columns[
+            :-2
+        ]  # The last two columns are 'all domains' and 'primary domain'
+        # Iterate over each row in the dataframe
+        for idx, row in domains.iterrows():
+            # Get the domains (column names) where the enrichment score is greater than 0
+            all_domains = domain_columns[row[domain_columns] > 0].tolist()
+            # Get the enrichment values for those domains
+            enrichment_values = row[all_domains].to_dict()
+            # Store the result in the dictionary with index as the key
+            node_id_to_domain_ids_and_enrichments[idx] = {
+                "domains": all_domains,  # The column names where enrichment > 0
+                "enrichments": enrichment_values,  # The actual enrichment values for those columns
+            }
+
+        return node_id_to_domain_ids_and_enrichments
 
-        Args:
-            cmap (str, optional): The name of the colormap to use. Defaults to "gist_rainbow".
-            color (str or None, optional): A specific color to use for all generated colors. Defaults to None.
-            random_seed (int, optional): Seed for random number generation. Defaults to 888.
+    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 keys to their corresponding RGBA colors.
+            Dict[int, List[str]]: A dictionary mapping domain IDs to the corresponding node labels.
         """
-        # Get colors for each domain based on node positions
-        domain_colors = _get_colors(
-            self.network,
-            self.domain_id_to_node_ids_map,
-            cmap=cmap,
-            color=color,
-            random_seed=random_seed,
-        )
-        self.network, self.domain_id_to_node_ids_map
-        return dict(zip(self.domain_id_to_node_ids_map.keys(), domain_colors))
-
-
-def _transform_colors(
-    colors: np.ndarray,
-    enrichment_sums: np.ndarray,
-    min_scale: float = 0.8,
-    max_scale: float = 1.0,
-    scale_factor: float = 1.0,
-) -> np.ndarray:
-    """Transform colors using power scaling to emphasize high enrichment sums more.
-
-    Args:
-        colors (np.ndarray): An array of RGBA colors.
-        enrichment_sums (np.ndarray): An array of enrichment sums corresponding to the colors.
-        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): Exponent for scaling, where values > 1 increase contrast by dimming small
-            values more. Defaults to 1.0.
-
-    Returns:
-        np.ndarray: The transformed array of RGBA colors with adjusted intensities.
-    """
-    if min_scale == max_scale:
-        min_scale = max_scale - 10e-6  # Avoid division by zero
-
-    # Normalize the enrichment sums to the range [0, 1]
-    normalized_sums = enrichment_sums / np.max(enrichment_sums)
-    # Apply power scaling to dim lower values and emphasize higher values
-    scaled_sums = normalized_sums**scale_factor
-    # Linearly scale the normalized sums to the range [min_scale, max_scale]
-    scaled_sums = min_scale + (max_scale - min_scale) * scaled_sums
-    # Adjust RGB values based on scaled sums
-    for i in range(3):  # Only adjust RGB values
-        colors[:, i] = scaled_sums * colors[:, i]
+        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 colors
+        return domain_id_to_label_map
 
 
 def _unfold_sphere_to_plane(G: nx.Graph) -> nx.Graph:
@@ -283,103 +217,3 @@ def _extract_node_coordinates(G: nx.Graph) -> np.ndarray:
     }
     node_coordinates = np.vstack(list(node_positions.values()))
     return node_coordinates
-
-
-def _get_colors(
-    network,
-    domain_id_to_node_ids_map,
-    cmap: str = "gist_rainbow",
-    color: Union[str, None] = None,
-    random_seed: int = 888,
-) -> List[Tuple]:
-    """Generate a list of RGBA colors based on domain centroids, ensuring that domains
-    close in space get maximally separated colors, while keeping some randomness.
-
-    Args:
-        network (NetworkX graph): The graph representing the network.
-        domain_id_to_node_ids_map (dict): Mapping from domain IDs to lists of node IDs.
-        cmap (str, optional): The name of the colormap to use. Defaults to "gist_rainbow".
-        color (str or None, optional): A specific color to use for all generated colors.
-        random_seed (int): Seed for random number generation. Defaults to 888.
-
-    Returns:
-        List[Tuple]: List of RGBA colors.
-    """
-    # Set random seed for reproducibility
-    np.random.seed(random_seed)
-    # Determine the number of colors to generate based on the number of domains
-    num_colors_to_generate = len(domain_id_to_node_ids_map)
-    if color:
-        # Generate all colors as the same specified color
-        rgba = matplotlib.colors.to_rgba(color)
-        return [rgba] * num_colors_to_generate
-
-    # Load colormap
-    colormap = matplotlib.colormaps.get_cmap(cmap)
-    # Step 1: Calculate centroids for each domain
-    centroids = _calculate_centroids(network, domain_id_to_node_ids_map)
-    # Step 2: Calculate pairwise distances between centroids
-    centroid_array = np.array(centroids)
-    dist_matrix = np.linalg.norm(centroid_array[:, None] - centroid_array, axis=-1)
-    # Step 3: Assign distant colors to close centroids
-    color_positions = _assign_distant_colors(dist_matrix, num_colors_to_generate)
-    # Step 4: Randomly shift the entire color palette while maintaining relative distances
-    global_shift = np.random.uniform(-0.1, 0.1)  # Small global shift to change the overall palette
-    color_positions = (color_positions + global_shift) % 1  # Wrap around to keep within [0, 1]
-    # Step 5: Ensure that all positions remain between 0 and 1
-    color_positions = np.clip(color_positions, 0, 1)
-
-    # Step 6: Generate RGBA colors based on positions
-    return [colormap(pos) for pos in color_positions]
-
-
-def _calculate_centroids(network, domain_id_to_node_ids_map):
-    """Calculate the centroid for each domain based on node x and y coordinates in the network.
-
-    Args:
-        network (NetworkX graph): The graph representing the network.
-        domain_id_to_node_ids_map (dict): Mapping from domain IDs to lists of node IDs.
-
-    Returns:
-        List[Tuple[float, float]]: List of centroids (x, y) for each domain.
-    """
-    centroids = []
-    for domain_id, node_ids in domain_id_to_node_ids_map.items():
-        # Extract x and y coordinates from the network nodes
-        node_positions = np.array(
-            [[network.nodes[node_id]["x"], network.nodes[node_id]["y"]] for node_id in node_ids]
-        )
-        # Compute the centroid as the mean of the x and y coordinates
-        centroid = np.mean(node_positions, axis=0)
-        centroids.append(tuple(centroid))
-
-    return centroids
-
-
-def _assign_distant_colors(dist_matrix, num_colors_to_generate):
-    """Assign colors to centroids that are close in space, ensuring stark color differences.
-
-    Args:
-        dist_matrix (ndarray): Matrix of pairwise centroid distances.
-        num_colors_to_generate (int): Number of colors to generate.
-
-    Returns:
-        np.array: Array of color positions in the range [0, 1].
-    """
-    color_positions = np.zeros(num_colors_to_generate)
-    # Step 1: Sort indices by centroid proximity (based on sum of distances to others)
-    proximity_order = sorted(
-        range(num_colors_to_generate), key=lambda idx: np.sum(dist_matrix[idx])
-    )
-    # Step 2: Assign colors starting with the most distant points in proximity order
-    for i, idx in enumerate(proximity_order):
-        color_positions[idx] = i / num_colors_to_generate
-
-    # Step 3: Adjust colors so that centroids close to one another are maximally distant on the color spectrum
-    half_spectrum = int(num_colors_to_generate / 2)
-    for i in range(half_spectrum):
-        # Split the spectrum so that close centroids are assigned distant colors
-        color_positions[proximity_order[i]] = (i * 2) / num_colors_to_generate
-        color_positions[proximity_order[-(i + 1)]] = ((i * 2) + 1) / num_colors_to_generate
-
-    return color_positions

risk/network/io.py

@@ -5,6 +5,7 @@ risk/network/io
 This file contains the code for the RISK class and command-line access.
 """
 
+import copy
 import json
 import os
 import pickle
@@ -13,6 +14,7 @@ import zipfile
 from xml.dom import minidom
 
 import networkx as nx
+import numpy as np
 import pandas as pd
 
 from risk.network.geometry import assign_edge_lengths
@@ -153,8 +155,10 @@ class NetworkIO:
         params.log_network(filetype=filetype)
         self._log_loading(filetype)
 
+        # Important: Make a copy of the network to avoid modifying the original
+        network_copy = copy.deepcopy(network)
         # Initialize the graph
-        return self._initialize_graph(network)
+        return self._initialize_graph(network_copy)
 
     @staticmethod
     def load_cytoscape_network(
@@ -451,10 +455,10 @@ class NetworkIO:
         # Log the number of nodes and edges before and after cleaning
         num_final_nodes = G.number_of_nodes()
         num_final_edges = G.number_of_edges()
-        logger.info(f"Initial node count: {num_initial_nodes}")
-        logger.info(f"Final node count: {num_final_nodes}")
-        logger.info(f"Initial edge count: {num_initial_edges}")
-        logger.info(f"Final edge count: {num_final_edges}")
+        logger.debug(f"Initial node count: {num_initial_nodes}")
+        logger.debug(f"Final node count: {num_final_nodes}")
+        logger.debug(f"Initial edge count: {num_initial_edges}")
+        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.
@@ -472,19 +476,53 @@ class NetworkIO:
             )  # Default to 1.0 if 'weight' not present
 
         if self.include_edge_weight and missing_weights:
-            logger.info(f"Total edges missing weights: {missing_weights}")
+            logger.debug(f"Total edges missing weights: {missing_weights}")
 
     def _validate_nodes(self, G: nx.Graph) -> None:
-        """Validate the graph structure and attributes.
+        """Validate the graph structure and attributes with attribute fallback for positions and labels.
 
         Args:
             G (nx.Graph): A NetworkX graph object.
         """
+        # Keep track of nodes missing labels
+        nodes_with_missing_labels = []
+
         for node, attrs in G.nodes(data=True):
-            assert (
-                "x" in attrs and "y" in attrs
-            ), f"Node {node} is missing 'x' or 'y' position attributes."
-            assert "label" in attrs, f"Node {node} is missing a 'label' attribute."
+            # Attribute fallback for '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
+                ):
+                    attrs["x"], attrs["y"] = attrs["pos"][
+                        :2
+                    ]  # Use only x and y, ignoring z if present
+                else:
+                    raise ValueError(
+                        f"Node {node} is missing 'x', 'y', and a valid 'pos' attribute."
+                    )
+
+            # Attribute fallback for '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"]
+                else:
+                    # Collect nodes with missing labels
+                    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
+        if nodes_with_missing_labels:
+            total_nodes = len(G.nodes)
+            fraction_missing_labels = len(nodes_with_missing_labels) / total_nodes
+            logger.warning(
+                f"{len(nodes_with_missing_labels)} out of {total_nodes} nodes "
+                f"({fraction_missing_labels:.2%}) were missing 'label' attributes and were assigned node IDs."
+            )
 
     def _assign_edge_lengths(self, G: nx.Graph) -> None:
         """Prepare the network by adjusting surface depth and calculating edge lengths.
@@ -511,13 +549,13 @@ class NetworkIO:
             filepath (str, optional): The path to the file being loaded. Defaults to "".
         """
         log_header("Loading network")
-        logger.info(f"Filetype: {filetype}")
+        logger.debug(f"Filetype: {filetype}")
         if filepath:
-            logger.info(f"Filepath: {filepath}")
-        logger.info(f"Edge weight: {'Included' if self.include_edge_weight else 'Excluded'}")
+            logger.debug(f"Filepath: {filepath}")
+        logger.debug(f"Edge weight: {'Included' if self.include_edge_weight else 'Excluded'}")
         if self.include_edge_weight:
-            logger.info(f"Weight label: {self.weight_label}")
-        logger.info(f"Minimum edges per node: {self.min_edges_per_node}")
-        logger.info(f"Projection: {'Sphere' if self.compute_sphere else 'Plane'}")
+            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:
-            logger.info(f"Surface depth: {self.surface_depth}")
+            logger.debug(f"Surface depth: {self.surface_depth}")

risk/network/plot/__init__.py

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