risk-network 0.0.8b3__tar.gz → 0.0.8b5__tar.gz

{risk_network-0.0.8b3 → risk_network-0.0.8b5}/PKG-INFO

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

{risk_network-0.0.8b3 → risk_network-0.0.8b5}/risk/__init__.py

@@ -7,4 +7,4 @@ RISK: RISK Infers Spatial Kinships
 
 from risk.risk import RISK
 
-__version__ = "0.0.8-beta.3"
+__version__ = "0.0.8-beta.5"

{risk_network-0.0.8b3 → risk_network-0.0.8b5}/risk/network/plot.py

@@ -33,6 +33,7 @@ class NetworkPlotter:
         graph: NetworkGraph,
         figsize: Tuple = (10, 10),
         background_color: Union[str, List, Tuple, np.ndarray] = "white",
+        background_alpha: float = 1.0,
     ) -> None:
         """Initialize the NetworkPlotter with a NetworkGraph object and plotting parameters.
 
@@ -40,16 +41,23 @@ class NetworkPlotter:
             graph (NetworkGraph): The network data and attributes to be visualized.
             figsize (tuple, 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, optional): Transparency level of the background color. Defaults to 1.0.
         """
         self.graph = graph
         # Initialize the plot with the specified parameters
-        self.ax = self._initialize_plot(graph, figsize, background_color)
+        self.ax = self._initialize_plot(
+            graph=graph,
+            figsize=figsize,
+            background_color=background_color,
+            background_alpha=background_alpha,
+        )
 
     def _initialize_plot(
         self,
         graph: NetworkGraph,
         figsize: Tuple,
         background_color: Union[str, List, Tuple, np.ndarray],
+        background_alpha: float = 1.0,
     ) -> plt.Axes:
         """Set up the plot with figure size and background color.
 
@@ -57,6 +65,7 @@ class NetworkPlotter:
             graph (NetworkGraph): The network data and attributes to be visualized.
             figsize (tuple): Size of the figure in inches (width, height).
             background_color (str): Background color of the plot.
+            background_alpha (float, optional): Transparency level of the background color. Defaults to 1.0.
 
         Returns:
             plt.Axes: The axis object for the plot.
@@ -76,7 +85,7 @@ class NetworkPlotter:
 
         # Set the background color of the plot
         # Convert color to RGBA using the _to_rgba helper function
-        fig.patch.set_facecolor(_to_rgba(background_color, 1.0))
+        fig.patch.set_facecolor(_to_rgba(color=background_color, alpha=background_alpha))
         ax.invert_yaxis()  # Invert the y-axis to match typical image coordinates
         # Remove axis spines for a cleaner look
         for spine in ax.spines.values():
@@ -199,7 +208,7 @@ class NetworkPlotter:
         )
 
         # Convert color to RGBA using the _to_rgba helper function - use outline_alpha for the perimeter
-        color = _to_rgba(color, outline_alpha)
+        color = _to_rgba(color=color, alpha=outline_alpha)
         # Extract node coordinates from the network graph
         node_coordinates = self.graph.node_coordinates
         # Calculate the center and radius of the bounding box around the network
@@ -218,7 +227,7 @@ class NetworkPlotter:
         )
         # Set the transparency of the fill if applicable
         if fill_alpha > 0:
-            circle.set_facecolor(_to_rgba(color, fill_alpha))
+            circle.set_facecolor(_to_rgba(color=color, alpha=fill_alpha))
 
         self.ax.add_artist(circle)
 
@@ -263,7 +272,7 @@ class NetworkPlotter:
         )
 
         # Convert color to RGBA using the _to_rgba helper function - use outline_alpha for the perimeter
-        color = _to_rgba(color, outline_alpha)
+        color = _to_rgba(color=color, alpha=outline_alpha)
         # Extract node coordinates from the network graph
         node_coordinates = self.graph.node_coordinates
         # Scale the node coordinates if needed
@@ -326,9 +335,15 @@ class NetworkPlotter:
 
         # Convert colors to RGBA using the _to_rgba helper function
         # If node_colors was generated using get_annotated_node_colors, its alpha values will override node_alpha
-        node_color = _to_rgba(node_color, node_alpha, num_repeats=len(self.graph.network.nodes))
-        node_edgecolor = _to_rgba(node_edgecolor, 1.0, num_repeats=len(self.graph.network.nodes))
-        edge_color = _to_rgba(edge_color, edge_alpha, num_repeats=len(self.graph.network.edges))
+        node_color = _to_rgba(
+            color=node_color, alpha=node_alpha, num_repeats=len(self.graph.network.nodes)
+        )
+        node_edgecolor = _to_rgba(
+            color=node_edgecolor, alpha=1.0, num_repeats=len(self.graph.network.nodes)
+        )
+        edge_color = _to_rgba(
+            color=edge_color, alpha=edge_alpha, num_repeats=len(self.graph.network.edges)
+        )
 
         # Extract node coordinates from the network graph
         node_coordinates = self.graph.node_coordinates
@@ -405,9 +420,11 @@ class NetworkPlotter:
             ]
 
         # Convert colors to RGBA using the _to_rgba helper function
-        node_color = _to_rgba(node_color, node_alpha, num_repeats=len(node_ids))
-        node_edgecolor = _to_rgba(node_edgecolor, 1.0, num_repeats=len(node_ids))
-        edge_color = _to_rgba(edge_color, edge_alpha, num_repeats=len(self.graph.network.edges))
+        node_color = _to_rgba(color=node_color, alpha=node_alpha, num_repeats=len(node_ids))
+        node_edgecolor = _to_rgba(color=node_edgecolor, alpha=1.0, num_repeats=len(node_ids))
+        edge_color = _to_rgba(
+            color=edge_color, alpha=edge_alpha, num_repeats=len(self.graph.network.edges)
+        )
 
         # Get the coordinates of the filtered nodes
         node_coordinates = {node_id: self.graph.node_coordinates[node_id] for node_id in node_ids}
@@ -470,7 +487,9 @@ class NetworkPlotter:
         )
 
         # Ensure color is converted to RGBA with repetition matching the number of domains
-        color = _to_rgba(color, alpha, num_repeats=len(self.graph.domain_id_to_node_ids_map))
+        color = _to_rgba(
+            color=color, alpha=alpha, num_repeats=len(self.graph.domain_id_to_node_ids_map)
+        )
         # Extract node coordinates from the network graph
         node_coordinates = self.graph.node_coordinates
         # Draw contours for each domain in the network
@@ -527,7 +546,7 @@ class NetworkPlotter:
             node_groups = [nodes]
 
         # Convert color to RGBA using the _to_rgba helper function
-        color_rgba = _to_rgba(color, alpha)
+        color_rgba = _to_rgba(color=color, alpha=alpha)
 
         # Iterate over each group of nodes (either sublists or flat list)
         for sublist in node_groups:
@@ -705,10 +724,10 @@ class NetworkPlotter:
             arrow_base_shrink (float, optional): Distance between the text and the base of the arrow. Defaults to 0.0.
             arrow_tip_shrink (float, optional): Distance between the arrow tip and the centroid. Defaults to 0.0.
             max_labels (int, optional): Maximum number of labels to plot. Defaults to None (no limit).
-            max_label_lines (int, optional): Maximum number of lines in a label. Defaults to None (no limit).
             min_label_lines (int, optional): Minimum number of lines in a label. Defaults to 1.
-            max_chars_per_line (int, optional): Maximum number of characters in a line to display. Defaults to None (no limit).
+            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.
             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,
@@ -761,11 +780,11 @@ class NetworkPlotter:
         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 = {}
+        # Calculate the center and radius of domains to position labels around the network
+        domain_id_to_centroid_map = {}
         for domain_id, node_ids in self.graph.domain_id_to_node_ids_map.items():
             if node_ids:  # Skip if the domain has no nodes
-                domain_centroids[domain_id] = self._calculate_domain_centroid(node_ids)
+                domain_id_to_centroid_map[domain_id] = self._calculate_domain_centroid(node_ids)
 
         # Initialize dictionaries and lists for valid indices
         valid_indices = []  # List of valid indices to plot colors and arrows
@@ -775,8 +794,8 @@ class NetworkPlotter:
         if ids_to_keep:
             # Process the ids_to_keep first INPLACE
             self._process_ids_to_keep(
+                domain_id_to_centroid_map=domain_id_to_centroid_map,
                 ids_to_keep=ids_to_keep,
-                domain_centroids=domain_centroids,
                 ids_to_replace=ids_to_replace,
                 words_to_omit=words_to_omit,
                 max_labels=max_labels,
@@ -796,7 +815,7 @@ class NetworkPlotter:
         # Process remaining domains INPLACE to fill in additional labels, if there are slots left
         if remaining_labels and remaining_labels > 0:
             self._process_remaining_domains(
-                domain_centroids=domain_centroids,
+                domain_id_to_centroid_map=domain_id_to_centroid_map,
                 ids_to_keep=ids_to_keep,
                 ids_to_replace=ids_to_replace,
                 words_to_omit=words_to_omit,
@@ -816,12 +835,14 @@ class NetworkPlotter:
         best_label_positions = _calculate_best_label_positions(
             filtered_domain_centroids, center, radius, offset
         )
-        # Convert colors to RGBA using the _to_rgba helper function
+        # Convert all domain colors to RGBA using the _to_rgba helper function
         fontcolor = _to_rgba(
-            fontcolor, fontalpha, num_repeats=len(self.graph.domain_id_to_node_ids_map)
+            color=fontcolor, alpha=fontalpha, num_repeats=len(self.graph.domain_id_to_node_ids_map)
         )
         arrow_color = _to_rgba(
-            arrow_color, arrow_alpha, num_repeats=len(self.graph.domain_id_to_node_ids_map)
+            color=arrow_color,
+            alpha=arrow_alpha,
+            num_repeats=len(self.graph.domain_id_to_node_ids_map),
         )
 
         # Annotate the network with labels
@@ -847,8 +868,11 @@ class NetworkPlotter:
                     shrinkB=arrow_tip_shrink,
                 ),
             )
-            # Overlay domain ID at the centroid if requested
-            if overlay_ids:
+
+        # Overlay domain ID at the centroid regardless of max_labels if requested
+        if overlay_ids:
+            for idx, domain in enumerate(self.graph.domain_id_to_node_ids_map):
+                centroid = domain_id_to_centroid_map[domain]
                 self.ax.text(
                     centroid[0],
                     centroid[1],
@@ -907,8 +931,8 @@ class NetworkPlotter:
             node_groups = [nodes]
 
         # Convert fontcolor and arrow_color to RGBA
-        fontcolor_rgba = _to_rgba(fontcolor, fontalpha)
-        arrow_color_rgba = _to_rgba(arrow_color, arrow_alpha)
+        fontcolor_rgba = _to_rgba(color=fontcolor, alpha=fontalpha)
+        arrow_color_rgba = _to_rgba(color=arrow_color, alpha=arrow_alpha)
 
         # Calculate the bounding box around the network
         center, radius = _calculate_bounding_box(self.graph.node_coordinates, radius_margin=scale)
@@ -977,8 +1001,8 @@ class NetworkPlotter:
 
     def _process_ids_to_keep(
         self,
+        domain_id_to_centroid_map: Dict[str, np.ndarray],
         ids_to_keep: Union[List[str], Tuple[str], np.ndarray],
-        domain_centroids: Dict[str, np.ndarray],
         ids_to_replace: Union[Dict[str, str], None],
         words_to_omit: Union[List[str], None],
         max_labels: Union[int, None],
@@ -993,8 +1017,8 @@ class NetworkPlotter:
         """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.
-            domain_centroids (dict): Mapping of domains to their centroids.
             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.
             max_labels (int, optional): Maximum number of labels allowed.
@@ -1020,25 +1044,30 @@ class NetworkPlotter:
 
         # Process each domain in ids_to_keep
         for domain in ids_to_keep:
-            if domain in self.graph.domain_id_to_domain_terms_map and domain in domain_centroids:
-                domain_terms = self._process_terms(
+            if (
+                domain in self.graph.domain_id_to_domain_terms_map
+                and domain in domain_id_to_centroid_map
+            ):
+                domain_centroid = domain_id_to_centroid_map[domain]
+                # No need to filter the domain terms if it is in ids_to_keep
+                _ = self._validate_and_update_domain(
                     domain=domain,
+                    domain_centroid=domain_centroid,
+                    domain_id_to_centroid_map=domain_id_to_centroid_map,
                     ids_to_replace=ids_to_replace,
                     words_to_omit=words_to_omit,
+                    min_label_lines=min_label_lines,
                     max_label_lines=max_label_lines,
                     min_chars_per_line=min_chars_per_line,
                     max_chars_per_line=max_chars_per_line,
+                    filtered_domain_centroids=filtered_domain_centroids,
+                    filtered_domain_terms=filtered_domain_terms,
+                    valid_indices=valid_indices,
                 )
-                num_domain_lines = len(domain_terms.split(TERM_DELIMITER))
-                # Check if the number of lines in the label is greater than or equal to the minimum
-                if num_domain_lines >= min_label_lines:
-                    filtered_domain_terms[domain] = domain_terms
-                    filtered_domain_centroids[domain] = domain_centroids[domain]
-                    valid_indices.append(list(domain_centroids.keys()).index(domain))
 
     def _process_remaining_domains(
         self,
-        domain_centroids: Dict[str, np.ndarray],
+        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],
         words_to_omit: Union[List[str], None],
@@ -1054,7 +1083,7 @@ class NetworkPlotter:
         """Process remaining domains to fill in additional labels, respecting the remaining_labels limit.
 
         Args:
-            domain_centroids (dict): Mapping of domains to their centroids.
+            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.
@@ -1066,13 +1095,16 @@ class NetworkPlotter:
             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).
+
+        Note:
+            The `filtered_domain_centroids`, `filtered_domain_terms`, and `valid_indices` are modified in-place.
         """
         # Counter to track how many labels have been created
         label_count = 0
         # Collect domains not in ids_to_keep
         remaining_domains = {
             domain: centroid
-            for domain, centroid in domain_centroids.items()
+            for domain, centroid in domain_id_to_centroid_map.items()
             if domain not in ids_to_keep and not pd.isna(domain)
         }
 
@@ -1112,26 +1144,89 @@ class NetworkPlotter:
 
         # Process the selected domains and add to filtered lists
         for domain in selected_domains:
-            centroid = remaining_domains[domain]
-            domain_terms = self._process_terms(
+            domain_centroid = remaining_domains[domain]
+            is_domain_valid = self._validate_and_update_domain(
                 domain=domain,
+                domain_centroid=domain_centroid,
+                domain_id_to_centroid_map=domain_id_to_centroid_map,
                 ids_to_replace=ids_to_replace,
                 words_to_omit=words_to_omit,
+                min_label_lines=min_label_lines,
                 max_label_lines=max_label_lines,
                 min_chars_per_line=min_chars_per_line,
                 max_chars_per_line=max_chars_per_line,
+                filtered_domain_centroids=filtered_domain_centroids,
+                filtered_domain_terms=filtered_domain_terms,
+                valid_indices=valid_indices,
             )
-            num_domain_lines = len(domain_terms.split(TERM_DELIMITER))
-            # Check if the number of lines in the label is greater than or equal to the minimum
-            if num_domain_lines >= min_label_lines:
-                filtered_domain_centroids[domain] = centroid
-                filtered_domain_terms[domain] = domain_terms
-                valid_indices.append(list(domain_centroids.keys()).index(domain))
-
+            # Increment the label count if the domain is valid
+            if is_domain_valid:
                 label_count += 1
                 if label_count >= remaining_labels:
                     break
 
+    def _validate_and_update_domain(
+        self,
+        domain: str,
+        domain_centroid: np.ndarray,
+        domain_id_to_centroid_map: Dict[str, np.ndarray],
+        ids_to_replace: Union[Dict[str, 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],
+        valid_indices: List[int],
+    ) -> bool:
+        """Validate and process the domain terms, updating relevant dictionaries if valid.
+
+        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.
+            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_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.
+
+        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
+
     def _process_terms(
         self,
         domain: str,
@@ -1152,7 +1247,7 @@ class NetworkPlotter:
             max_chars_per_line (int): Maximum number of characters in a line to display.
 
         Returns:
-            list: Processed terms, with words combined if necessary to fit within constraints.
+            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:
@@ -1213,11 +1308,11 @@ class NetworkPlotter:
         # Apply the alpha value for enriched nodes
         network_colors[:, 3] = alpha  # Apply the alpha value to the enriched nodes' A channel
         # Convert the non-enriched color to RGBA using the _to_rgba helper function
-        nonenriched_color = _to_rgba(nonenriched_color, nonenriched_alpha)
+        nonenriched_color = _to_rgba(color=nonenriched_color, alpha=nonenriched_alpha)
         # Adjust node colors: replace any fully black nodes (RGB == 0) with the non-enriched color and its alpha
         adjusted_network_colors = np.where(
             np.all(network_colors[:, :3] == 0, axis=1, keepdims=True),  # Check RGB values only
-            np.array([nonenriched_color]),  # Apply the non-enriched color with alpha
+            np.array(nonenriched_color),  # Apply the non-enriched color with alpha
             network_colors,  # Keep the original colors for enriched nodes
         )
         return adjusted_network_colors
@@ -1391,62 +1486,65 @@ class NetworkPlotter:
 
 def _to_rgba(
     color: Union[str, List, Tuple, np.ndarray],
-    alpha: float = 1.0,
+    alpha: Union[float, None] = None,
     num_repeats: Union[int, None] = None,
 ) -> np.ndarray:
-    """Convert a color or array of colors to RGBA format, applying alpha only if the color is RGB.
+    """Convert color(s) to RGBA format, applying alpha and repeating as needed.
 
     Args:
         color (Union[str, list, tuple, np.ndarray]): The color(s) to convert. Can be a string, list, tuple, or np.ndarray.
-        alpha (float, optional): Alpha value (transparency) to apply if the color is in RGB format. Defaults to 1.0.
-        num_repeats (int or None, optional): If provided, the color will be repeated this many times. Defaults to None.
+        alpha (float, None, optional): Alpha value (transparency) to apply. If provided, it overrides any existing alpha values.
+        num_repeats (int, None, optional): If provided, the color(s) will be repeated this many times. Defaults to None.
 
     Returns:
-        np.ndarray: The RGBA color or array of RGBA colors.
+        np.ndarray: Array of RGBA colors repeated `num_repeats` times, if applicable.
     """
-    # Handle single color case (string, RGB, or RGBA)
-    if isinstance(color, str) or (
-        isinstance(color, (list, tuple, np.ndarray))
-        and len(color) in [3, 4]
-        and not any(isinstance(c, (list, tuple, np.ndarray)) for c in color)
-    ):
-        rgba_color = np.array(mcolors.to_rgba(color))
-        # Only set alpha if the input is an RGB color or a string (not RGBA)
-        if len(rgba_color) == 4 and (
-            len(color) == 3 or isinstance(color, str)
-        ):  # If it's RGB or a string, set the alpha
-            rgba_color[3] = alpha
 
-        # Repeat the color if num_repeats argument is provided
-        if num_repeats is not None:
-            return np.array([rgba_color] * num_repeats)
+    def convert_to_rgba(c: Union[str, List, Tuple, np.ndarray]) -> np.ndarray:
+        """Convert a single color to RGBA format, handling strings, hex, and RGB/RGBA lists."""
+        if isinstance(c, str):
+            # Convert color names or hex values (e.g., 'red', '#FF5733') to RGBA
+            rgba = np.array(mcolors.to_rgba(c))
+        elif isinstance(c, (list, tuple, np.ndarray)) and len(c) in [3, 4]:
+            # Convert RGB (3) or RGBA (4) values to RGBA format
+            rgba = np.array(mcolors.to_rgba(c))
+        else:
+            raise ValueError(
+                f"Invalid color format: {c}. Must be a valid string or RGB/RGBA sequence."
+            )
 
-        return rgba_color
+        if alpha is not None:  # Override alpha if provided
+            rgba[3] = alpha
+        return rgba
 
-    # Handle array of colors case (including strings, RGB, and RGBA)
-    elif isinstance(color, (list, tuple, np.ndarray)):
-        rgba_colors = []
-        for i in range(num_repeats):
-            # Reiterate over the colors if the number of repeats exceeds the number of colors
-            c = color[i % len(color)]
-            # Ensure each element is either a valid string or a list/tuple of length 3 (RGB) or 4 (RGBA)
-            if isinstance(c, str) or (
-                isinstance(c, (list, tuple, np.ndarray)) and len(c) in [3, 4]
-            ):
-                rgba_c = np.array(mcolors.to_rgba(c))
-                # Apply alpha only to RGB colors (not RGBA) and strings
-                if len(rgba_c) == 4 and (len(c) == 3 or isinstance(c, str)):
-                    rgba_c[3] = alpha
-
-                rgba_colors.append(rgba_c)
-            else:
-                raise ValueError(f"Invalid color: {c}. Must be a valid RGB/RGBA or string color.")
+    # If color is a 2D array of RGBA values, convert it to a list of lists
+    if isinstance(color, np.ndarray) and color.ndim == 2 and color.shape[1] == 4:
+        color = [list(c) for c in color]
 
-        # Repeat the colors if num_repeats argument is provided
-        if num_repeats is not None and len(rgba_colors) == 1:
-            return np.array([rgba_colors[0]] * num_repeats)
+    # Handle a single color (string or RGB/RGBA list/tuple)
+    if isinstance(color, (str, list, tuple)) and not any(
+        isinstance(c, (list, tuple, np.ndarray)) for c in color
+    ):
+        rgba_color = convert_to_rgba(color)
+        if num_repeats:
+            return np.tile(
+                rgba_color, (num_repeats, 1)
+            )  # Repeat the color if num_repeats is provided
+        return np.array([rgba_color])  # Return a single color wrapped in a numpy array
+
+    # Handle a list/array of colors
+    elif isinstance(color, (list, tuple, np.ndarray)):
+        rgba_colors = np.array(
+            [convert_to_rgba(c) for c in color]
+        )  # Convert each color in the list to RGBA
+        # Handle repetition if num_repeats is provided
+        if num_repeats:
+            repeated_colors = np.array(
+                [rgba_colors[i % len(rgba_colors)] for i in range(num_repeats)]
+            )
+            return repeated_colors
 
-        return np.array(rgba_colors)
+        return rgba_colors
 
     else:
         raise ValueError("Color must be a valid RGB/RGBA or array of RGB/RGBA colors.")
@@ -1487,13 +1585,13 @@ def _calculate_bounding_box(
     return center, radius
 
 
-def _combine_words(words: List[str], max_length: int, max_label_lines: int) -> str:
-    """Combine words to fit within the max_length and max_label_lines constraints,
-    and separate the final output by ':' for plotting.
+def _combine_words(words: List[str], max_chars_per_line: int, max_label_lines: int) -> str:
+    """Combine words to fit within the max_chars_per_line and max_label_lines constraints,
+    and separate the final output by TERM_DELIMITER for plotting.
 
     Args:
         words (List[str]): List of words to combine.
-        max_length (int): Maximum allowed length for a combined line.
+        max_chars_per_line (int): Maximum number of characters in a line to display.
         max_label_lines (int): Maximum number of lines in a label.
 
     Returns:
@@ -1510,14 +1608,18 @@ def _combine_words(words: List[str], max_length: int, max_label_lines: int) -> s
             # Try to combine more words if possible, and ensure the combination fits within max_length
             for j in range(i + 1, len(words_batch)):
                 next_word = words_batch[j]
-                if len(combined_word) + len(next_word) + 2 <= max_length:  # +2 for ', '
+                # Ensure that the combined word fits within the max_chars_per_line limit
+                if len(combined_word) + len(next_word) + 1 <= max_chars_per_line:  # +1 for space
                     combined_word = f"{combined_word} {next_word}"
                     i += 1  # Move past the combined word
                 else:
                     break  # Stop combining if the length is exceeded
 
-            combined_lines.append(combined_word)  # Add the combined word or single word
-            i += 1  # Move to the next word
+            # Add the combined word only if it fits within the max_chars_per_line limit
+            if len(combined_word) <= max_chars_per_line:
+                combined_lines.append(combined_word)  # Add the combined word
+            # Move to the next word
+            i += 1
 
             # Stop if we've reached the max_label_lines limit
             if len(combined_lines) >= max_label_lines:

{risk_network-0.0.8b3 → risk_network-0.0.8b5}/risk_network.egg-info/PKG-INFO

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