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

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

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

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

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

{risk_network-0.0.6b3 → risk_network-0.0.6b5}/risk/annotations/io.py

@@ -153,6 +153,35 @@ class AnnotationsIO:
         # Load the annotations into the provided network
         return load_annotations(network, annotations_input)
 
+    def load_dict_annotation(self, content: Dict[str, Any], network: nx.Graph) -> Dict[str, Any]:
+        """Load annotations from a provided dictionary and convert them to a dictionary annotation.
+
+        Args:
+            content (dict): The annotations dictionary to load.
+            network (NetworkX graph): The network to which the annotations are related.
+
+        Returns:
+            dict: A dictionary containing ordered nodes, ordered annotations, and the annotations matrix.
+        """
+        # Ensure the input content is a dictionary
+        if not isinstance(content, dict):
+            raise TypeError(
+                f"Expected 'content' to be a dictionary, but got {type(content).__name__} instead."
+            )
+
+        filetype = "Dictionary"
+        # Log the loading of the annotations from the dictionary
+        params.log_annotations(filepath="In-memory dictionary", filetype=filetype)
+        _log_loading(filetype, "In-memory dictionary")
+
+        # Load the annotations into the provided network
+        annotations_dict = load_annotations(network, content)
+        # Ensure the output is a dictionary
+        if not isinstance(annotations_dict, dict):
+            raise ValueError("Expected output to be a dictionary")
+
+        return annotations_dict
+
 
 def _load_matrix_file(
     filepath: str,

{risk_network-0.0.6b3 → risk_network-0.0.6b5}/risk/neighborhoods/domains.py

@@ -35,26 +35,31 @@ def define_domains(
     Returns:
         pd.DataFrame: DataFrame with the primary domain for each node.
     """
-    # Perform hierarchical clustering on the binary enrichment matrix
-    m = significant_neighborhoods_enrichment[:, top_annotations["top attributes"]].T
-    best_linkage, best_metric, best_threshold = _optimize_silhouette_across_linkage_and_metrics(
-        m, linkage_criterion, linkage_method, linkage_metric
-    )
-    try:
-        Z = linkage(m, method=best_linkage, metric=best_metric)
-    except ValueError as e:
-        raise ValueError("No significant annotations found.") from e
+    # Check if there's more than one column in significant_neighborhoods_enrichment
+    if significant_neighborhoods_enrichment.shape[1] == 1:
+        print("Single annotation detected. Skipping clustering.")
+        top_annotations["domain"] = 1  # Assign a default domain or handle appropriately
+    else:
+        # Perform hierarchical clustering on the binary enrichment matrix
+        m = significant_neighborhoods_enrichment[:, top_annotations["top attributes"]].T
+        best_linkage, best_metric, best_threshold = _optimize_silhouette_across_linkage_and_metrics(
+            m, linkage_criterion, linkage_method, linkage_metric
+        )
+        try:
+            Z = linkage(m, method=best_linkage, metric=best_metric)
+        except ValueError as e:
+            raise ValueError("No significant annotations found.") from e
 
-    print(
-        f"Linkage criterion: '{linkage_criterion}'\nLinkage method: '{best_linkage}'\nLinkage metric: '{best_metric}'"
-    )
-    print(f"Optimal linkage threshold: {round(best_threshold, 3)}")
+        print(
+            f"Linkage criterion: '{linkage_criterion}'\nLinkage method: '{best_linkage}'\nLinkage metric: '{best_metric}'"
+        )
+        print(f"Optimal linkage threshold: {round(best_threshold, 3)}")
 
-    max_d_optimal = np.max(Z[:, 2]) * best_threshold
-    domains = fcluster(Z, max_d_optimal, criterion=linkage_criterion)
-    # Assign domains to the annotations matrix
-    top_annotations["domain"] = 0
-    top_annotations.loc[top_annotations["top attributes"], "domain"] = domains
+        max_d_optimal = np.max(Z[:, 2]) * best_threshold
+        domains = fcluster(Z, max_d_optimal, criterion=linkage_criterion)
+        # Assign domains to the annotations matrix
+        top_annotations["domain"] = 0
+        top_annotations.loc[top_annotations["top attributes"], "domain"] = domains
 
     # Create DataFrames to store domain information
     node_to_enrichment = pd.DataFrame(
@@ -63,6 +68,7 @@ def define_domains(
     )
     node_to_domain = node_to_enrichment.groupby(level="domain", axis=1).sum()
 
+    # Find the maximum enrichment score for each node
     t_max = node_to_domain.loc[:, 1:].max(axis=1)
     t_idxmax = node_to_domain.loc[:, 1:].idxmax(axis=1)
     t_idxmax[t_max == 0] = 0

{risk_network-0.0.6b3 → risk_network-0.0.6b5}/risk/network/graph.py

@@ -42,12 +42,16 @@ class NetworkGraph:
             node_enrichment_sums (np.ndarray): Array containing the enrichment sums for the nodes.
         """
         self.top_annotations = top_annotations
-        self.domain_to_nodes = self._create_domain_to_nodes_map(domains)
+        self.domain_to_nodes_map = self._create_domain_to_nodes_map(domains)
         self.domains = domains
         self.trimmed_domain_to_term = self._create_domain_to_term_map(trimmed_domains)
         self.trimmed_domains = trimmed_domains
-        self.node_label_to_id_map = node_label_to_id_map
         self.node_enrichment_sums = node_enrichment_sums
+        self.node_id_to_label_map = {v: k for k, v in node_label_to_id_map.items()}
+        self.node_label_to_enrichment_map = dict(
+            zip(node_label_to_id_map.keys(), node_enrichment_sums)
+        )
+        self.node_label_to_id_map = node_label_to_id_map
         # NOTE: self.network and self.node_coordinates are declared in _initialize_network
         self.network = None
         self.node_coordinates = None
@@ -63,12 +67,12 @@ class NetworkGraph:
             dict: A dictionary where keys are domain IDs and values are lists of nodes belonging to each domain.
         """
         cleaned_domains_matrix = domains.reset_index()[["index", "primary domain"]]
-        node_to_domains = cleaned_domains_matrix.set_index("index")["primary domain"].to_dict()
-        domain_to_nodes = defaultdict(list)
-        for k, v in node_to_domains.items():
-            domain_to_nodes[v].append(k)
+        node_to_domains_map = cleaned_domains_matrix.set_index("index")["primary domain"].to_dict()
+        domain_to_nodes_map = defaultdict(list)
+        for k, v in node_to_domains_map.items():
+            domain_to_nodes_map[v].append(k)
 
-        return domain_to_nodes
+        return domain_to_nodes_map
 
     def _create_domain_to_term_map(self, trimmed_domains: pd.DataFrame) -> Dict[str, Any]:
         """Create a mapping from domain IDs to their corresponding terms.
@@ -154,7 +158,7 @@ class NetworkGraph:
         # Initialize composite colors array with shape (number of nodes, 4) for RGBA
         composite_colors = np.zeros((num_nodes, 4))
         # Assign colors to nodes based on domain_colors
-        for domain_idx, nodes in self.domain_to_nodes.items():
+        for domain_idx, nodes in self.domain_to_nodes_map.items():
             color = domain_colors[domain_idx]
             for node in nodes:
                 composite_colors[node] = color
@@ -185,7 +189,7 @@ class NetworkGraph:
         domain_colors = _get_colors(
             num_colors_to_generate=len(domains), cmap=cmap, color=color, random_seed=random_seed
         )
-        return dict(zip(self.domain_to_nodes.keys(), domain_colors))
+        return dict(zip(self.domain_to_nodes_map.keys(), domain_colors))
 
 
 def _transform_colors(

{risk_network-0.0.6b3 → risk_network-0.0.6b5}/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,6 +277,7 @@ class NetworkPlotter:
         nodes: List,
         node_size: Union[int, np.ndarray] = 50,
         node_shape: str = "o",
+        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",
@@ -292,6 +291,7 @@ class NetworkPlotter:
             nodes (list): List of node labels to include in the subnetwork.
             node_size (int or np.ndarray, optional): Size of the nodes. Can be a single integer or an array of sizes. Defaults to 50.
             node_shape (str, optional): Shape of the nodes. Defaults to "o".
+            node_edgewidth (float, optional): Width of the node edges. Defaults to 1.0.
             edge_width (float, optional): Width of the edges. Defaults to 1.0.
             node_color (str, list, tuple, or np.ndarray, optional): Color of the nodes. Can be a single color or an array of colors. Defaults to "white".
             node_edgecolor (str, list, tuple, or np.ndarray, optional): Color of the node edges. Defaults to "black".
@@ -302,7 +302,6 @@ class NetworkPlotter:
         Raises:
             ValueError: If no valid nodes are found in the network graph.
         """
-        # Don't log subnetwork parameters as they are specific to individual annotations
         # Filter to get node IDs and their coordinates
         node_ids = [
             self.graph.node_label_to_id_map.get(node)
@@ -312,10 +311,19 @@ class NetworkPlotter:
         if not node_ids:
             raise ValueError("No nodes found in the network graph.")
 
+        # 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
+                if node in self.graph.node_label_to_id_map
+            ]
+
         # Convert colors to RGBA using the _to_rgba helper function
-        node_color = _to_rgba(node_color, node_alpha)
-        node_edgecolor = _to_rgba(node_edgecolor, 1.0)  # Node edges usually fully opaque
-        edge_color = _to_rgba(edge_color, edge_alpha)
+        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}
 
@@ -328,6 +336,7 @@ class NetworkPlotter:
             node_shape=node_shape,
             node_color=node_color,
             edgecolors=node_edgecolor,
+            linewidths=node_edgewidth,
             ax=self.ax,
         )
         # Draw the edges between the specified nodes in the subnetwork
@@ -348,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.
 
@@ -359,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(
@@ -370,14 +381,15 @@ 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
-        color = _to_rgba(color, alpha, num_repeats=len(self.graph.domain_to_nodes))
+        color = _to_rgba(color, alpha, num_repeats=len(self.graph.domain_to_nodes_map))
         # Extract node coordinates from the network graph
         node_coordinates = self.graph.node_coordinates
         # Draw contours for each domain in the network
-        for idx, (_, nodes) in enumerate(self.graph.domain_to_nodes.items()):
+        for idx, (_, nodes) in enumerate(self.graph.domain_to_nodes_map.items()):
             if len(nodes) > 1:
                 self._draw_kde_contour(
                     self.ax,
@@ -390,6 +402,7 @@ class NetworkPlotter:
                     linestyle=linestyle,
                     linewidth=linewidth,
                     alpha=alpha,
+                    fill_alpha=fill_alpha,
                 )
 
     def plot_subcontour(
@@ -401,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).
 
@@ -413,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.
@@ -443,6 +458,7 @@ class NetworkPlotter:
             linestyle=linestyle,
             linewidth=linewidth,
             alpha=alpha,
+            fill_alpha=fill_alpha,
         )
 
     def _draw_kde_contour(
@@ -456,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.
 
@@ -470,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])
@@ -496,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,
@@ -505,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,
@@ -517,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)
 
@@ -580,9 +600,9 @@ class NetworkPlotter:
         )
 
         # Convert colors to RGBA using the _to_rgba helper function, applying alpha separately for font and arrow
-        fontcolor = _to_rgba(fontcolor, fontalpha, num_repeats=len(self.graph.domain_to_nodes))
+        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)
+            arrow_color, arrow_alpha, num_repeats=len(self.graph.domain_to_nodes_map)
         )
 
         # Normalize words_to_omit to lowercase
@@ -591,7 +611,7 @@ class NetworkPlotter:
 
         # Calculate the center and radius of the network
         domain_centroids = {}
-        for domain, nodes in self.graph.domain_to_nodes.items():
+        for domain, nodes in self.graph.domain_to_nodes_map.items():
             if nodes:  # Skip if the domain has no nodes
                 domain_centroids[domain] = self._calculate_domain_centroid(nodes)
 
@@ -800,28 +820,28 @@ 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.
         """
-        # Merge all enriched nodes from the domain_to_nodes dictionary
+        # Merge all enriched nodes from the domain_to_nodes_map dictionary
         enriched_nodes = set()
-        for _, nodes in self.graph.domain_to_nodes.items():
+        for _, nodes in self.graph.domain_to_nodes_map.items():
             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
 
@@ -928,7 +948,7 @@ class NetworkPlotter:
             random_seed=random_seed,
         )
         annotated_colors = []
-        for _, nodes in self.graph.domain_to_nodes.items():
+        for _, nodes in self.graph.domain_to_nodes_map.items():
             if len(nodes) > 1:
                 # For multi-node domains, choose the brightest color based on RGB sum
                 domain_colors = np.array([node_colors[node] for node in nodes])
@@ -969,33 +989,51 @@ def _to_rgba(
     alpha: float = 1.0,
     num_repeats: Union[int, None] = None,
 ) -> np.ndarray:
-    """Convert a color or array of colors to RGBA format, applying or updating the alpha as needed.
+    """Convert a color or array of colors to RGBA format, applying alpha only if the color is RGB.
 
     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. Defaults to 1.0.
+        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.
 
     Returns:
         np.ndarray: The RGBA color or array of RGBA colors.
     """
-    # Handle single color case
+    # 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]
     ):
-        rgba_color = np.array(mcolors.to_rgba(color, alpha))
-        # Repeat the color if repeat argument is provided
+        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)
 
         return rgba_color
 
-    # Handle array of colors case
-    elif isinstance(color, (list, tuple, np.ndarray)) and isinstance(
-        color[0], (list, tuple, np.ndarray)
-    ):
-        rgba_colors = [mcolors.to_rgba(c, alpha) if len(c) == 3 else np.array(c) for c in color]
-        # Repeat the colors if repeat argument is provided
+    # Handle array of colors case (including strings, RGB, and RGBA)
+    elif isinstance(color, (list, tuple, np.ndarray)):
+        rgba_colors = []
+        for c in 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.")
+
+        # 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)
 

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

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