risk-network 0.0.6b4__tar.gz → 0.0.6b6__tar.gz

{risk_network-0.0.6b4 → risk_network-0.0.6b6}/PKG-INFO

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

{risk_network-0.0.6b4 → risk_network-0.0.6b6}/risk/__init__.py

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

{risk_network-0.0.6b4 → risk_network-0.0.6b6}/risk/network/plot.py

@@ -137,9 +137,7 @@ class NetworkPlotter:
         )
         # Set the transparency of the fill if applicable
         if fill_alpha > 0:
-            circle.set_facecolor(
-                _to_rgba(color, fill_alpha)
-            )  # Use _to_rgba to set the fill color with transparency
+            circle.set_facecolor(_to_rgba(color, fill_alpha))
 
         self.ax.add_artist(circle)
 
@@ -200,7 +198,7 @@ class NetworkPlotter:
             color=color,
             linestyle=linestyle,
             linewidth=linewidth,
-            alpha=fill_alpha,  # Use fill_alpha for the fill
+            alpha=fill_alpha,
         )
 
     def plot_network(
@@ -279,7 +277,7 @@ class NetworkPlotter:
         nodes: List,
         node_size: Union[int, np.ndarray] = 50,
         node_shape: str = "o",
-        node_edgewidth: float = 1.0,  # Added node_edgewidth parameter
+        node_edgewidth: float = 1.0,
         edge_width: float = 1.0,
         node_color: Union[str, List, Tuple, np.ndarray] = "white",
         node_edgecolor: Union[str, List, Tuple, np.ndarray] = "black",
@@ -313,8 +311,8 @@ class NetworkPlotter:
         if not node_ids:
             raise ValueError("No nodes found in the network graph.")
 
-        # If node_color is an array, match its length to the found node_ids
-        if not isinstance(node_color, str):
+        # Check if node_color is a single color or a list of colors
+        if not isinstance(node_color, (str, tuple, np.ndarray)):
             node_color = [
                 node_color[nodes.index(node)]
                 for node in nodes
@@ -325,6 +323,7 @@ class NetworkPlotter:
         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))
+
         # Get the coordinates of the filtered nodes
         node_coordinates = {node_id: self.graph.node_coordinates[node_id] for node_id in node_ids}
 
@@ -358,7 +357,8 @@ class NetworkPlotter:
         color: Union[str, List, Tuple, np.ndarray] = "white",
         linestyle: str = "solid",
         linewidth: float = 1.5,
-        alpha: float = 0.2,
+        alpha: float = 1.0,
+        fill_alpha: float = 0.2,
     ) -> None:
         """Draw KDE contours for nodes in various domains of a network graph, highlighting areas of high density.
 
@@ -369,7 +369,8 @@ class NetworkPlotter:
             color (str, list, tuple, or np.ndarray, optional): Color of the contours. Can be a single color or an array of colors. Defaults to "white".
             linestyle (str, optional): Line style for the contours. Defaults to "solid".
             linewidth (float, optional): Line width for the contours. Defaults to 1.5.
-            alpha (float, optional): Transparency level of the contour fill. Defaults to 0.2.
+            alpha (float, optional): Transparency level of the contour lines. Defaults to 1.0.
+            fill_alpha (float, optional): Transparency level of the contour fill. Defaults to 0.2.
         """
         # Log the contour plotting parameters
         params.log_plotter(
@@ -380,6 +381,7 @@ class NetworkPlotter:
                 "custom" if isinstance(color, np.ndarray) else color
             ),  # np.ndarray usually indicates custom colors
             contour_alpha=alpha,
+            contour_fill_alpha=fill_alpha,
         )
 
         # Ensure color is converted to RGBA with repetition matching the number of domains
@@ -400,6 +402,7 @@ class NetworkPlotter:
                     linestyle=linestyle,
                     linewidth=linewidth,
                     alpha=alpha,
+                    fill_alpha=fill_alpha,
                 )
 
     def plot_subcontour(
@@ -411,7 +414,8 @@ class NetworkPlotter:
         color: Union[str, List, Tuple, np.ndarray] = "white",
         linestyle: str = "solid",
         linewidth: float = 1.5,
-        alpha: float = 0.2,
+        alpha: float = 1.0,
+        fill_alpha: float = 0.2,
     ) -> None:
         """Plot a subcontour for a given set of nodes using Kernel Density Estimation (KDE).
 
@@ -423,7 +427,8 @@ class NetworkPlotter:
             color (str, list, tuple, or np.ndarray, optional): Color of the contour. Can be a string (e.g., 'white') or RGBA array. Defaults to "white".
             linestyle (str, optional): Line style for the contour. Defaults to "solid".
             linewidth (float, optional): Line width for the contour. Defaults to 1.5.
-            alpha (float, optional): Transparency level of the contour fill. Defaults to 0.2.
+            alpha (float, optional): Transparency level of the contour lines. Defaults to 1.0.
+            fill_alpha (float, optional): Transparency level of the contour fill. Defaults to 0.2.
 
         Raises:
             ValueError: If no valid nodes are found in the network graph.
@@ -453,6 +458,7 @@ class NetworkPlotter:
             linestyle=linestyle,
             linewidth=linewidth,
             alpha=alpha,
+            fill_alpha=fill_alpha,
         )
 
     def _draw_kde_contour(
@@ -466,7 +472,8 @@ class NetworkPlotter:
         color: Union[str, np.ndarray] = "white",
         linestyle: str = "solid",
         linewidth: float = 1.5,
-        alpha: float = 0.5,
+        alpha: float = 1.0,
+        fill_alpha: float = 0.2,
     ) -> None:
         """Draw a Kernel Density Estimate (KDE) contour plot for a set of nodes on a given axis.
 
@@ -480,7 +487,8 @@ class NetworkPlotter:
             color (str or np.ndarray): Color for the contour. Can be a string or RGBA array. Defaults to "white".
             linestyle (str, optional): Line style for the contour. Defaults to "solid".
             linewidth (float, optional): Line width for the contour. Defaults to 1.5.
-            alpha (float, optional): Transparency level for the contour fill. Defaults to 0.5.
+            alpha (float, optional): Transparency level for the contour lines. Defaults to 1.0.
+            fill_alpha (float, optional): Transparency level for the contour fill. Defaults to 0.2.
         """
         # Extract the positions of the specified nodes
         points = np.array([pos[n] for n in nodes])
@@ -506,8 +514,8 @@ class NetworkPlotter:
         min_density, max_density = z.min(), z.max()
         contour_levels = np.linspace(min_density, max_density, levels)[1:]
         contour_colors = [color for _ in range(levels - 1)]
-        # Plot the filled contours only if alpha > 0
-        if alpha > 0:
+        # Plot the filled contours using fill_alpha for transparency
+        if fill_alpha > 0:
             ax.contourf(
                 x,
                 y,
@@ -515,10 +523,10 @@ class NetworkPlotter:
                 levels=contour_levels,
                 colors=contour_colors,
                 antialiased=True,
-                alpha=alpha,
+                alpha=fill_alpha,
             )
 
-        # Plot the contour lines without any change in behavior
+        # Plot the contour lines with the specified alpha for transparency
         c = ax.contour(
             x,
             y,
@@ -527,7 +535,9 @@ class NetworkPlotter:
             colors=contour_colors,
             linestyles=linestyle,
             linewidths=linewidth,
+            alpha=alpha,
         )
+        # Set linewidth for the contour lines to 0 for levels other than the base level
         for i in range(1, len(contour_levels)):
             c.collections[i].set_linewidth(0)
 
@@ -540,6 +550,7 @@ class NetworkPlotter:
         fontcolor: Union[str, List, Tuple, np.ndarray] = "black",
         fontalpha: float = 1.0,
         arrow_linewidth: float = 1,
+        arrow_style: str = "->",
         arrow_color: Union[str, List, Tuple, np.ndarray] = "black",
         arrow_alpha: float = 1.0,
         max_labels: Union[int, None] = None,
@@ -547,7 +558,10 @@ class NetworkPlotter:
         min_words: int = 1,
         max_word_length: int = 20,
         min_word_length: int = 1,
-        words_to_omit: Union[List[str], None] = None,
+        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,
     ) -> None:
         """Annotate the network graph with labels for different domains, positioned around the network for clarity.
 
@@ -559,6 +573,7 @@ class NetworkPlotter:
             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, optional): Transparency level for the font color. 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_alpha (float, optional): Transparency level for the arrow color. Defaults to 1.0.
             max_labels (int, optional): Maximum number of labels to plot. Defaults to None (no limit).
@@ -566,7 +581,16 @@ class NetworkPlotter:
             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.
+            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,
+                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 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.
+
+        Raises:
+            ValueError: If the number of provided `ids_to_keep` exceeds `max_labels`.
         """
         # Log the plotting parameters
         params.log_plotter(
@@ -579,6 +603,7 @@ class NetworkPlotter:
             ),  # np.ndarray usually indicates custom colors
             label_fontalpha=fontalpha,
             label_arrow_linewidth=arrow_linewidth,
+            label_arrow_style=arrow_style,
             label_arrow_color="custom" if isinstance(arrow_color, np.ndarray) else arrow_color,
             label_arrow_alpha=arrow_alpha,
             label_max_labels=max_labels,
@@ -587,9 +612,12 @@ class NetworkPlotter:
             label_max_word_length=max_word_length,
             label_min_word_length=min_word_length,
             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,
         )
 
-        # Convert colors to RGBA using the _to_rgba helper function, applying alpha separately for font and arrow
+        # Convert colors to RGBA using the _to_rgba helper function
         fontcolor = _to_rgba(fontcolor, fontalpha, num_repeats=len(self.graph.domain_to_nodes_map))
         arrow_color = _to_rgba(
             arrow_color, arrow_alpha, num_repeats=len(self.graph.domain_to_nodes_map)
@@ -605,55 +633,82 @@ class NetworkPlotter:
             if nodes:  # Skip if the domain has no nodes
                 domain_centroids[domain] = self._calculate_domain_centroid(nodes)
 
-        # Initialize empty lists to collect valid indices
+        # Initialize dictionaries and lists for 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(terms) >= min_words:
-                # Add to filtered_domain_centroids
-                filtered_domain_centroids[domain] = centroid
-                # 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)
-
-        # 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]
+        # Handle the ids_to_keep logic
+        if ids_to_keep:
+            # Check if the number of provided ids_to_keep exceeds max_labels
+            if max_labels is not None and len(ids_to_keep) > max_labels:
+                raise ValueError(
+                    f"Number of provided IDs ({len(ids_to_keep)}) exceeds max_labels ({max_labels})."
+                )
+
+            # Process the specified IDs first
+            for domain in ids_to_keep:
+                if domain in self.graph.trimmed_domain_to_term and domain in domain_centroids:
+                    # Handle ids_to_replace logic here for ids_to_keep
+                    if ids_to_replace and domain in ids_to_replace:
+                        terms = ids_to_replace[domain].split(" ")
+                    else:
+                        terms = self.graph.trimmed_domain_to_term[domain].split(" ")
+
+                    # Apply words_to_omit, word length constraints, and max_words
+                    if words_to_omit:
+                        terms = [term for term in terms if term.lower() not in words_to_omit]
+                    terms = [
+                        term for term in terms if min_word_length <= len(term) <= max_word_length
+                    ]
+                    terms = terms[:max_words]
+
+                    # Check if the domain passes the word count condition
+                    if len(terms) >= min_words:
+                        filtered_domain_centroids[domain] = domain_centroids[domain]
+                        filtered_domain_terms[domain] = " ".join(terms)
+                        valid_indices.append(
+                            list(domain_centroids.keys()).index(domain)
+                        )  # Track the valid index
+
+        # Calculate remaining labels to plot after processing ids_to_keep
+        remaining_labels = (
+            max_labels - len(ids_to_keep) if ids_to_keep and max_labels else max_labels
+        )
+        # Process remaining domains to fill in additional labels, if there are slots left
+        if remaining_labels and remaining_labels > 0:
+            for idx, (domain, centroid) in enumerate(domain_centroids.items()):
+                if ids_to_keep and domain in ids_to_keep:
+                    continue  # Skip domains already handled by ids_to_keep
+
+                # Handle ids_to_replace logic first
+                if ids_to_replace and domain in ids_to_replace:
+                    terms = ids_to_replace[domain].split(" ")
+                else:
+                    terms = self.graph.trimmed_domain_to_term[domain].split(" ")
+
+                # Apply words_to_omit, word length constraints, and max_words
+                if words_to_omit:
+                    terms = [term for term in terms if term.lower() not in words_to_omit]
+
+                terms = [term for term in terms if min_word_length <= len(term) <= max_word_length]
+                terms = terms[:max_words]
+                # Check if the domain passes the word count condition
+                if len(terms) >= min_words:
+                    filtered_domain_centroids[domain] = centroid
+                    filtered_domain_terms[domain] = " ".join(terms)
+                    valid_indices.append(idx)  # Track the valid index
+
+                # Stop once we've reached the max_labels limit
+                if len(filtered_domain_centroids) >= max_labels:
+                    break
 
         # Calculate the bounding box around the network
         center, radius = _calculate_bounding_box(self.graph.node_coordinates, radius_margin=scale)
-        # Calculate the best positions for labels around the perimeter
+        # Calculate the best positions for labels
         best_label_positions = _calculate_best_label_positions(
             filtered_domain_centroids, center, radius, offset
         )
-        # Annotate the network with labels - valid_indices is used for fontcolor and arrow_color
+        # Annotate the network with labels
         for idx, (domain, pos) in zip(valid_indices, best_label_positions.items()):
             centroid = filtered_domain_centroids[domain]
             annotations = filtered_domain_terms[domain].split(" ")[:max_words]
@@ -667,8 +722,23 @@ class NetworkPlotter:
                 fontsize=fontsize,
                 fontname=font,
                 color=fontcolor[idx],
-                arrowprops=dict(arrowstyle="->", color=arrow_color[idx], linewidth=arrow_linewidth),
+                arrowprops=dict(
+                    arrowstyle=arrow_style, color=arrow_color[idx], linewidth=arrow_linewidth
+                ),
             )
+            # Overlay domain ID at the centroid if requested
+            if overlay_ids:
+                self.ax.text(
+                    centroid[0],
+                    centroid[1],
+                    domain,
+                    ha="center",
+                    va="center",
+                    fontsize=fontsize,
+                    fontname=font,
+                    color=fontcolor[idx],
+                    alpha=fontalpha,
+                )
 
     def plot_sublabel(
         self,
@@ -688,7 +758,7 @@ class NetworkPlotter:
         """Annotate the network graph with a single label for the given nodes, positioned at a specified radial angle.
 
         Args:
-            nodes (List[str]): List of node labels to be used for calculating the centroid.
+            nodes (List): List of node labels to be used for calculating the centroid.
             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.
@@ -810,13 +880,13 @@ class NetworkPlotter:
         return adjusted_network_colors
 
     def get_annotated_node_sizes(
-        self, enriched_nodesize: int = 50, nonenriched_nodesize: int = 25
+        self, enriched_size: int = 50, nonenriched_size: int = 25
     ) -> np.ndarray:
         """Adjust the sizes of nodes in the network graph based on whether they are enriched or not.
 
         Args:
-            enriched_nodesize (int): Size for enriched nodes. Defaults to 50.
-            nonenriched_nodesize (int): Size for non-enriched nodes. Defaults to 25.
+            enriched_size (int): Size for enriched nodes. Defaults to 50.
+            nonenriched_size (int): Size for non-enriched nodes. Defaults to 25.
 
         Returns:
             np.ndarray: Array of node sizes, with enriched nodes larger than non-enriched ones.
@@ -827,11 +897,11 @@ class NetworkPlotter:
             enriched_nodes.update(nodes)
 
         # Initialize all node sizes to the non-enriched size
-        node_sizes = np.full(len(self.graph.network.nodes), nonenriched_nodesize)
+        node_sizes = np.full(len(self.graph.network.nodes), nonenriched_size)
         # Set the size for enriched nodes
         for node in enriched_nodes:
             if node in self.graph.network.nodes:
-                node_sizes[node] = enriched_nodesize
+                node_sizes[node] = enriched_size
 
         return node_sizes
 

{risk_network-0.0.6b4 → risk_network-0.0.6b6}/risk_network.egg-info/PKG-INFO

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