risk-network 0.0.12b1__py3-none-any.whl → 0.0.12b3__py3-none-any.whl

risk/network/plotter/labels.py

@@ -134,7 +134,7 @@ class Labels:
             max_chars_per_line = int(1e6)
         # Normalize words_to_omit to lowercase
         if words_to_omit:
-            words_to_omit = set(word.lower() for word in words_to_omit)
+            words_to_omit = list(set(word.lower() for word in words_to_omit))
 
         # Calculate the center and radius of domains to position labels around the network
         domain_id_to_centroid_map = {}
@@ -205,13 +205,11 @@ class Labels:
         for idx, (domain, pos) in zip(valid_indices, best_label_positions.items()):
             centroid = filtered_domain_centroids[domain]
             # Split by special key TERM_DELIMITER to split annotation into multiple lines
-            annotations = filtered_domain_terms[domain].split(TERM_DELIMITER)
+            terms = filtered_domain_terms[domain].split(TERM_DELIMITER)
             if fontcase is not None:
-                annotations = self._apply_str_transformation(
-                    words=annotations, transformation=fontcase
-                )
+                terms = self._apply_str_transformation(words=terms, transformation=fontcase)
             self.ax.annotate(
-                "\n".join(annotations),
+                "\n".join(terms),
                 xy=centroid,
                 xytext=pos,
                 textcoords="data",
@@ -237,7 +235,7 @@ class Labels:
                 self.ax.text(
                     centroid[0],
                     centroid[1],
-                    domain,
+                    str(domain),
                     ha="center",
                     va="center",
                     fontsize=fontsize,
@@ -373,7 +371,7 @@ class Labels:
 
     def _process_ids_to_keep(
         self,
-        domain_id_to_centroid_map: Dict[str, np.ndarray],
+        domain_id_to_centroid_map: Dict[int, np.ndarray],
         ids_to_keep: Union[List[str], Tuple[str], np.ndarray],
         ids_to_labels: Union[Dict[int, str], None],
         words_to_omit: Union[List[str], None],
@@ -382,14 +380,14 @@ class Labels:
         max_label_lines: int,
         min_chars_per_line: int,
         max_chars_per_line: int,
-        filtered_domain_centroids: Dict[str, np.ndarray],
-        filtered_domain_terms: Dict[str, str],
+        filtered_domain_centroids: Dict[int, np.ndarray],
+        filtered_domain_terms: Dict[int, str],
         valid_indices: List[int],
     ) -> None:
         """Process the ids_to_keep, apply filtering, and store valid domain centroids and terms.
 
         Args:
-            domain_id_to_centroid_map (Dict[str, np.ndarray]): Mapping of domain IDs to their centroids.
+            domain_id_to_centroid_map (Dict[int, np.ndarray]): Mapping of domain IDs to their centroids.
             ids_to_keep (List, Tuple, or np.ndarray, optional): IDs of domains that must be labeled.
             ids_to_labels (Dict[int, str], None, optional): A dictionary mapping domain IDs to custom labels. Defaults to None.
             words_to_omit (List, optional): List of words to omit from the labels. Defaults to None.
@@ -398,7 +396,7 @@ class Labels:
             max_label_lines (int): Maximum number of lines in a label.
             min_chars_per_line (int): Minimum number of characters in a line to display.
             max_chars_per_line (int): Maximum number of characters in a line to display.
-            filtered_domain_centroids (Dict[str, np.ndarray]): Dictionary to store filtered domain centroids (output).
+            filtered_domain_centroids (Dict[int, np.ndarray]): Dictionary to store filtered domain centroids (output).
             filtered_domain_terms (Dict[str, str]): Dictionary to store filtered domain terms (output).
             valid_indices (List): List to store valid indices (output).
 
@@ -415,15 +413,15 @@ class Labels:
             )
 
         # Process each domain in ids_to_keep
-        for domain in ids_to_keep:
+        for domain_id in ids_to_keep:
             if (
-                domain in self.graph.domain_id_to_domain_terms_map
-                and domain in domain_id_to_centroid_map
+                domain_id in self.graph.domain_id_to_domain_terms_map
+                and domain_id in domain_id_to_centroid_map
             ):
-                domain_centroid = domain_id_to_centroid_map[domain]
+                domain_centroid = domain_id_to_centroid_map[domain_id]
                 # No need to filter the domain terms if it is in ids_to_keep
                 _ = self._validate_and_update_domain(
-                    domain=domain,
+                    domain_id=domain_id,
                     domain_centroid=domain_centroid,
                     domain_id_to_centroid_map=domain_id_to_centroid_map,
                     ids_to_labels=ids_to_labels,
@@ -439,7 +437,7 @@ class Labels:
 
     def _process_remaining_domains(
         self,
-        domain_id_to_centroid_map: Dict[str, np.ndarray],
+        domain_id_to_centroid_map: Dict[int, np.ndarray],
         ids_to_keep: Union[List[str], Tuple[str], np.ndarray],
         ids_to_labels: Union[Dict[int, str], None],
         words_to_omit: Union[List[str], None],
@@ -448,14 +446,14 @@ class Labels:
         max_label_lines: int,
         min_chars_per_line: int,
         max_chars_per_line: int,
-        filtered_domain_centroids: Dict[str, np.ndarray],
-        filtered_domain_terms: Dict[str, str],
+        filtered_domain_centroids: Dict[int, np.ndarray],
+        filtered_domain_terms: Dict[int, str],
         valid_indices: List[int],
     ) -> None:
         """Process remaining domains to fill in additional labels, respecting the remaining_labels limit.
 
         Args:
-            domain_id_to_centroid_map (Dict[str, np.ndarray]): Mapping of domain IDs to their centroids.
+            domain_id_to_centroid_map (Dict[int, np.ndarray]): Mapping of domain IDs to their centroids.
             ids_to_keep (List, Tuple, or np.ndarray, optional): IDs of domains that must be labeled.
             ids_to_labels (Dict[int, str], None, optional): A dictionary mapping domain IDs to custom labels. Defaults to None.
             words_to_omit (List, optional): List of words to omit from the labels. Defaults to None.
@@ -464,7 +462,7 @@ class Labels:
             max_label_lines (int): Maximum number of lines in a label.
             min_chars_per_line (int): Minimum number of characters in a line to display.
             max_chars_per_line (int): Maximum number of characters in a line to display.
-            filtered_domain_centroids (Dict[str, np.ndarray]): Dictionary to store filtered domain centroids (output).
+            filtered_domain_centroids (Dict[int, np.ndarray]): Dictionary to store filtered domain centroids (output).
             filtered_domain_terms (Dict[str, str]): Dictionary to store filtered domain terms (output).
             valid_indices (List): List to store valid indices (output).
 
@@ -485,24 +483,24 @@ class Labels:
             return np.linalg.norm(centroid1 - centroid2)
 
         # Domains to plot on network
-        selected_domains = []
+        selected_domain_ids = []
         # Find the farthest apart domains using centroids
         if remaining_domains and remaining_labels:
             first_domain = next(iter(remaining_domains))  # Pick the first domain to start
-            selected_domains.append(first_domain)
+            selected_domain_ids.append(first_domain)
 
-            while len(selected_domains) < remaining_labels:
+            while len(selected_domain_ids) < remaining_labels:
                 farthest_domain = None
                 max_distance = -1
                 # Find the domain farthest from any already selected domain
                 for candidate_domain, candidate_centroid in remaining_domains.items():
-                    if candidate_domain in selected_domains:
+                    if candidate_domain in selected_domain_ids:
                         continue
 
                     # Calculate the minimum distance to any selected domain
                     min_distance = min(
                         calculate_distance(candidate_centroid, remaining_domains[dom])
-                        for dom in selected_domains
+                        for dom in selected_domain_ids
                     )
                     # Update the farthest domain if the minimum distance is greater
                     if min_distance > max_distance:
@@ -511,15 +509,15 @@ class Labels:
 
                 # Add the farthest domain to the selected domains
                 if farthest_domain:
-                    selected_domains.append(farthest_domain)
+                    selected_domain_ids.append(farthest_domain)
                 else:
                     break  # No more domains to select
 
         # Process the selected domains and add to filtered lists
-        for domain in selected_domains:
-            domain_centroid = remaining_domains[domain]
+        for domain_id in selected_domain_ids:
+            domain_centroid = remaining_domains[domain_id]
             is_domain_valid = self._validate_and_update_domain(
-                domain=domain,
+                domain_id=domain_id,
                 domain_centroid=domain_centroid,
                 domain_id_to_centroid_map=domain_id_to_centroid_map,
                 ids_to_labels=ids_to_labels,
@@ -540,45 +538,45 @@ class Labels:
 
     def _validate_and_update_domain(
         self,
-        domain: str,
+        domain_id: int,
         domain_centroid: np.ndarray,
-        domain_id_to_centroid_map: Dict[str, np.ndarray],
+        domain_id_to_centroid_map: Dict[int, np.ndarray],
         ids_to_labels: Union[Dict[int, str], None],
         words_to_omit: Union[List[str], None],
         min_label_lines: int,
         max_label_lines: int,
         min_chars_per_line: int,
         max_chars_per_line: int,
-        filtered_domain_centroids: Dict[str, np.ndarray],
-        filtered_domain_terms: Dict[str, str],
+        filtered_domain_centroids: Dict[int, np.ndarray],
+        filtered_domain_terms: Dict[int, str],
         valid_indices: List[int],
     ) -> bool:
         """Validate and process the domain terms, updating relevant dictionaries if valid.
 
         Args:
-            domain (str): Domain ID to process.
+            domain_id (int): Domain ID to process.
             domain_centroid (np.ndarray): Centroid position of the domain.
-            domain_id_to_centroid_map (Dict[str, np.ndarray]): Mapping of domain IDs to their centroids.
+            domain_id_to_centroid_map (Dict[int, np.ndarray]): Mapping of domain IDs to their centroids.
             ids_to_labels (Dict[int, str], None, optional): A dictionary mapping domain IDs to custom labels. Defaults to None.
             words_to_omit (List[str], None, optional): List of words to omit from the labels. Defaults to None.
             min_label_lines (int): Minimum number of lines required in a label.
             max_label_lines (int): Maximum number of lines allowed in a label.
             min_chars_per_line (int): Minimum number of characters allowed per line.
             max_chars_per_line (int): Maximum number of characters allowed per line.
-            filtered_domain_centroids (Dict[str, np.ndarray]): Dictionary to store valid domain centroids.
+            filtered_domain_centroids (Dict[int, np.ndarray]): Dictionary to store valid domain centroids.
             filtered_domain_terms (Dict[str, str]): Dictionary to store valid domain terms.
             valid_indices (List[int]): List of valid domain indices.
 
         Returns:
             bool: True if the domain is valid and added to the filtered dictionaries, False otherwise.
         """
-        if ids_to_labels and domain in ids_to_labels:
+        if ids_to_labels and domain_id in ids_to_labels:
             # Directly use custom labels without filtering
-            domain_terms = ids_to_labels[domain]
+            domain_terms = ids_to_labels[domain_id]
         else:
             # Process the domain terms automatically
             domain_terms = self._process_terms(
-                domain=domain,
+                domain_id=domain_id,
                 words_to_omit=words_to_omit,
                 max_label_lines=max_label_lines,
                 min_chars_per_line=min_chars_per_line,
@@ -595,24 +593,24 @@ class Labels:
                 return False
 
         # Store the valid terms and centroids
-        filtered_domain_centroids[domain] = domain_centroid
-        filtered_domain_terms[domain] = domain_terms
-        valid_indices.append(list(domain_id_to_centroid_map.keys()).index(domain))
+        filtered_domain_centroids[domain_id] = domain_centroid
+        filtered_domain_terms[domain_id] = domain_terms
+        valid_indices.append(list(domain_id_to_centroid_map.keys()).index(domain_id))
 
         return True
 
     def _process_terms(
         self,
-        domain: str,
+        domain_id: int,
         words_to_omit: Union[List[str], None],
         max_label_lines: int,
         min_chars_per_line: int,
         max_chars_per_line: int,
-    ) -> List[str]:
+    ) -> str:
         """Process terms for a domain, applying word length constraints and combining words where appropriate.
 
         Args:
-            domain (str): The domain being processed.
+            domain_id (int): Domain ID to process.
             words_to_omit (List[str], None): List of words to omit from the labels.
             max_label_lines (int): Maximum number of lines in a label.
             min_chars_per_line (int): Minimum number of characters in a line to display.
@@ -622,7 +620,7 @@ class Labels:
             str: Processed terms separated by TERM_DELIMITER, with words combined if necessary to fit within constraints.
         """
         # Set custom labels from significant terms
-        terms = self.graph.domain_id_to_domain_terms_map[domain].split(" ")
+        terms = self.graph.domain_id_to_domain_terms_map[domain_id].split(" ")
         # Apply words_to_omit and word length constraints
         if words_to_omit:
             terms = [
@@ -632,7 +630,7 @@ class Labels:
             ]
 
         # Use the combine_words function directly to handle word combinations and length constraints
-        compressed_terms = self._combine_words(tuple(terms), max_chars_per_line, max_label_lines)
+        compressed_terms = self._combine_words(list(terms), max_chars_per_line, max_label_lines)
 
         return compressed_terms
 
@@ -647,8 +645,8 @@ class Labels:
         scale_factor: float = 1.0,
         ids_to_colors: Union[Dict[int, Any], None] = None,
         random_seed: int = 888,
-    ) -> np.ndarray:
-        """Get colors for the labels based on node annotations or a specified colormap.
+    ) -> List:
+        """Get colors for the labels based on node annotation or a specified colormap.
 
         Args:
             cmap (str, optional): Name of the colormap to use for generating label colors. Defaults to "gist_rainbow".
@@ -666,7 +664,7 @@ class Labels:
             random_seed (int, optional): Seed for random number generation to ensure reproducibility. Defaults to 888.
 
         Returns:
-            np.ndarray: Array of RGBA colors for label annotations.
+            List: Array of RGBA colors for label annotation.
         """
         return get_annotated_domain_colors(
             graph=self.graph,
@@ -750,21 +748,21 @@ class Labels:
 
     def _calculate_best_label_positions(
         self,
-        filtered_domain_centroids: Dict[str, Any],
-        center: np.ndarray,
+        filtered_domain_centroids: Dict[int, Any],
+        center: Tuple[float, float],
         radius: float,
         offset: float,
-    ) -> Dict[str, Any]:
+    ) -> Dict[int, Any]:
         """Calculate and optimize label positions for clarity.
 
         Args:
-            filtered_domain_centroids (Dict[str, Any]): Centroids of the filtered domains.
-            center (np.ndarray): The center coordinates for label positioning.
+            filtered_domain_centroids (Dict[int, Any]): Centroids of the filtered domains.
+            center (Tuple[float, float]): The center point around which labels are positioned.
             radius (float): The radius for positioning labels around the center.
             offset (float): The offset distance from the radius for positioning labels.
 
         Returns:
-            Dict[str, Any]: Optimized positions for labels.
+            Dict[int, Any]: Optimized positions for labels.
         """
         num_domains = len(filtered_domain_centroids)
         # Calculate equidistant positions around the center for initial label placement
@@ -777,12 +775,12 @@ class Labels:
         return self._optimize_label_positions(label_positions, filtered_domain_centroids)
 
     def _calculate_equidistant_positions_around_center(
-        self, center: np.ndarray, radius: float, label_offset: float, num_domains: int
+        self, center: Tuple[float, float], radius: float, label_offset: float, num_domains: int
     ) -> List[np.ndarray]:
         """Calculate positions around a center at equidistant angles.
 
         Args:
-            center (np.ndarray): The central point around which positions are calculated.
+            center (Tuple[float, float]): The center point around which positions are calculated.
             radius (float): The radius at which positions are calculated.
             label_offset (float): The offset added to the radius for label positioning.
             num_domains (int): The number of positions (or domains) to calculate.
@@ -799,16 +797,16 @@ class Labels:
         ]
 
     def _optimize_label_positions(
-        self, best_label_positions: Dict[str, Any], domain_centroids: Dict[str, Any]
-    ) -> Dict[str, Any]:
+        self, best_label_positions: Dict[int, Any], domain_centroids: Dict[int, Any]
+    ) -> Dict[int, Any]:
         """Optimize label positions around the perimeter to minimize total distance to centroids.
 
         Args:
-            best_label_positions (Dict[str, Any]): Initial positions of labels around the perimeter.
-            domain_centroids (Dict[str, Any]): Centroid positions of the domains.
+            best_label_positions (Dict[int, Any]): Initial positions of labels around the perimeter.
+            domain_centroids (Dict[int, Any]): Centroid positions of the domains.
 
         Returns:
-            Dict[str, Any]: Optimized label positions.
+            Dict[int, Any]: Optimized label positions.
         """
         while True:
             improvement = False  # Start each iteration assuming no improvement
@@ -838,39 +836,39 @@ class Labels:
         return best_label_positions
 
     def _calculate_total_distance(
-        self, label_positions: Dict[str, Any], domain_centroids: Dict[str, Any]
+        self, label_positions: Dict[int, Any], domain_centroids: Dict[int, Any]
     ) -> float:
         """Calculate the total distance from label positions to their domain centroids.
 
         Args:
-            label_positions (Dict[str, Any]): Positions of labels around the perimeter.
-            domain_centroids (Dict[str, Any]): Centroid positions of the domains.
+            label_positions (Dict[int, Any]): Positions of labels around the perimeter.
+            domain_centroids (Dict[int, Any]): Centroid positions of the domains.
 
         Returns:
             float: The total distance from labels to centroids.
         """
-        total_distance = 0
+        total_distance = 0.0
         # Iterate through each domain and calculate the distance to its centroid
         for domain, pos in label_positions.items():
             centroid = domain_centroids[domain]
-            total_distance += np.linalg.norm(centroid - pos)
+            total_distance += float(np.linalg.norm(centroid - pos))
 
         return total_distance
 
     def _swap_and_evaluate(
         self,
-        label_positions: Dict[str, Any],
+        label_positions: Dict[int, Any],
         i: int,
         j: int,
-        domain_centroids: Dict[str, Any],
+        domain_centroids: Dict[int, Any],
     ) -> float:
         """Swap two labels and evaluate the total distance after the swap.
 
         Args:
-            label_positions (Dict[str, Any]): Positions of labels around the perimeter.
+            label_positions (Dict[int, Any]): Positions of labels around the perimeter.
             i (int): Index of the first label to swap.
             j (int): Index of the second label to swap.
-            domain_centroids (Dict[str, Any]): Centroid positions of the domains.
+            domain_centroids (Dict[int, Any]): Centroid positions of the domains.
 
         Returns:
             float: The total distance after swapping the two labels.

risk/network/plotter/network.py

@@ -94,10 +94,10 @@ class Network:
         # Draw the nodes of the graph
         nx.draw_networkx_nodes(
             self.graph.network,
-            pos=node_coordinates,
+            pos=node_coordinates.tolist(),
             node_size=node_size,
             node_shape=node_shape,
-            node_color=node_color_rgba,
+            node_color=node_color_rgba.tolist(),
             edgecolors=node_edgecolor_rgba,
             linewidths=node_edgewidth,
             ax=self.ax,
@@ -105,9 +105,9 @@ class Network:
         # Draw the edges of the graph
         nx.draw_networkx_edges(
             self.graph.network,
-            pos=node_coordinates,
+            pos=node_coordinates.tolist(),
             width=edge_width,
-            edge_color=edge_color_rgba,
+            edge_color=edge_color_rgba.tolist(),
             ax=self.ax,
         )
 
@@ -181,7 +181,7 @@ class Network:
             nodelist=node_ids,
             node_size=node_size,
             node_shape=node_shape,
-            node_color=node_color_rgba,
+            node_color=node_color_rgba.tolist(),
             edgecolors=node_edgecolor_rgba,
             linewidths=node_edgewidth,
             ax=self.ax,
@@ -192,7 +192,7 @@ class Network:
             subgraph,
             pos=node_coordinates,
             width=edge_width,
-            edge_color=edge_color_rgba,
+            edge_color=edge_color_rgba.tolist(),
             ax=self.ax,
         )
 

risk/network/plotter/plotter.py

@@ -29,7 +29,7 @@ class Plotter(Canvas, Network, Contour, Labels):
     def __init__(
         self,
         graph: Graph,
-        figsize: Tuple = (10, 10),
+        figsize: Union[List, Tuple, np.ndarray] = (10, 10),
         background_color: Union[str, List, Tuple, np.ndarray] = "white",
         background_alpha: Union[float, None] = 1.0,
         pad: float = 0.3,
@@ -38,7 +38,7 @@ class Plotter(Canvas, Network, Contour, Labels):
 
         Args:
             graph (Graph): The network data and attributes to be visualized.
-            figsize (Tuple, optional): Size of the figure in inches (width, height). Defaults to (10, 10).
+            figsize (List, Tuple, np.ndarray, 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.
@@ -58,7 +58,7 @@ class Plotter(Canvas, Network, Contour, Labels):
     def _initialize_plot(
         self,
         graph: Graph,
-        figsize: Tuple,
+        figsize: Union[List, Tuple, np.ndarray],
         background_color: Union[str, List, Tuple, np.ndarray],
         background_alpha: Union[float, None],
         pad: float,
@@ -67,7 +67,7 @@ class Plotter(Canvas, Network, Contour, Labels):
 
         Args:
             graph (Graph): The network data and attributes to be visualized.
-            figsize (Tuple): Size of the figure in inches (width, height).
+            figsize (List, Tuple, np.ndarray, optional): Size of the figure in inches (width, height). Defaults to (10, 10).
             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`.
@@ -93,8 +93,8 @@ class Plotter(Canvas, Network, Contour, Labels):
         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_xlim((float(center[0] - radius - pad), float(center[0] + radius + pad)))
+        ax.set_ylim((float(center[1] - radius - pad), float(center[1] + radius + pad)))
         ax.set_aspect("equal")  # Ensure the aspect ratio is equal
 
         # Set the background color of the plot

risk/network/plotter/utils/colors.py

@@ -23,8 +23,8 @@ def get_annotated_domain_colors(
     scale_factor: float = 1.0,
     ids_to_colors: Union[Dict[int, Any], None] = None,
     random_seed: int = 888,
-) -> np.ndarray:
-    """Get colors for the domains based on node annotations, or use a specified color.
+) -> List[Tuple]:
+    """Get colors for the domains based on node annotation, or use a specified color.
 
     Args:
         graph (Graph): The network data and attributes to be visualized.
@@ -41,7 +41,7 @@ def get_annotated_domain_colors(
         random_seed (int, optional): Seed for random number generation to ensure reproducibility. Defaults to 888.
 
     Returns:
-        np.ndarray: Array of RGBA colors for each domain.
+        List[Tuple]: List of RGBA colors for each domain, based on significance or the specified color.
     """
     # Generate domain colors based on the significance data
     node_colors = get_domain_colors(
@@ -61,10 +61,12 @@ def get_annotated_domain_colors(
         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 node_ids])
-            color = domain_colors[np.argmax(domain_colors[:, :3].sum(axis=1))]  # Sum the RGB values
+            color = tuple(
+                domain_colors[np.argmax(domain_colors[:, :3].sum(axis=1))]
+            )  # Sum the RGB values
         else:
             # Single-node domains default to white (RGBA)
-            color = np.array([1.0, 1.0, 1.0, 1.0])
+            color = tuple([1.0, 1.0, 1.0, 1.0])
 
         annotated_colors.append(color)
 
@@ -202,7 +204,7 @@ def _get_composite_node_colors(
             significances = node_info["significances"]  # List of significance values
             # Filter domains and significances to keep only those with corresponding colors in domain_ids_to_colors
             filtered_domains_significances = [
-                (domain_id, significance)
+                (domain_id, float(significance))
                 for domain_id, significance in zip(domains, significances)
                 if domain_id in domain_ids_to_colors
             ]
@@ -216,7 +218,9 @@ def _get_composite_node_colors(
             colors = [domain_ids_to_colors[domain_id] for domain_id in filtered_domains]
             # Blend the colors using the given gamma (default is 2.2 if None)
             gamma = blend_gamma if blend_gamma is not None else 2.2
-            composite_color = _blend_colors_perceptually(colors, filtered_significances, gamma)
+            composite_color = _blend_colors_perceptually(
+                colors, list(filtered_significances), gamma
+            )
             # Assign the composite color to the node
             composite_colors[node] = composite_color
 
@@ -246,7 +250,7 @@ def _get_colors(
     if color:
         # If a single color is specified, apply it to all domains
         rgba = to_rgba(color, num_repeats=num_domains)
-        return rgba
+        return list(rgba)
 
     # Load colormap and generate a large, maximally separated set of colors
     colormap = matplotlib.colormaps.get_cmap(cmap)

risk/network/plotter/utils/layout.py

@@ -11,7 +11,7 @@ import numpy as np
 
 def calculate_bounding_box(
     node_coordinates: np.ndarray, radius_margin: float = 1.05
-) -> Tuple[np.ndarray, float]:
+) -> Tuple[Tuple, float]:
     """Calculate the bounding box of the network based on node coordinates.
 
     Args:
@@ -19,13 +19,13 @@ def calculate_bounding_box(
         radius_margin (float, optional): Margin factor to apply to the bounding box radius. Defaults to 1.05.
 
     Returns:
-        tuple: Center of the bounding box and the radius (adjusted by the radius margin).
+        Tuple[Tuple, float]: Center (x, y) and radius of the bounding box.
     """
     # Find minimum and maximum x, y coordinates
     x_min, y_min = np.min(node_coordinates, axis=0)
     x_max, y_max = np.max(node_coordinates, axis=0)
     # Calculate the center of the bounding box
-    center = np.array([(x_min + x_max) / 2, (y_min + y_max) / 2])
+    center = ((x_min + x_max) / 2, (y_min + y_max) / 2)
     # Calculate the radius of the bounding box, adjusted by the margin
     radius = max(x_max - x_min, y_max - y_min) / 2 * radius_margin
     return center, radius

risk/risk.py

@@ -3,7 +3,7 @@ risk/risk
 ~~~~~~~~~
 """
 
-from risk.annotations.io import AnnotationsIO
+from risk.annotation.io import AnnotationIO
 from risk.log import params, set_global_verbosity
 from risk.neighborhoods.api import NeighborhoodsAPI
 from risk.network.graph.api import GraphAPI
@@ -11,7 +11,7 @@ from risk.network.io import NetworkIO
 from risk.network.plotter.api import PlotterAPI
 
 
-class RISK(NetworkIO, AnnotationsIO, NeighborhoodsAPI, GraphAPI, PlotterAPI):
+class RISK(NetworkIO, AnnotationIO, NeighborhoodsAPI, GraphAPI, PlotterAPI):
     """RISK: A class for network analysis and visualization.
 
     The RISK class integrates functionalities for loading networks, processing annotations,

{risk_network-0.0.12b1.dist-info → risk_network-0.0.12b3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: risk-network
-Version: 0.0.12b1
+Version: 0.0.12b3
 Summary: A Python package for biological network analysis
 Author-email: Ira Horecka <ira89@icloud.com>
 License: GPL-3.0-or-later

risk_network-0.0.12b3.dist-info/RECORD

@@ -0,0 +1,40 @@
+risk/__init__.py,sha256=VvDXIVi8eQIQJ1y7eWSxIK70Xj19NdNxJCNkaTn9GsM,127
+risk/risk.py,sha256=Wjuxob5bI70Tpz9t71i05g94AQ3qXEMjfEcm5IV9HSY,1118
+risk/annotation/__init__.py,sha256=1EbGo41ClQb5ESTtitjOhrZhaLzzwr5aT-RYDX8w-h4,185
+risk/annotation/annotation.py,sha256=OE859FpVnp69hDi1cN_CQqeiG0SrJ2ZCuIdQKzY-gt0,14675
+risk/annotation/io.py,sha256=iffCXePQuMluytYQDg5tbu34g9ZsCUq1H4j-z-W25lE,10695
+risk/annotation/nltk_setup.py,sha256=14B6L56_dwIgAOC9Rl4dNd4-b-aEngUCoJP9L9kEilU,3572
+risk/log/__init__.py,sha256=en-hKzuFtQWos4oZd8PxJ9u9Pe5bdihiqH9-qk_5ppw,217
+risk/log/console.py,sha256=PgjyEvyhYLUSHXPUKEqOmxsDsfrjPICIgqo_cAHq0N8,4575
+risk/log/parameters.py,sha256=FnP-kdg0Kip0SyxFEn7su7BG51FbMtTfm3Rk96cnCoc,5801
+risk/neighborhoods/__init__.py,sha256=CNS0VNbh_IdxldXjDkPqeTrxgY4hqi_Tc_MTADW_tzQ,182
+risk/neighborhoods/api.py,sha256=TXbjbHfQDi2eZeD9086BBsUjhDiJq2BNEYALiGs_rPc,23299
+risk/neighborhoods/community.py,sha256=0YdTh6wgMLiGMdtlaD7Vu_uxOVoZ9vDBjxbkglkrTV8,17808
+risk/neighborhoods/domains.py,sha256=9cWcGYGALcYruvAjWKztnEZlnYyT6DSoAPP6VsgA2wQ,14601
+risk/neighborhoods/neighborhoods.py,sha256=g08IFsMjsadkkfl9FI9oIrzlQ5KgWK_BMRN0VmCzDbs,21694
+risk/neighborhoods/stats/__init__.py,sha256=1evLEAa7trCWj2DapCV4vW_f0zsyKHqTsn4--E_fDPg,306
+risk/neighborhoods/stats/tests.py,sha256=Z14H8G2qHzM5AOhKqp4YfCOL_wp3QwzUzfeGQJOqTTU,12060
+risk/neighborhoods/stats/permutation/__init__.py,sha256=V-uLSoi4SIPKjSRl7rhcDR4HJ4tquAn3QxNTXH9KzK8,169
+risk/neighborhoods/stats/permutation/permutation.py,sha256=k9-Yw-1wWBqeD9cGcTh_d2ypqN-HzoJrcCEAR5-BK0o,10673
+risk/neighborhoods/stats/permutation/test_functions.py,sha256=Wuop4WDY3foGeKp-hMGc2Gdqf85s-x9BDXGB8ifp0oE,3147
+risk/network/__init__.py,sha256=C9GisdyJM7fizwUIipy1vC4lbry9ceqLn1iBcW0-mZg,34
+risk/network/io.py,sha256=1JViOU1YY0DgRP-dK-n-Tkj2ZrpVJJm4vq-5mzvK7kM,27856
+risk/network/graph/__init__.py,sha256=iG6IlE8xtAyF6_NuCBUpsJrjrjd1vsXO1Ajsr0K8EA0,46
+risk/network/graph/api.py,sha256=gXheVl1xw7vFDHOOQdRxCFwVy4ajEJ1dk4GQxm13sCI,8528
+risk/network/graph/graph.py,sha256=jPNJea9JiLKedGFvSKmZ5Kf2R9go0HJkZ4wYNJwZRJI,12410
+risk/network/graph/stats.py,sha256=xITodchaF8Pgngynil_GM9IeMBtxuraPX-Gjp6WBEMY,7338
+risk/network/graph/summary.py,sha256=UZvZk5w2BZ5zs8IDfr-YYYBr2eM1wmXh0FKp_p9UdB4,10260
+risk/network/plotter/__init__.py,sha256=9kdeONe8NaJvJ5FO7eOdZiobqL4CeR7q2MghG4z6Kt8,50
+risk/network/plotter/api.py,sha256=GFP0n_0-tSdCZQd6cuaH3w55953sXCR02nwyJhAEqK4,1789
+risk/network/plotter/canvas.py,sha256=i8i-ARLCNsHkAW3W_E63PpbEjmQLJplpqK6mSivgz4k,13610
+risk/network/plotter/contour.py,sha256=TJA4C9G07iFBBSuSCYGZJ6NZfXGWH8zVw0LC2eqU3JA,15540
+risk/network/plotter/labels.py,sha256=89Ege5NkfFMZJXw_mF-rhtIPa4-S8UKtYSkj8ty_VeQ,46805
+risk/network/plotter/network.py,sha256=c9rPQ5mjil0sxVQnprRaKMAUqT6PZmKiATWz0m-TvQU,14185
+risk/network/plotter/plotter.py,sha256=WZcOrBW3vBQ_aLwv8c8pXJO8ZlyswHHHfEsiLxzEYaI,6121
+risk/network/plotter/utils/colors.py,sha256=xZt4877ORTQqySiMh-tUGe0sXvhLbXO04iGNeBDkbbw,19144
+risk/network/plotter/utils/layout.py,sha256=Lty16T-Q-oWwo9fXqm-nnS_dMS3BMhuFt4SFqxFC3Ng,3610
+risk_network-0.0.12b3.dist-info/licenses/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+risk_network-0.0.12b3.dist-info/METADATA,sha256=asgx3FEU8sjkJzPlyHJ676q47C1j_O9doIVq_oFwVn4,6667
+risk_network-0.0.12b3.dist-info/WHEEL,sha256=ooBFpIzZCPdw3uqIQsOo4qqbA4ZRPxHnOH7peeONza0,91
+risk_network-0.0.12b3.dist-info/top_level.txt,sha256=NX7C2PFKTvC1JhVKv14DFlFAIFnKc6Lpsu1ZfxvQwVw,5
+risk_network-0.0.12b3.dist-info/RECORD,,