risk-network 0.0.4b2__py3-none-any.whl → 0.0.5__py3-none-any.whl

risk/__init__.py

@@ -2,12 +2,9 @@
 risk
 ~~~~
 
-risk
-~~~~
-
-RISK: RISK Infers Spatial Kinship
+RISK: RISK Infers Spatial Kinships
 """
 
 from risk.risk import RISK
 
-__version__ = "0.0.4-beta.2"
+__version__ = "0.0.5"

risk/annotations/annotations.py

@@ -197,7 +197,7 @@ def _simplify_word_list(words: List[str], threshold: float = 0.80) -> List[str]:
     word_counts = Counter(words)
     filtered_words = []
     used_words = set()
-
+    # Iterate through the words to find similar words
     for word in word_counts:
         if word in used_words:
             continue
@@ -207,7 +207,7 @@ def _simplify_word_list(words: List[str], threshold: float = 0.80) -> List[str]:
         similar_words = [
             other_word
             for other_word in word_counts
-            if _jaccard_index(word_set, set(other_word)) >= threshold
+            if _calculate_jaccard_index(word_set, set(other_word)) >= threshold
         ]
         # Sort by frequency and choose the most frequent word
         similar_words.sort(key=lambda w: word_counts[w], reverse=True)
@@ -220,7 +220,7 @@ def _simplify_word_list(words: List[str], threshold: float = 0.80) -> List[str]:
     return final_words
 
 
-def _jaccard_index(set1: Set[Any], set2: Set[Any]) -> float:
+def _calculate_jaccard_index(set1: Set[Any], set2: Set[Any]) -> float:
     """Calculate the Jaccard Index of two sets.
 
     Args:

risk/constants.py

@@ -3,6 +3,8 @@ risk/constants
 ~~~~~~~~~~~~~~
 """
 
+GROUP_LINKAGE_METHODS = ["single", "complete", "average", "weighted", "centroid", "median", "ward"]
+
 GROUP_DISTANCE_METRICS = [
     "braycurtis",
     "canberra",
@@ -27,5 +29,3 @@ GROUP_DISTANCE_METRICS = [
     "sqeuclidean",
     "yule",
 ]
-
-GROUP_LINKAGE_METHODS = ["single", "complete", "average", "weighted", "centroid", "median", "ward"]

risk/neighborhoods/neighborhoods.py

@@ -321,7 +321,11 @@ def _calculate_threshold(average_distances: list, distance_threshold: float) ->
     rank_percentiles = np.linspace(0, 1, len(sorted_distances))
     # Interpolating the ranks to 1000 evenly spaced percentiles
     interpolated_percentiles = np.linspace(0, 1, 1000)
-    smoothed_distances = np.interp(interpolated_percentiles, rank_percentiles, sorted_distances)
+    try:
+        smoothed_distances = np.interp(interpolated_percentiles, rank_percentiles, sorted_distances)
+    except ValueError as e:
+        raise ValueError("No significant annotations found.") from e
+
     # Determine the index corresponding to the distance threshold
     threshold_index = int(np.ceil(distance_threshold * len(smoothed_distances))) - 1
     # Return the smoothed distance at the calculated index

risk/network/geometry.py

@@ -7,13 +7,13 @@ import networkx as nx
 import numpy as np
 
 
-def apply_edge_lengths(
+def assign_edge_lengths(
     G: nx.Graph,
     compute_sphere: bool = True,
     surface_depth: float = 0.0,
     include_edge_weight: bool = False,
 ) -> nx.Graph:
-    """Apply edge lengths in the graph, optionally mapping nodes to a sphere and including edge weights.
+    """Assign edge lengths in the graph, optionally mapping nodes to a sphere and including edge weights.
 
     Args:
         G (nx.Graph): The input graph.

risk/network/graph.py

@@ -5,13 +5,12 @@ risk/network/graph
 
 import random
 from collections import defaultdict
-from typing import Any, Dict, List, Tuple
+from typing import Any, Dict, List, Tuple, Union
 
 import networkx as nx
 import numpy as np
 import pandas as pd
 import matplotlib
-import matplotlib.cm as cm
 
 
 class NetworkGraph:
@@ -101,7 +100,12 @@ class NetworkGraph:
         self.node_coordinates = _extract_node_coordinates(G_2d)
 
     def get_domain_colors(
-        self, min_scale: float = 0.8, max_scale: float = 1.0, random_seed: int = 888, **kwargs
+        self,
+        min_scale: float = 0.8,
+        max_scale: float = 1.0,
+        scale_factor: float = 1.0,
+        random_seed: int = 888,
+        **kwargs,
     ) -> np.ndarray:
         """Generate composite colors for domains.
 
@@ -112,6 +116,8 @@ class NetworkGraph:
         Args:
             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.
             random_seed (int, optional): Seed for random number generation. Defaults to 888.
             **kwargs: Additional keyword arguments for color generation.
 
@@ -119,7 +125,7 @@ class NetworkGraph:
             np.ndarray: Array of transformed colors.
         """
         # Get colors for each domain
-        domain_colors = self._get_domain_colors(**kwargs, random_seed=random_seed)
+        domain_colors = self._get_domain_colors(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
@@ -128,6 +134,7 @@ class NetworkGraph:
             self.node_enrichment_sums,
             min_scale=min_scale,
             max_scale=max_scale,
+            scale_factor=scale_factor,
         )
 
         return transformed_colors
@@ -153,9 +160,15 @@ class NetworkGraph:
 
         return composite_colors
 
-    def _get_domain_colors(self, **kwargs) -> Dict[str, Any]:
+    def _get_domain_colors(
+        self, color: Union[str, None] = None, random_seed: int = 888
+    ) -> Dict[str, Any]:
         """Get colors for each domain.
 
+        Args:
+            color (Union[str, None], optional): Specific color to use for all domains. If specified, it will overwrite the colormap.
+            random_seed (int, optional): Seed for random number generation. Defaults to 888.
+
         Returns:
             dict: A dictionary mapping domain keys to their corresponding RGBA colors.
         """
@@ -164,20 +177,28 @@ class NetworkGraph:
             col for col in self.domains.columns if isinstance(col, (int, np.integer))
         ]
         domains = np.sort(numeric_domains)
-        domain_colors = _get_colors(**kwargs, num_colors_to_generate=len(domains))
+        domain_colors = _get_colors(
+            num_colors_to_generate=len(domains), color=color, random_seed=random_seed
+        )
         return dict(zip(self.domain_to_nodes.keys(), domain_colors))
 
 
 def _transform_colors(
-    colors: np.ndarray, enrichment_sums: np.ndarray, min_scale: float = 0.8, max_scale: float = 1.0
+    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 to ensure proper alpha values and intensity based on enrichment sums.
+    """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.
@@ -185,11 +206,12 @@ def _transform_colors(
     if min_scale == max_scale:
         min_scale = max_scale - 10e-6  # Avoid division by zero
 
-    log_enrichment_sums = np.log1p(enrichment_sums)  # Use log1p to avoid log(0)
-    # Normalize the capped enrichment sums to the range [0, 1]
-    normalized_sums = log_enrichment_sums / np.max(log_enrichment_sums)
-    # Scale normalized sums to the specified color range [min_scale, max_scale]
-    scaled_sums = min_scale + (max_scale - min_scale) * normalized_sums
+    # 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]
@@ -250,7 +272,10 @@ def _extract_node_coordinates(G: nx.Graph) -> np.ndarray:
 
 
 def _get_colors(
-    num_colors_to_generate: int = 10, cmap: str = "hsv", random_seed: int = 888, **kwargs
+    num_colors_to_generate: int = 10,
+    cmap: str = "hsv",
+    random_seed: int = 888,
+    color: Union[str, None] = None,
 ) -> List[Tuple]:
     """Generate a list of RGBA colors from a specified colormap or use a direct color string.
 
@@ -258,19 +283,20 @@ def _get_colors(
         num_colors_to_generate (int): The number of colors to generate. Defaults to 10.
         cmap (str): The name of the colormap to use. Defaults to "hsv".
         random_seed (int): Seed for random number generation. Defaults to 888.
-        **kwargs: Additional keyword arguments, such as 'color' for a specific color.
+        color (str, optional): Specific color to use for all nodes. If specified, it will overwrite the colormap.
+            Defaults to None.
 
     Returns:
         list of tuple: List of RGBA colors.
     """
     # Set random seed for reproducibility
     random.seed(random_seed)
-    if kwargs.get("color"):
-        # If a direct color string is provided, generate a list with that color
-        rgba = matplotlib.colors.to_rgba(kwargs["color"])
+    if color:
+        # If a direct color is provided, generate a list with that color
+        rgba = matplotlib.colors.to_rgba(color)
         rgbas = [rgba] * num_colors_to_generate
     else:
-        colormap = cm.get_cmap(cmap)
+        colormap = matplotlib.colormaps.get_cmap(cmap)
         # Generate evenly distributed color positions
         color_positions = np.linspace(0, 1, num_colors_to_generate)
         random.shuffle(color_positions)  # Shuffle the positions to randomize colors

risk/network/io.py

@@ -6,6 +6,7 @@ This file contains the code for the RISK class and command-line access.
 """
 
 import json
+import os
 import pickle
 import shutil
 import zipfile
@@ -14,7 +15,7 @@ from xml.dom import minidom
 import networkx as nx
 import pandas as pd
 
-from risk.network.geometry import apply_edge_lengths
+from risk.network.geometry import assign_edge_lengths
 from risk.log import params, print_header
 
 
@@ -215,14 +216,20 @@ class NetworkIO:
         params.log_network(filetype=filetype, filepath=str(filepath))
         self._log_loading(filetype, filepath=filepath)
         cys_files = []
+        tmp_dir = ".tmp_cytoscape"
         # Try / finally to remove unzipped files
         try:
-            # Unzip CYS file
+            # Create the temporary directory if it doesn't exist
+            if not os.path.exists(tmp_dir):
+                os.makedirs(tmp_dir)
+
+            # Unzip CYS file into the temporary directory
             with zipfile.ZipFile(filepath, "r") as zip_ref:
                 cys_files = zip_ref.namelist()
-                zip_ref.extractall("./")
+                zip_ref.extractall(tmp_dir)
+
             # Get first view and network instances
-            cys_view_files = [cf for cf in cys_files if "/views/" in cf]
+            cys_view_files = [os.path.join(tmp_dir, cf) for cf in cys_files if "/views/" in cf]
             cys_view_file = (
                 cys_view_files[0]
                 if not view_name
@@ -244,7 +251,7 @@ class NetworkIO:
             # Read the node attributes (from /tables/)
             attribute_metadata_keywords = ["/tables/", "SHARED_ATTRS", "edge.cytable"]
             attribute_metadata = [
-                cf
+                os.path.join(tmp_dir, cf)
                 for cf in cys_files
                 if all(keyword in cf for keyword in attribute_metadata_keywords)
             ][0]
@@ -291,10 +298,9 @@ class NetworkIO:
             return self._initialize_graph(G)
 
         finally:
-            # Remove unzipped files/directories
-            cys_dirnames = list(set([cf.split("/")[0] for cf in cys_files]))
-            for dirname in cys_dirnames:
-                shutil.rmtree(dirname)
+            # Remove the temporary directory and its contents
+            if os.path.exists(tmp_dir):
+                shutil.rmtree(tmp_dir)
 
     @classmethod
     def load_cytoscape_json_network(
@@ -402,12 +408,13 @@ class NetworkIO:
         Returns:
             nx.Graph: The processed and validated graph.
         """
+        self._validate_nodes(G)
+        self._assign_edge_weights(G)
+        self._assign_edge_lengths(G)
+        self._remove_invalid_graph_properties(G)
         # IMPORTANT: This is where the graph node labels are converted to integers
+        # Make sure to perform this step after all other processing
         G = nx.relabel_nodes(G, {node: idx for idx, node in enumerate(G.nodes)})
-        self._remove_invalid_graph_properties(G)
-        self._validate_edges(G)
-        self._validate_nodes(G)
-        self._process_graph(G)
         return G
 
     def _remove_invalid_graph_properties(self, G: nx.Graph) -> None:
@@ -416,18 +423,26 @@ class NetworkIO:
         Args:
             G (nx.Graph): A NetworkX graph object.
         """
-        print(f"Minimum edges per node: {self.min_edges_per_node}")
-        # Remove nodes with fewer edges than the specified threshold
-        nodes_with_few_edges = [
-            node for node in G.nodes() if G.degree(node) <= self.min_edges_per_node
-        ]
-        G.remove_nodes_from(nodes_with_few_edges)
-        # Remove self-loop edges
-        self_loops = list(nx.selfloop_edges(G))
-        G.remove_edges_from(self_loops)
-
-    def _validate_edges(self, G: nx.Graph) -> None:
-        """Validate and assign weights to the edges in the graph.
+        # First, Remove self-loop edges to ensure correct edge count
+        G.remove_edges_from(list(nx.selfloop_edges(G)))
+        # Then, iteratively remove nodes with fewer edges than the specified threshold
+        while True:
+            nodes_to_remove = [
+                node for node in G.nodes() if G.degree(node) < self.min_edges_per_node
+            ]
+            if not nodes_to_remove:
+                break  # Exit loop if no more nodes to remove
+
+            # Remove the nodes and their associated edges
+            G.remove_nodes_from(nodes_to_remove)
+
+        # Optionally: Remove any isolated nodes if needed
+        isolated_nodes = list(nx.isolates(G))
+        if isolated_nodes:
+            G.remove_nodes_from(isolated_nodes)
+
+    def _assign_edge_weights(self, G: nx.Graph) -> None:
+        """Assign weights to the edges in the graph.
 
         Args:
             G (nx.Graph): A NetworkX graph object.
@@ -456,13 +471,13 @@ class NetworkIO:
             ), f"Node {node} is missing 'x' or 'y' position attributes."
             assert "label" in attrs, f"Node {node} is missing a 'label' attribute."
 
-    def _process_graph(self, G: nx.Graph) -> None:
+    def _assign_edge_lengths(self, G: nx.Graph) -> None:
         """Prepare the network by adjusting surface depth and calculating edge lengths.
 
         Args:
             G (nx.Graph): The input network graph.
         """
-        apply_edge_lengths(
+        assign_edge_lengths(
             G,
             compute_sphere=self.compute_sphere,
             surface_depth=self.surface_depth,
@@ -484,9 +499,9 @@ class NetworkIO:
         print(f"Filetype: {filetype}")
         if filepath:
             print(f"Filepath: {filepath}")
-        print(f"Projection: {'Sphere' if self.compute_sphere else 'Plane'}")
-        if self.compute_sphere:
-            print(f"Surface depth: {self.surface_depth}")
         print(f"Edge weight: {'Included' if self.include_edge_weight else 'Excluded'}")
         if self.include_edge_weight:
             print(f"Weight label: {self.weight_label}")
+        print(f"Projection: {'Sphere' if self.compute_sphere else 'Plane'}")
+        if self.compute_sphere:
+            print(f"Surface depth: {self.surface_depth}")

risk/network/plot.py

@@ -33,6 +33,7 @@ class NetworkPlotter:
         plot_outline: bool = True,
         outline_color: str = "black",
         outline_scale: float = 1.0,
+        linestyle: str = "dashed",
     ) -> None:
         """Initialize the NetworkPlotter with a NetworkGraph object and plotting parameters.
 
@@ -43,11 +44,18 @@ class NetworkPlotter:
             plot_outline (bool, optional): Whether to plot the network perimeter circle. Defaults to True.
             outline_color (str, optional): Color of the network perimeter circle. Defaults to "black".
             outline_scale (float, optional): Outline scaling factor for the perimeter diameter. Defaults to 1.0.
+            linestyle (str): Line style for the network perimeter circle (e.g., dashed, solid). Defaults to "dashed".
         """
         self.graph = graph
         # Initialize the plot with the specified parameters
         self.ax = self._initialize_plot(
-            graph, figsize, background_color, plot_outline, outline_color, outline_scale
+            graph,
+            figsize,
+            background_color,
+            plot_outline,
+            outline_color,
+            outline_scale,
+            linestyle,
         )
 
     def _initialize_plot(
@@ -58,6 +66,7 @@ class NetworkPlotter:
         plot_outline: bool,
         outline_color: str,
         outline_scale: float,
+        linestyle: str,
     ) -> plt.Axes:
         """Set up the plot with figure size, optional circle perimeter, and background color.
 
@@ -68,6 +77,7 @@ class NetworkPlotter:
             plot_outline (bool): Whether to plot the network perimeter circle.
             outline_color (str): Color of the network perimeter circle.
             outline_scale (float): Outline scaling factor for the perimeter diameter.
+            linestyle (str): Line style for the network perimeter circle (e.g., dashed, solid).
 
         Returns:
             plt.Axes: The axis object for the plot.
@@ -87,7 +97,7 @@ class NetworkPlotter:
             circle = plt.Circle(
                 center,
                 scaled_radius,
-                linestyle="--",
+                linestyle=linestyle,  # Use the linestyle argument here
                 color=outline_color,
                 fill=False,
                 linewidth=1.5,
@@ -400,8 +410,12 @@ class NetworkPlotter:
         fontcolor: Union[str, np.ndarray] = "black",
         arrow_linewidth: float = 1,
         arrow_color: Union[str, np.ndarray] = "black",
+        max_labels: Union[int, None] = None,
         max_words: int = 10,
         min_words: int = 1,
+        max_word_length: int = 20,
+        min_word_length: int = 1,
+        words_to_omit: Union[List[str], None] = None,
     ) -> None:
         """Annotate the network graph with labels for different domains, positioned around the network for clarity.
 
@@ -413,8 +427,12 @@ class NetworkPlotter:
             fontcolor (str or np.ndarray, optional): Color of the label text. Can be a string or RGBA array. Defaults to "black".
             arrow_linewidth (float, optional): Line width of the arrows pointing to centroids. Defaults to 1.
             arrow_color (str or np.ndarray, optional): Color of the arrows. Can be a string or RGBA array. Defaults to "black".
+            max_labels (int, optional): Maximum number of labels to plot. Defaults to None (no limit).
             max_words (int, optional): Maximum number of words in a label. Defaults to 10.
             min_words (int, optional): Minimum number of words required to display a label. Defaults to 1.
+            max_word_length (int, optional): Maximum number of characters in a word to display. Defaults to 20.
+            min_word_length (int, optional): Minimum number of characters in a word to display. Defaults to 1.
+            words_to_omit (List[str], optional): List of words to omit from the labels. Defaults to None.
         """
         # Log the plotting parameters
         params.log_plotter(
@@ -425,14 +443,22 @@ class NetworkPlotter:
             label_fontcolor="custom" if isinstance(fontcolor, np.ndarray) else fontcolor,
             label_arrow_linewidth=arrow_linewidth,
             label_arrow_color="custom" if isinstance(arrow_color, np.ndarray) else arrow_color,
+            label_max_labels=max_labels,
             label_max_words=max_words,
             label_min_words=min_words,
+            label_max_word_length=max_word_length,
+            label_min_word_length=min_word_length,
+            label_words_to_omit=words_to_omit,
         )
+
         # Convert color strings to RGBA arrays if necessary
         if isinstance(fontcolor, str):
-            fontcolor = self.get_annotated_contour_colors(color=fontcolor)
+            fontcolor = self.get_annotated_label_colors(color=fontcolor)
         if isinstance(arrow_color, str):
-            arrow_color = self.get_annotated_contour_colors(color=arrow_color)
+            arrow_color = self.get_annotated_label_colors(color=arrow_color)
+        # Normalize words_to_omit to lowercase
+        if words_to_omit:
+            words_to_omit = set(word.lower() for word in words_to_omit)
 
         # Calculate the center and radius of the network
         domain_centroids = {}
@@ -443,31 +469,57 @@ class NetworkPlotter:
         # Initialize empty lists to collect valid indices
         valid_indices = []
         filtered_domain_centroids = {}
+        filtered_domain_terms = {}
         # Loop through domain_centroids with index
         for idx, (domain, centroid) in enumerate(domain_centroids.items()):
+            # Process the domain term
+            terms = self.graph.trimmed_domain_to_term[domain].split(" ")
+            # Remove words_to_omit
+            if words_to_omit:
+                terms = [term for term in terms if term.lower() not in words_to_omit]
+            # Filter words based on length
+            terms = [term for term in terms if min_word_length <= len(term) <= max_word_length]
+            # Trim to max_words
+            terms = terms[:max_words]
             # Check if the domain passes the word count condition
-            if len(self.graph.trimmed_domain_to_term[domain].split(" ")[:max_words]) >= min_words:
+            if len(terms) >= min_words:
                 # Add to filtered_domain_centroids
                 filtered_domain_centroids[domain] = centroid
-                # Keep track of the valid index
+                # Store the filtered and trimmed terms
+                filtered_domain_terms[domain] = " ".join(terms)
+                # Keep track of the valid index - used for fontcolor and arrow_color
                 valid_indices.append(idx)
 
-        # Now filter fontcolor and arrow_color to keep only the valid indices
-        fontcolor = fontcolor[valid_indices]
-        arrow_color = arrow_color[valid_indices]
+        # If max_labels is specified and less than the available labels
+        if max_labels is not None and max_labels < len(filtered_domain_centroids):
+            step = len(filtered_domain_centroids) / max_labels
+            selected_indices = [int(i * step) for i in range(max_labels)]
+            # Filter the centroids, terms, and valid_indices to only use the selected indices
+            filtered_domain_centroids = {
+                k: v
+                for i, (k, v) in enumerate(filtered_domain_centroids.items())
+                if i in selected_indices
+            }
+            filtered_domain_terms = {
+                k: v
+                for i, (k, v) in enumerate(filtered_domain_terms.items())
+                if i in selected_indices
+            }
+            # Update valid_indices to match selected indices
+            valid_indices = [valid_indices[i] for i in selected_indices]
 
         # Calculate the bounding box around the network
         center, radius = _calculate_bounding_box(
             self.graph.node_coordinates, radius_margin=perimeter_scale
         )
         # Calculate the best positions for labels around the perimeter
-        best_label_positions = _best_label_positions(
+        best_label_positions = _calculate_best_label_positions(
             filtered_domain_centroids, center, radius, offset
         )
-        # Annotate the network with labels
-        for idx, (domain, pos) in enumerate(best_label_positions.items()):
+        # Annotate the network with labels - valid_indices is used for fontcolor and arrow_color
+        for idx, (domain, pos) in zip(valid_indices, best_label_positions.items()):
             centroid = filtered_domain_centroids[domain]
-            annotations = self.graph.trimmed_domain_to_term[domain].split(" ")[:max_words]
+            annotations = filtered_domain_terms[domain].split(" ")[:max_words]
             self.ax.annotate(
                 "\n".join(annotations),
                 xy=centroid,
@@ -531,12 +583,10 @@ class NetworkPlotter:
 
         # Calculate the centroid of the provided nodes
         centroid = self._calculate_domain_centroid(node_ids)
-
         # Calculate the bounding box around the network
         center, radius = _calculate_bounding_box(
             self.graph.node_coordinates, radius_margin=perimeter_scale
         )
-
         # Convert radial position to radians, adjusting for a 90-degree rotation
         radial_radians = np.deg2rad(radial_position - 90)
         label_position = (
@@ -746,7 +796,7 @@ def _calculate_bounding_box(
     return center, radius
 
 
-def _best_label_positions(
+def _calculate_best_label_positions(
     filtered_domain_centroids: Dict[str, Any], center: np.ndarray, radius: float, offset: float
 ) -> Dict[str, Any]:
     """Calculate and optimize label positions for clarity.
@@ -762,7 +812,9 @@ def _best_label_positions(
     """
     num_domains = len(filtered_domain_centroids)
     # Calculate equidistant positions around the center for initial label placement
-    equidistant_positions = _equidistant_angles_around_center(center, radius, offset, num_domains)
+    equidistant_positions = _calculate_equidistant_positions_around_center(
+        center, radius, offset, num_domains
+    )
     # Create a mapping of domains to their initial label positions
     label_positions = {
         domain: position
@@ -772,7 +824,7 @@ def _best_label_positions(
     return _optimize_label_positions(label_positions, filtered_domain_centroids)
 
 
-def _equidistant_angles_around_center(
+def _calculate_equidistant_positions_around_center(
     center: np.ndarray, radius: float, label_offset: float, num_domains: int
 ) -> List[np.ndarray]:
     """Calculate positions around a center at equidistant angles.