risk-network 0.0.6b8__tar.gz → 0.0.6b10__tar.gz

{risk_network-0.0.6b8 → risk_network-0.0.6b10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: risk-network
-Version: 0.0.6b8
+Version: 0.0.6b10
 Summary: A Python package for biological network analysis
 Author: Ira Horecka
 Author-email: Ira Horecka <ira89@icloud.com>

{risk_network-0.0.6b8 → risk_network-0.0.6b10}/risk/__init__.py

@@ -7,4 +7,4 @@ RISK: RISK Infers Spatial Kinships
 
 from risk.risk import RISK
 
-__version__ = "0.0.6-beta.8"
+__version__ = "0.0.6-beta.10"

{risk_network-0.0.6b8 → risk_network-0.0.6b10}/risk/log/params.py

@@ -7,6 +7,7 @@ import csv
 import json
 import warnings
 from datetime import datetime
+from functools import wraps
 from typing import Any, Dict
 
 import numpy as np
@@ -27,6 +28,7 @@ def _safe_param_export(func):
         function: The wrapped function with error handling.
     """
 
+    @wraps(func)
     def wrapper(*args, **kwargs):
         try:
             result = func(*args, **kwargs)

{risk_network-0.0.6b8 → risk_network-0.0.6b10}/risk/network/graph.py

@@ -28,7 +28,7 @@ class NetworkGraph:
         top_annotations: pd.DataFrame,
         domains: pd.DataFrame,
         trimmed_domains: pd.DataFrame,
-        node_label_to_id_map: Dict[str, Any],
+        node_label_to_node_id_map: Dict[str, Any],
         node_enrichment_sums: np.ndarray,
     ):
         """Initialize the NetworkGraph object.
@@ -38,43 +38,48 @@ 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_id_map (dict): A dictionary mapping node labels to their corresponding IDs.
+            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_to_nodes_map = self._create_domain_to_nodes_map(domains)
+        self.domain_id_to_node_ids_map = self._create_domain_id_to_node_ids_map(domains)
         self.domains = domains
-        self.trimmed_domain_to_term = self._create_domain_to_term_map(trimmed_domains)
-        self.trimmed_domains = trimmed_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_label_map = {v: k for k, v in node_label_to_id_map.items()}
+        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_id_map.keys(), node_enrichment_sums)
+            zip(node_label_to_node_id_map.keys(), node_enrichment_sums)
         )
-        self.node_label_to_id_map = node_label_to_id_map
-        # NOTE: self.network and self.node_coordinates are declared in _initialize_network
+        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()
+        # self.network and self.node_coordinates are properly declared in _initialize_network
         self.network = None
         self.node_coordinates = None
         self._initialize_network(network)
 
-    def _create_domain_to_nodes_map(self, domains: pd.DataFrame) -> Dict[str, Any]:
-        """Create a mapping from domains to the list of nodes belonging to each domain.
+    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 nodes belonging to each domain.
+            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_to_nodes_map = defaultdict(list)
+        domain_id_to_node_ids_map = defaultdict(list)
         for k, v in node_to_domains_map.items():
-            domain_to_nodes_map[v].append(k)
+            domain_id_to_node_ids_map[v].append(k)
 
-        return domain_to_nodes_map
+        return domain_id_to_node_ids_map
 
-    def _create_domain_to_term_map(self, trimmed_domains: pd.DataFrame) -> Dict[str, Any]:
+    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:
@@ -90,6 +95,20 @@ class NetworkGraph:
             )
         )
 
+    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 _initialize_network(self, G: nx.Graph) -> None:
         """Initialize the network by unfolding it and extracting node coordinates.
 
@@ -158,8 +177,8 @@ class NetworkGraph:
         # 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_idx, nodes in self.domain_to_nodes_map.items():
-            color = domain_colors[domain_idx]
+        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
 
@@ -189,7 +208,7 @@ class NetworkGraph:
         domain_colors = _get_colors(
             num_colors_to_generate=len(domains), cmap=cmap, color=color, random_seed=random_seed
         )
-        return dict(zip(self.domain_to_nodes_map.keys(), domain_colors))
+        return dict(zip(self.domain_id_to_node_ids_map.keys(), domain_colors))
 
 
 def _transform_colors(

{risk_network-0.0.6b8 → risk_network-0.0.6b10}/risk/network/plot.py

@@ -308,9 +308,9 @@ class NetworkPlotter:
 
         # Filter to get node IDs and their coordinates
         node_ids = [
-            self.graph.node_label_to_id_map.get(node)
+            self.graph.node_label_to_node_id_map.get(node)
             for node in nodes
-            if node in self.graph.node_label_to_id_map
+            if node in self.graph.node_label_to_node_id_map
         ]
         if not node_ids:
             raise ValueError("No nodes found in the network graph.")
@@ -320,7 +320,7 @@ class NetworkPlotter:
             node_color = [
                 node_color[nodes.index(node)]
                 for node in nodes
-                if node in self.graph.node_label_to_id_map
+                if node in self.graph.node_label_to_node_id_map
             ]
 
         # Convert colors to RGBA using the _to_rgba helper function
@@ -389,16 +389,16 @@ class NetworkPlotter:
         )
 
         # Ensure color is converted to RGBA with repetition matching the number of domains
-        color = _to_rgba(color, alpha, num_repeats=len(self.graph.domain_to_nodes_map))
+        color = _to_rgba(color, alpha, num_repeats=len(self.graph.domain_id_to_node_ids_map))
         # Extract node coordinates from the network graph
         node_coordinates = self.graph.node_coordinates
         # Draw contours for each domain in the network
-        for idx, (_, nodes) in enumerate(self.graph.domain_to_nodes_map.items()):
-            if len(nodes) > 1:
+        for idx, (_, node_ids) in enumerate(self.graph.domain_id_to_node_ids_map.items()):
+            if len(node_ids) > 1:
                 self._draw_kde_contour(
                     self.ax,
                     node_coordinates,
-                    nodes,
+                    node_ids,
                     color=color[idx],
                     levels=levels,
                     bandwidth=bandwidth,
@@ -452,9 +452,9 @@ class NetworkPlotter:
         for sublist in node_groups:
             # Filter to get node IDs and their coordinates for each sublist
             node_ids = [
-                self.graph.node_label_to_id_map.get(node)
+                self.graph.node_label_to_node_id_map.get(node)
                 for node in sublist
-                if node in self.graph.node_label_to_id_map
+                if node in self.graph.node_label_to_node_id_map
             ]
             if not node_ids or len(node_ids) == 1:
                 raise ValueError(
@@ -641,12 +641,14 @@ class NetworkPlotter:
 
         # Set max_labels to the total number of domains if not provided (None)
         if max_labels is None:
-            max_labels = len(self.graph.domain_to_nodes_map)
+            max_labels = len(self.graph.domain_id_to_node_ids_map)
 
         # Convert colors to RGBA using the _to_rgba helper function
-        fontcolor = _to_rgba(fontcolor, fontalpha, num_repeats=len(self.graph.domain_to_nodes_map))
+        fontcolor = _to_rgba(
+            fontcolor, fontalpha, num_repeats=len(self.graph.domain_id_to_node_ids_map)
+        )
         arrow_color = _to_rgba(
-            arrow_color, arrow_alpha, num_repeats=len(self.graph.domain_to_nodes_map)
+            arrow_color, arrow_alpha, num_repeats=len(self.graph.domain_id_to_node_ids_map)
         )
 
         # Normalize words_to_omit to lowercase
@@ -655,9 +657,9 @@ class NetworkPlotter:
 
         # Calculate the center and radius of the network
         domain_centroids = {}
-        for domain, nodes in self.graph.domain_to_nodes_map.items():
-            if nodes:  # Skip if the domain has no nodes
-                domain_centroids[domain] = self._calculate_domain_centroid(nodes)
+        for domain_id, node_ids in self.graph.domain_id_to_node_ids_map.items():
+            if node_ids:  # Skip if the domain has no nodes
+                domain_centroids[domain_id] = self._calculate_domain_centroid(node_ids)
 
         # Initialize dictionaries and lists for valid indices
         valid_indices = []
@@ -675,12 +677,15 @@ class NetworkPlotter:
 
             # Process the specified IDs first
             for domain in ids_to_keep:
-                if domain in self.graph.trimmed_domain_to_term and domain in domain_centroids:
+                if (
+                    domain in self.graph.domain_id_to_domain_terms_map
+                    and domain in domain_centroids
+                ):
                     # Handle ids_to_replace logic here for ids_to_keep
                     if ids_to_replace and domain in ids_to_replace:
                         terms = ids_to_replace[domain].split(" ")
                     else:
-                        terms = self.graph.trimmed_domain_to_term[domain].split(" ")
+                        terms = self.graph.domain_id_to_domain_terms_map[domain].split(" ")
 
                     # Apply words_to_omit, word length constraints, and max_words
                     if words_to_omit:
@@ -712,7 +717,7 @@ class NetworkPlotter:
                 if ids_to_replace and domain in ids_to_replace:
                     terms = ids_to_replace[domain].split(" ")
                 else:
-                    terms = self.graph.trimmed_domain_to_term[domain].split(" ")
+                    terms = self.graph.domain_id_to_domain_terms_map[domain].split(" ")
 
                 # Apply words_to_omit, word length constraints, and max_words
                 if words_to_omit:
@@ -835,9 +840,9 @@ class NetworkPlotter:
         for sublist in node_groups:
             # Map node labels to IDs
             node_ids = [
-                self.graph.node_label_to_id_map.get(node)
+                self.graph.node_label_to_node_id_map.get(node)
                 for node in sublist
-                if node in self.graph.node_label_to_id_map
+                if node in self.graph.node_label_to_node_id_map
             ]
             if not node_ids or len(node_ids) == 1:
                 raise ValueError(
@@ -948,10 +953,10 @@ class NetworkPlotter:
         Returns:
             np.ndarray: Array of node sizes, with enriched nodes larger than non-enriched ones.
         """
-        # Merge all enriched nodes from the domain_to_nodes_map dictionary
+        # Merge all enriched nodes from the domain_id_to_node_ids_map dictionary
         enriched_nodes = set()
-        for _, nodes in self.graph.domain_to_nodes_map.items():
-            enriched_nodes.update(nodes)
+        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)
@@ -1065,10 +1070,10 @@ class NetworkPlotter:
             random_seed=random_seed,
         )
         annotated_colors = []
-        for _, nodes in self.graph.domain_to_nodes_map.items():
-            if len(nodes) > 1:
+        for _, node_ids in self.graph.domain_id_to_node_ids_map.items():
+            if len(node_ids) > 1:
                 # For multi-node domains, choose the brightest color based on RGB sum
-                domain_colors = np.array([node_colors[node] for node in nodes])
+                domain_colors = np.array([node_colors[node] for node in node_ids])
                 brightest_color = domain_colors[
                     np.argmax(domain_colors[:, :3].sum(axis=1))  # Sum the RGB values
                 ]

{risk_network-0.0.6b8 → risk_network-0.0.6b10}/risk/risk.py

@@ -62,7 +62,7 @@ class RISK(NetworkIO, AnnotationsIO):
 
         Args:
             network (nx.Graph): The network graph.
-            annotations (pd.DataFrame): The matrix of annotations associated with the network.
+            annotations (dict): The annotations associated with the network.
             distance_metric (str, optional): Distance metric for neighborhood analysis. Defaults to "dijkstra".
             louvain_resolution (float, optional): Resolution parameter for Louvain clustering. Defaults to 0.1.
             edge_length_threshold (float, optional): Edge length threshold for neighborhood analysis. Defaults to 0.5.
@@ -131,7 +131,7 @@ class RISK(NetworkIO, AnnotationsIO):
 
         Args:
             network (nx.Graph): The network graph.
-            annotations (pd.DataFrame): The matrix of annotations associated with the network.
+            annotations (dict): The annotations associated with the network.
             distance_metric (str, optional): Distance metric for neighborhood analysis. Defaults to "dijkstra".
             louvain_resolution (float, optional): Resolution parameter for Louvain clustering. Defaults to 0.1.
             edge_length_threshold (float, optional): Edge length threshold for neighborhood analysis. Defaults to 0.5.
@@ -187,7 +187,7 @@ class RISK(NetworkIO, AnnotationsIO):
 
         Args:
             network (nx.Graph): The network graph.
-            annotations (pd.DataFrame): The matrix of annotations associated with the network.
+            annotations (dict): The annotations associated with the network.
             distance_metric (str, optional): Distance metric for neighborhood analysis. Defaults to "dijkstra".
             louvain_resolution (float, optional): Resolution parameter for Louvain clustering. Defaults to 0.1.
             edge_length_threshold (float, optional): Edge length threshold for neighborhood analysis. Defaults to 0.5.
@@ -343,7 +343,7 @@ class RISK(NetworkIO, AnnotationsIO):
             top_annotations=top_annotations,
             domains=domains,
             trimmed_domains=trimmed_domains,
-            node_label_to_id_map=node_label_to_id,
+            node_label_to_node_id_map=node_label_to_id,
             node_enrichment_sums=node_enrichment_sums,
         )
 

{risk_network-0.0.6b8 → risk_network-0.0.6b10}/risk_network.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: risk-network
-Version: 0.0.6b8
+Version: 0.0.6b10
 Summary: A Python package for biological network analysis
 Author: Ira Horecka
 Author-email: Ira Horecka <ira89@icloud.com>