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

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

@@ -3,6 +3,7 @@ risk/network/plot/labels
 ~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
+import copy
 from typing import Any, Dict, List, Tuple, Union
 
 import matplotlib.pyplot as plt
@@ -10,9 +11,9 @@ import numpy as np
 import pandas as pd
 
 from risk.log import params
-from risk.network.graph import NetworkGraph
-from risk.network.plot.utils.color import get_annotated_domain_colors, to_rgba
-from risk.network.plot.utils.layout import calculate_bounding_box
+from risk.network.graph.network import NetworkGraph
+from risk.network.plotter.utils.colors import get_annotated_domain_colors, to_rgba
+from risk.network.plotter.utils.layout import calculate_bounding_box
 
 TERM_DELIMITER = "::::"  # String used to separate multiple domain terms when constructing composite domain labels
 
@@ -53,7 +54,7 @@ class Labels:
         words_to_omit: Union[List, None] = None,
         overlay_ids: bool = False,
         ids_to_keep: Union[List, Tuple, np.ndarray, None] = None,
-        ids_to_replace: Union[Dict, None] = None,
+        ids_to_labels: Union[Dict[int, str], None] = None,
     ) -> None:
         """Annotate the network graph with labels for different domains, positioned around the network for clarity.
 
@@ -61,18 +62,18 @@ class Labels:
             scale (float, optional): Scale factor for positioning labels around the perimeter. Defaults to 1.05.
             offset (float, optional): Offset distance for labels from the perimeter. Defaults to 0.10.
             font (str, optional): Font name for the labels. Defaults to "Arial".
-            fontcase (Union[str, Dict[str, str], None]): Defines how to transform the case of words.
+            fontcase (str, Dict[str, str], or None, optional): Defines how to transform the case of words.
                 - If a string (e.g., 'upper', 'lower', 'title'), applies the transformation to all words.
                 - If a dictionary, maps specific cases ('lower', 'upper', 'title') to transformations (e.g., 'lower'='upper').
                 - If None, no transformation is applied.
             fontsize (int, optional): Font size for the labels. Defaults to 10.
-            fontcolor (str, list, tuple, or np.ndarray, optional): Color of the label text. Can be a string or RGBA array.
+            fontcolor (str, List, Tuple, or np.ndarray, optional): Color of the label text. Can be a string or RGBA array.
                 Defaults to "black".
             fontalpha (float, None, optional): Transparency level for the font color. If provided, it overrides any existing alpha
                 values found in fontcolor. Defaults to 1.0.
             arrow_linewidth (float, optional): Line width of the arrows pointing to centroids. Defaults to 1.
             arrow_style (str, optional): Style of the arrows pointing to centroids. Defaults to "->".
-            arrow_color (str, list, tuple, or np.ndarray, optional): Color of the arrows. Defaults to "black".
+            arrow_color (str, List, Tuple, or np.ndarray, optional): Color of the arrows. Defaults to "black".
             arrow_alpha (float, None, optional): Transparency level for the arrow color. If provided, it overrides any existing alpha
                 values found in arrow_color. Defaults to 1.0.
             arrow_base_shrink (float, optional): Distance between the text and the base of the arrow. Defaults to 0.0.
@@ -82,11 +83,11 @@ class Labels:
             max_label_lines (int, optional): Maximum number of lines in a label. Defaults to None (no limit).
             min_chars_per_line (int, optional): Minimum number of characters in a line to display. Defaults to 1.
             max_chars_per_line (int, optional): Maximum number of characters in a line to display. Defaults to None (no limit).
-            words_to_omit (list, optional): List of words to omit from the labels. Defaults to None.
+            words_to_omit (List, optional): List of words to omit from the labels. Defaults to None.
             overlay_ids (bool, optional): Whether to overlay domain IDs in the center of the centroids. Defaults to False.
-            ids_to_keep (list, tuple, np.ndarray, or None, optional): IDs of domains that must be labeled. To discover domain IDs,
+            ids_to_keep (List, Tuple, np.ndarray, or None, optional): IDs of domains that must be labeled. To discover domain IDs,
                 you can set `overlay_ids=True`. Defaults to None.
-            ids_to_replace (dict, optional): A dictionary mapping domain IDs to custom labels (strings). The labels should be
+            ids_to_labels (Dict[int, str], optional): A dictionary mapping domain IDs to custom labels (strings). The labels should be
                 space-separated words. If provided, the custom labels will replace the default domain terms. To discover domain IDs, you
                 can set `overlay_ids=True`. Defaults to None.
 
@@ -118,7 +119,7 @@ class Labels:
             label_words_to_omit=words_to_omit,
             label_overlay_ids=overlay_ids,
             label_ids_to_keep=ids_to_keep,
-            label_ids_to_replace=ids_to_replace,
+            label_ids_to_labels=ids_to_labels,
         )
 
         # Convert ids_to_keep to a tuple if it is not None
@@ -151,7 +152,7 @@ class Labels:
             self._process_ids_to_keep(
                 domain_id_to_centroid_map=domain_id_to_centroid_map,
                 ids_to_keep=ids_to_keep,
-                ids_to_replace=ids_to_replace,
+                ids_to_labels=ids_to_labels,
                 words_to_omit=words_to_omit,
                 max_labels=max_labels,
                 min_label_lines=min_label_lines,
@@ -172,7 +173,7 @@ class Labels:
             self._process_remaining_domains(
                 domain_id_to_centroid_map=domain_id_to_centroid_map,
                 ids_to_keep=ids_to_keep,
-                ids_to_replace=ids_to_replace,
+                ids_to_labels=ids_to_labels,
                 words_to_omit=words_to_omit,
                 remaining_labels=remaining_labels,
                 min_chars_per_line=min_chars_per_line,
@@ -191,10 +192,10 @@ class Labels:
             filtered_domain_centroids, center, radius, offset
         )
         # Convert all domain colors to RGBA using the to_rgba helper function
-        fontcolor = to_rgba(
+        fontcolor_rgba = to_rgba(
             color=fontcolor, alpha=fontalpha, num_repeats=len(self.graph.domain_id_to_node_ids_map)
         )
-        arrow_color = to_rgba(
+        arrow_color_rgba = to_rgba(
             color=arrow_color,
             alpha=arrow_alpha,
             num_repeats=len(self.graph.domain_id_to_node_ids_map),
@@ -216,14 +217,15 @@ class Labels:
                 va="center",
                 fontsize=fontsize,
                 fontname=font,
-                color=fontcolor[idx],
-                arrowprops=dict(
-                    arrowstyle=arrow_style,
-                    color=arrow_color[idx],
-                    linewidth=arrow_linewidth,
-                    shrinkA=arrow_base_shrink,
-                    shrinkB=arrow_tip_shrink,
-                ),
+                color=fontcolor_rgba[idx],
+                arrowprops={
+                    "arrowstyle": arrow_style,
+                    "linewidth": arrow_linewidth,
+                    "color": arrow_color_rgba[idx],
+                    "alpha": arrow_alpha,
+                    "shrinkA": arrow_base_shrink,
+                    "shrinkB": arrow_tip_shrink,
+                },
             )
 
         # Overlay domain ID at the centroid regardless of max_labels if requested
@@ -238,8 +240,7 @@ class Labels:
                     va="center",
                     fontsize=fontsize,
                     fontname=font,
-                    color=fontcolor[idx],
-                    alpha=fontalpha,
+                    color=fontcolor_rgba[idx],
                 )
 
     def plot_sublabel(
@@ -263,19 +264,19 @@ class Labels:
         """Annotate the network graph with a label for the given nodes, with one arrow pointing to each centroid of sublists of nodes.
 
         Args:
-            nodes (list, tuple, or np.ndarray): List of node labels or list of lists of node labels.
+            nodes (List, Tuple, or np.ndarray): List of node labels or list of lists of node labels.
             label (str): The label to be annotated on the network.
             radial_position (float, optional): Radial angle for positioning the label, in degrees (0-360). Defaults to 0.0.
             scale (float, optional): Scale factor for positioning the label around the perimeter. Defaults to 1.05.
             offset (float, optional): Offset distance for the label from the perimeter. Defaults to 0.10.
             font (str, optional): Font name for the label. Defaults to "Arial".
             fontsize (int, optional): Font size for the label. Defaults to 10.
-            fontcolor (str, list, tuple, or np.ndarray, optional): Color of the label text. Defaults to "black".
+            fontcolor (str, List, Tuple, or np.ndarray, optional): Color of the label text. Defaults to "black".
             fontalpha (float, None, optional): Transparency level for the font color. If provided, it overrides any existing alpha values found
                 in fontalpha. Defaults to 1.0.
             arrow_linewidth (float, optional): Line width of the arrow pointing to the centroid. Defaults to 1.
             arrow_style (str, optional): Style of the arrows pointing to the centroid. Defaults to "->".
-            arrow_color (str, list, tuple, or np.ndarray, optional): Color of the arrow. Defaults to "black".
+            arrow_color (str, List, Tuple, or np.ndarray, optional): Color of the arrow. Defaults to "black".
             arrow_alpha (float, None, optional): Transparency level for the arrow color. If provided, it overrides any existing alpha values
                 found in arrow_alpha. Defaults to 1.0.
             arrow_base_shrink (float, optional): Distance between the text and the base of the arrow. Defaults to 0.0.
@@ -334,20 +335,21 @@ class Labels:
                 fontsize=fontsize,
                 fontname=font,
                 color=fontcolor_rgba[idx],
-                arrowprops=dict(
-                    arrowstyle=arrow_style,
-                    color=arrow_color_rgba[idx],
-                    linewidth=arrow_linewidth,
-                    shrinkA=arrow_base_shrink,
-                    shrinkB=arrow_tip_shrink,
-                ),
+                arrowprops={
+                    "arrowstyle": arrow_style,
+                    "linewidth": arrow_linewidth,
+                    "color": arrow_color_rgba[idx],
+                    "alpha": arrow_alpha,
+                    "shrinkA": arrow_base_shrink,
+                    "shrinkB": arrow_tip_shrink,
+                },
             )
 
     def _calculate_domain_centroid(self, nodes: List) -> tuple:
         """Calculate the most centrally located node in .
 
         Args:
-            nodes (list): List of node labels to include in the subnetwork.
+            nodes (List): List of node labels to include in the subnetwork.
 
         Returns:
             tuple: A tuple containing the domain's central node coordinates.
@@ -368,7 +370,7 @@ class Labels:
         self,
         domain_id_to_centroid_map: Dict[str, np.ndarray],
         ids_to_keep: Union[List[str], Tuple[str], np.ndarray],
-        ids_to_replace: Union[Dict[str, str], None],
+        ids_to_labels: Union[Dict[int, str], None],
         words_to_omit: Union[List[str], None],
         max_labels: Union[int, None],
         min_label_lines: int,
@@ -382,18 +384,18 @@ class Labels:
         """Process the ids_to_keep, apply filtering, and store valid domain centroids and terms.
 
         Args:
-            domain_id_to_centroid_map (dict): 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_replace (dict, 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.
+            domain_id_to_centroid_map (Dict[str, 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.
             max_labels (int, optional): Maximum number of labels allowed.
             min_label_lines (int): Minimum number of lines in a label.
             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): Dictionary to store filtered domain centroids (output).
-            filtered_domain_terms (dict): Dictionary to store filtered domain terms (output).
-            valid_indices (list): List to store valid indices (output).
+            filtered_domain_centroids (Dict[str, 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).
 
         Note:
             The `filtered_domain_centroids`, `filtered_domain_terms`, and `valid_indices` are modified in-place.
@@ -419,7 +421,7 @@ class Labels:
                     domain=domain,
                     domain_centroid=domain_centroid,
                     domain_id_to_centroid_map=domain_id_to_centroid_map,
-                    ids_to_replace=ids_to_replace,
+                    ids_to_labels=ids_to_labels,
                     words_to_omit=words_to_omit,
                     min_label_lines=min_label_lines,
                     max_label_lines=max_label_lines,
@@ -434,7 +436,7 @@ class Labels:
         self,
         domain_id_to_centroid_map: Dict[str, np.ndarray],
         ids_to_keep: Union[List[str], Tuple[str], np.ndarray],
-        ids_to_replace: Union[Dict[str, str], None],
+        ids_to_labels: Union[Dict[int, str], None],
         words_to_omit: Union[List[str], None],
         remaining_labels: int,
         min_label_lines: int,
@@ -448,18 +450,18 @@ class Labels:
         """Process remaining domains to fill in additional labels, respecting the remaining_labels limit.
 
         Args:
-            domain_id_to_centroid_map (dict): 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_replace (dict, 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.
+            domain_id_to_centroid_map (Dict[str, 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.
             remaining_labels (int): The remaining number of labels that can be generated.
             min_label_lines (int): Minimum number of lines in a label.
             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): Dictionary to store filtered domain centroids (output).
-            filtered_domain_terms (dict): Dictionary to store filtered domain terms (output).
-            valid_indices (list): List to store valid indices (output).
+            filtered_domain_centroids (Dict[str, 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).
 
         Note:
             The `filtered_domain_centroids`, `filtered_domain_terms`, and `valid_indices` are modified in-place.
@@ -515,7 +517,7 @@ class Labels:
                 domain=domain,
                 domain_centroid=domain_centroid,
                 domain_id_to_centroid_map=domain_id_to_centroid_map,
-                ids_to_replace=ids_to_replace,
+                ids_to_labels=ids_to_labels,
                 words_to_omit=words_to_omit,
                 min_label_lines=min_label_lines,
                 max_label_lines=max_label_lines,
@@ -536,7 +538,7 @@ class Labels:
         domain: str,
         domain_centroid: np.ndarray,
         domain_id_to_centroid_map: Dict[str, np.ndarray],
-        ids_to_replace: Union[Dict[str, str], None],
+        ids_to_labels: Union[Dict[int, str], None],
         words_to_omit: Union[List[str], None],
         min_label_lines: int,
         max_label_lines: int,
@@ -551,9 +553,9 @@ class Labels:
         Args:
             domain (str): Domain ID to process.
             domain_centroid (np.ndarray): Centroid position of the domain.
-            domain_id_to_centroid_map (dict): Mapping of domain IDs to their centroids.
-            ids_to_replace (Union[Dict[str, str], None]): A dictionary mapping domain IDs to custom labels.
-            words_to_omit (Union[List[str], None]): List of words to omit from the labels.
+            domain_id_to_centroid_map (Dict[str, 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.
@@ -564,39 +566,39 @@ class Labels:
 
         Returns:
             bool: True if the domain is valid and added to the filtered dictionaries, False otherwise.
-
-        Note:
-            The `filtered_domain_centroids`, `filtered_domain_terms`, and `valid_indices` are modified in-place.
         """
-        # Process the domain terms
-        domain_terms = self._process_terms(
-            domain=domain,
-            ids_to_replace=ids_to_replace,
-            words_to_omit=words_to_omit,
-            max_label_lines=max_label_lines,
-            min_chars_per_line=min_chars_per_line,
-            max_chars_per_line=max_chars_per_line,
-        )
-        # If domain_terms is empty, skip further processing
-        if not domain_terms:
-            return False
-
-        # Split the terms by TERM_DELIMITER and count the number of lines
-        num_domain_lines = len(domain_terms.split(TERM_DELIMITER))
-        # Check if the number of lines is greater than or equal to the minimum
-        if num_domain_lines >= min_label_lines:
-            filtered_domain_centroids[domain] = domain_centroid
-            filtered_domain_terms[domain] = domain_terms
-            # Add the index of the domain to the valid indices list
-            valid_indices.append(list(domain_id_to_centroid_map.keys()).index(domain))
-            return True
-
-        return False
+        if ids_to_labels and domain in ids_to_labels:
+            # Directly use custom labels without filtering
+            domain_terms = ids_to_labels[domain]
+        else:
+            # Process the domain terms automatically
+            domain_terms = self._process_terms(
+                domain=domain,
+                words_to_omit=words_to_omit,
+                max_label_lines=max_label_lines,
+                min_chars_per_line=min_chars_per_line,
+                max_chars_per_line=max_chars_per_line,
+            )
+            # If no valid terms are generated, skip further processing
+            if not domain_terms:
+                return False
+
+            # Split the terms by TERM_DELIMITER and count the number of lines
+            num_domain_lines = len(domain_terms.split(TERM_DELIMITER))
+            # Check if the number of lines meets the minimum requirement
+            if num_domain_lines < min_label_lines:
+                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))
+
+        return True
 
     def _process_terms(
         self,
         domain: str,
-        ids_to_replace: Union[Dict[str, str], None],
         words_to_omit: Union[List[str], None],
         max_label_lines: int,
         min_chars_per_line: int,
@@ -606,8 +608,7 @@ class Labels:
 
         Args:
             domain (str): The domain being processed.
-            ids_to_replace (dict, optional): Dictionary mapping domain IDs to custom labels.
-            words_to_omit (list, optional): List of words to omit from the labels.
+            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.
             max_chars_per_line (int): Maximum number of characters in a line to display.
@@ -615,12 +616,8 @@ class Labels:
         Returns:
             str: Processed terms separated by TERM_DELIMITER, with words combined if necessary to fit within constraints.
         """
-        # Handle ids_to_replace logic
-        if ids_to_replace and domain in ids_to_replace:
-            terms = ids_to_replace[domain].split(" ")
-        else:
-            terms = self.graph.domain_id_to_domain_terms_map[domain].split(" ")
-
+        # Set custom labels from significant terms
+        terms = self.graph.domain_id_to_domain_terms_map[domain].split(" ")
         # Apply words_to_omit and word length constraints
         if words_to_omit:
             terms = [
@@ -637,24 +634,30 @@ class Labels:
     def get_annotated_label_colors(
         self,
         cmap: str = "gist_rainbow",
-        color: Union[str, list, tuple, np.ndarray, None] = None,
+        color: Union[str, List, Tuple, np.ndarray, None] = None,
+        blend_colors: bool = False,
+        blend_gamma: float = 2.2,
         min_scale: float = 0.8,
         max_scale: float = 1.0,
         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.
 
         Args:
             cmap (str, optional): Name of the colormap to use for generating label colors. Defaults to "gist_rainbow".
-            color (str, list, tuple, np.ndarray, or None, optional): Color to use for the labels. Can be a single color or an array
+            color (str, List, Tuple, np.ndarray, or None, optional): Color to use for the labels. Can be a single color or an array
                 of colors. If None, the colormap will be used. Defaults to None.
+            blend_colors (bool, optional): Whether to blend colors for nodes with multiple domains. Defaults to False.
+            blend_gamma (float, optional): Gamma correction factor for perceptual color blending. Defaults to 2.2.
             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 color scaling based on enrichment scores.
+            scale_factor (float, optional): Exponent for adjusting color scaling based on significance scores.
                 A higher value increases contrast by dimming lower scores more. Defaults to 1.0.
+            ids_to_colors (Dict[int, Any], None, optional): Mapping of domain IDs to specific colors. Defaults to None.
             random_seed (int, optional): Seed for random number generation to ensure reproducibility. Defaults to 888.
 
         Returns:
@@ -664,9 +667,12 @@ class Labels:
             graph=self.graph,
             cmap=cmap,
             color=color,
+            blend_colors=blend_colors,
+            blend_gamma=blend_gamma,
             min_scale=min_scale,
             max_scale=max_scale,
             scale_factor=scale_factor,
+            ids_to_colors=ids_to_colors,
             random_seed=random_seed,
         )
 
@@ -716,12 +722,19 @@ def _combine_words(words: List[str], max_chars_per_line: int, max_label_lines: i
     # Main logic: start with max_label_lines number of words
     combined_lines = try_combinations(words[:max_label_lines])
     remaining_words = words[max_label_lines:]  # Remaining words after the initial batch
+    # Track words that have already been added
+    existing_words = set(" ".join(combined_lines).split())
 
     # Continue pulling more words until we fill the lines
     while remaining_words and len(combined_lines) < max_label_lines:
         available_slots = max_label_lines - len(combined_lines)
-        words_to_add = remaining_words[:available_slots]
+        words_to_add = [
+            word for word in remaining_words[:available_slots] if word not in existing_words
+        ]
         remaining_words = remaining_words[available_slots:]
+        # Update the existing words set
+        existing_words.update(words_to_add)
+        # Add to combined_lines only unique words
         combined_lines += try_combinations(words_to_add)
 
     # Join the final combined lines with TERM_DELIMITER, a special separator for line breaks
@@ -734,13 +747,13 @@ def _calculate_best_label_positions(
     """Calculate and optimize label positions for clarity.
 
     Args:
-        filtered_domain_centroids (dict): Centroids of the filtered domains.
+        filtered_domain_centroids (Dict[str, Any]): Centroids of the filtered domains.
         center (np.ndarray): The center coordinates for label positioning.
         radius (float): The radius for positioning labels around the center.
         offset (float): The offset distance from the radius for positioning labels.
 
     Returns:
-        dict: Optimized positions for labels.
+        Dict[str, Any]: Optimized positions for labels.
     """
     num_domains = len(filtered_domain_centroids)
     # Calculate equidistant positions around the center for initial label placement
@@ -748,10 +761,7 @@ def _calculate_best_label_positions(
         center, radius, offset, num_domains
     )
     # Create a mapping of domains to their initial label positions
-    label_positions = {
-        domain: position
-        for domain, position in zip(filtered_domain_centroids.keys(), equidistant_positions)
-    }
+    label_positions = dict(zip(filtered_domain_centroids.keys(), equidistant_positions))
     # Optimize the label positions to minimize distance to domain centroids
     return _optimize_label_positions(label_positions, filtered_domain_centroids)
 
@@ -768,7 +778,7 @@ def _calculate_equidistant_positions_around_center(
         num_domains (int): The number of positions (or domains) to calculate.
 
     Returns:
-        list[np.ndarray]: List of positions (as 2D numpy arrays) around the center.
+        List[np.ndarray]: List of positions (as 2D numpy arrays) around the center.
     """
     # Calculate equidistant angles in radians around the center
     angles = np.linspace(0, 2 * np.pi, num_domains, endpoint=False)
@@ -785,11 +795,11 @@ def _optimize_label_positions(
     """Optimize label positions around the perimeter to minimize total distance to centroids.
 
     Args:
-        best_label_positions (dict): Initial positions of labels around the perimeter.
-        domain_centroids (dict): Centroid positions of the domains.
+        best_label_positions (Dict[str, Any]): Initial positions of labels around the perimeter.
+        domain_centroids (Dict[str, Any]): Centroid positions of the domains.
 
     Returns:
-        dict: Optimized label positions.
+        Dict[str, Any]: Optimized label positions.
     """
     while True:
         improvement = False  # Start each iteration assuming no improvement
@@ -821,8 +831,8 @@ def _calculate_total_distance(
     """Calculate the total distance from label positions to their domain centroids.
 
     Args:
-        label_positions (dict): Positions of labels around the perimeter.
-        domain_centroids (dict): Centroid positions of the domains.
+        label_positions (Dict[str, Any]): Positions of labels around the perimeter.
+        domain_centroids (Dict[str, Any]): Centroid positions of the domains.
 
     Returns:
         float: The total distance from labels to centroids.
@@ -845,17 +855,17 @@ def _swap_and_evaluate(
     """Swap two labels and evaluate the total distance after the swap.
 
     Args:
-        label_positions (dict): Positions of labels around the perimeter.
+        label_positions (Dict[str, 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): Centroid positions of the domains.
+        domain_centroids (Dict[str, Any]): Centroid positions of the domains.
 
     Returns:
         float: The total distance after swapping the two labels.
     """
     # Get the list of labels from the dictionary keys
     labels = list(label_positions.keys())
-    swapped_positions = label_positions.copy()
+    swapped_positions = copy.deepcopy(label_positions)
     # Swap the positions of the two specified labels
     swapped_positions[labels[i]], swapped_positions[labels[j]] = (
         swapped_positions[labels[j]],