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

risk/network/graph.py

@@ -15,9 +15,9 @@ class NetworkGraph:
     """A class to represent a network graph and process its nodes and edges.
 
     The NetworkGraph class provides functionality to handle and manipulate a network graph,
-    including managing domains, annotations, and node enrichment data. It also includes methods
+    including managing domains, annotations, and node significance data. It also includes methods
     for transforming and mapping graph coordinates, as well as generating colors based on node
-    enrichment.
+    significance.
     """
 
     def __init__(
@@ -27,7 +27,7 @@ class NetworkGraph:
         domains: pd.DataFrame,
         trimmed_domains: pd.DataFrame,
         node_label_to_node_id_map: Dict[str, Any],
-        node_enrichment_sums: np.ndarray,
+        node_significance_sums: np.ndarray,
     ):
         """Initialize the NetworkGraph object.
 
@@ -37,7 +37,7 @@ class NetworkGraph:
             domains (pd.DataFrame): DataFrame containing domain data for the network nodes.
             trimmed_domains (pd.DataFrame): DataFrame containing trimmed domain data for the network nodes.
             node_label_to_node_id_map (Dict[str, Any]): A dictionary mapping node labels to their corresponding IDs.
-            node_enrichment_sums (np.ndarray): Array containing the enrichment sums for the nodes.
+            node_significance_sums (np.ndarray): Array containing the significant sums for the nodes.
         """
         self.top_annotations = top_annotations
         self.domain_id_to_node_ids_map = self._create_domain_id_to_node_ids_map(domains)
@@ -49,13 +49,13 @@ class NetworkGraph:
             trimmed_domains
         )
         self.trimmed_domains = trimmed_domains
-        self.node_enrichment_sums = node_enrichment_sums
-        self.node_id_to_domain_ids_and_enrichments_map = (
-            self._create_node_id_to_domain_ids_and_enrichments(domains)
+        self.node_significance_sums = node_significance_sums
+        self.node_id_to_domain_ids_and_significance_map = (
+            self._create_node_id_to_domain_ids_and_significances(domains)
         )
         self.node_id_to_node_label_map = {v: k for k, v in node_label_to_node_id_map.items()}
-        self.node_label_to_enrichment_map = dict(
-            zip(node_label_to_node_id_map.keys(), node_enrichment_sums)
+        self.node_label_to_significance_map = dict(
+            zip(node_label_to_node_id_map.keys(), node_significance_sums)
         )
         self.node_label_to_node_id_map = node_label_to_node_id_map
         # NOTE: Below this point, instance attributes (i.e., self) will be used!
@@ -103,25 +103,25 @@ class NetworkGraph:
     def _create_domain_id_to_domain_info_map(
         trimmed_domains: pd.DataFrame,
     ) -> Dict[int, Dict[str, Any]]:
-        """Create a mapping from domain IDs to their corresponding full description and enrichment score.
+        """Create a mapping from domain IDs to their corresponding full description and significance score.
 
         Args:
-            trimmed_domains (pd.DataFrame): DataFrame containing domain IDs, full descriptions, and enrichment scores.
+            trimmed_domains (pd.DataFrame): DataFrame containing domain IDs, full descriptions, and significance scores.
 
         Returns:
-            Dict[int, Dict[str, Any]]: A dictionary mapping domain IDs (int) to a dictionary with 'full_descriptions' and 'enrichment_scores'.
+            Dict[int, Dict[str, Any]]: A dictionary mapping domain IDs (int) to a dictionary with 'full_descriptions' and 'significance_scores'.
         """
         return {
             int(id_): {
                 "full_descriptions": trimmed_domains.at[id_, "full_descriptions"],
-                "enrichment_scores": trimmed_domains.at[id_, "enrichment_scores"],
+                "significance_scores": trimmed_domains.at[id_, "significance_scores"],
             }
             for id_ in trimmed_domains.index
         }
 
     @staticmethod
-    def _create_node_id_to_domain_ids_and_enrichments(domains: pd.DataFrame) -> Dict[int, Dict]:
-        """Creates a dictionary mapping each node ID to its corresponding domain IDs and enrichment values.
+    def _create_node_id_to_domain_ids_and_significances(domains: pd.DataFrame) -> Dict[int, Dict]:
+        """Creates a dictionary mapping each node ID to its corresponding domain IDs and significance values.
 
         Args:
             domains (pd.DataFrame): A DataFrame containing domain information for each node. Assumes the last
@@ -129,28 +129,28 @@ class NetworkGraph:
 
         Returns:
             Dict[int, Dict]: A dictionary where the key is the node ID (index of the DataFrame), and the value is another dictionary
-                with 'domain' (a list of domain IDs with non-zero enrichment) and 'enrichment'
-                (a dict of domain IDs and their corresponding enrichment values).
+                with 'domain' (a list of domain IDs with non-zero significance) and 'significance'
+                (a dict of domain IDs and their corresponding significance values).
         """
         # Initialize an empty dictionary to store the result
-        node_id_to_domain_ids_and_enrichments = {}
+        node_id_to_domain_ids_and_significances = {}
         # Get the list of domain columns (excluding 'all domains' and 'primary domain')
         domain_columns = domains.columns[
             :-2
         ]  # The last two columns are 'all domains' and 'primary domain'
         # Iterate over each row in the dataframe
         for idx, row in domains.iterrows():
-            # Get the domains (column names) where the enrichment score is greater than 0
+            # Get the domains (column names) where the significance score is greater than 0
             all_domains = domain_columns[row[domain_columns] > 0].tolist()
-            # Get the enrichment values for those domains
-            enrichment_values = row[all_domains].to_dict()
+            # Get the significance values for those domains
+            significance_values = row[all_domains].to_dict()
             # Store the result in the dictionary with index as the key
-            node_id_to_domain_ids_and_enrichments[idx] = {
-                "domains": all_domains,  # The column names where enrichment > 0
-                "enrichments": enrichment_values,  # The actual enrichment values for those columns
+            node_id_to_domain_ids_and_significances[idx] = {
+                "domains": all_domains,  # The column names where significance > 0
+                "significances": significance_values,  # The actual significance values for those columns
             }
 
-        return node_id_to_domain_ids_and_enrichments
+        return node_id_to_domain_ids_and_significances
 
     def _create_domain_id_to_node_labels_map(self) -> Dict[int, List[str]]:
         """Create a map from domain IDs to node labels.

risk/network/plot/canvas.py

@@ -36,6 +36,7 @@ class Canvas:
         font: str = "Arial",
         title_color: Union[str, List, Tuple, np.ndarray] = "black",
         subtitle_color: Union[str, List, Tuple, np.ndarray] = "gray",
+        title_x: float = 0.5,
         title_y: float = 0.975,
         title_space_offset: float = 0.075,
         subtitle_offset: float = 0.025,
@@ -52,6 +53,7 @@ class Canvas:
                 Defaults to "black".
             subtitle_color (str, List, Tuple, or np.ndarray, optional): Color of the subtitle text. Can be a string or an array of colors.
                 Defaults to "gray".
+            title_x (float, optional): X-axis position of the title. Defaults to 0.5.
             title_y (float, optional): Y-axis position of the title. Defaults to 0.975.
             title_space_offset (float, optional): Fraction of figure height to leave for the space above the plot. Defaults to 0.075.
             subtitle_offset (float, optional): Offset factor to position the subtitle below the title. Defaults to 0.025.
@@ -85,7 +87,7 @@ class Canvas:
                 fontsize=title_fontsize,
                 color=title_color,
                 fontname=font,
-                x=0.5,  # Center the title horizontally
+                x=title_x,
                 ha="center",
                 va="top",
                 y=title_y,

risk/network/plot/contour.py

@@ -294,7 +294,7 @@ class Contour:
                 Controls the dimmest colors. Defaults to 0.8.
             max_scale (float, optional): Maximum intensity scale for the colors generated by the colormap.
                 Controls the brightest colors. Defaults to 1.0.
-            scale_factor (float, optional): Exponent for adjusting color scaling based on enrichment scores.
+            scale_factor (float, optional): Exponent for adjusting color scaling based on significance scores.
                 A higher value increases contrast by dimming lower scores more. Defaults to 1.0.
             random_seed (int, optional): Seed for random number generation to ensure reproducibility. Defaults to 888.
 

risk/network/plot/labels.py

@@ -659,7 +659,7 @@ class Labels:
                 Controls the dimmest colors. Defaults to 0.8.
             max_scale (float, optional): Maximum intensity scale for the colors generated by the colormap.
                 Controls the brightest colors. Defaults to 1.0.
-            scale_factor (float, optional): Exponent for adjusting color scaling based on enrichment scores.
+            scale_factor (float, optional): Exponent for adjusting color scaling based on significance scores.
                 A higher value increases contrast by dimming lower scores more. Defaults to 1.0.
             random_seed (int, optional): Seed for random number generation to ensure reproducibility. Defaults to 888.
 

risk/network/plot/network.py

@@ -203,11 +203,11 @@ class Network:
         max_scale: float = 1.0,
         scale_factor: float = 1.0,
         alpha: Union[float, None] = 1.0,
-        nonenriched_color: Union[str, List, Tuple, np.ndarray] = "white",
-        nonenriched_alpha: Union[float, None] = 1.0,
+        nonsignificant_color: Union[str, List, Tuple, np.ndarray] = "white",
+        nonsignificant_alpha: Union[float, None] = 1.0,
         random_seed: int = 888,
     ) -> np.ndarray:
-        """Adjust the colors of nodes in the network graph based on enrichment.
+        """Adjust the colors of nodes in the network graph based on significance.
 
         Args:
             cmap (str, optional): Colormap to use for coloring the nodes. Defaults to "gist_rainbow".
@@ -218,16 +218,16 @@ class Network:
             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): Factor for adjusting the color scaling intensity. Defaults to 1.0.
-            alpha (float, None, optional): Alpha value for enriched nodes. If provided, it overrides any existing alpha values found in `color`.
+            alpha (float, None, optional): Alpha value for significant nodes. If provided, it overrides any existing alpha values found in `color`.
                 Defaults to 1.0.
-            nonenriched_color (str, List, Tuple, or np.ndarray, optional): Color for non-enriched nodes. Can be a single color or an array of colors.
+            nonsignificant_color (str, List, Tuple, or np.ndarray, optional): Color for non-significant nodes. Can be a single color or an array of colors.
                 Defaults to "white".
-            nonenriched_alpha (float, None, optional): Alpha value for non-enriched nodes. If provided, it overrides any existing alpha values found
-                in `nonenriched_color`. Defaults to 1.0.
+            nonsignificant_alpha (float, None, optional): Alpha value for non-significant nodes. If provided, it overrides any existing alpha values found
+                in `nonsignificant_color`. Defaults to 1.0.
             random_seed (int, optional): Seed for random number generation. Defaults to 888.
 
         Returns:
-            np.ndarray: Array of RGBA colors adjusted for enrichment status.
+            np.ndarray: Array of RGBA colors adjusted for significance status.
         """
         # Get the initial domain colors for each node, which are returned as RGBA
         network_colors = get_domain_colors(
@@ -241,11 +241,11 @@ class Network:
             scale_factor=scale_factor,
             random_seed=random_seed,
         )
-        # 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_rgba = to_rgba(
-            color=nonenriched_color, alpha=nonenriched_alpha, num_repeats=1
+        # Apply the alpha value for significant nodes
+        network_colors[:, 3] = alpha  # Apply the alpha value to the significant nodes' A channel
+        # Convert the non-significant color to RGBA using the to_rgba helper function
+        nonsignificant_color_rgba = to_rgba(
+            color=nonsignificant_color, alpha=nonsignificant_alpha, num_repeats=1
         )  # num_repeats=1 for a single color
         # Adjust node colors: replace any nodes where all three RGB values are equal and less than 0.1
         # 0.1 is a predefined threshold for the minimum color intensity
@@ -255,34 +255,34 @@ class Network:
                 & np.all(network_colors[:, :3] == network_colors[:, 0:1], axis=1)
             )[:, None],
             np.tile(
-                np.array(nonenriched_color_rgba), (network_colors.shape[0], 1)
-            ),  # Replace with the full RGBA non-enriched color
+                np.array(nonsignificant_color_rgba), (network_colors.shape[0], 1)
+            ),  # Replace with the full RGBA non-significant color
             network_colors,  # Keep the original colors where no match is found
         )
         return adjusted_network_colors
 
     def get_annotated_node_sizes(
-        self, enriched_size: int = 50, nonenriched_size: int = 25
+        self, significant_size: int = 50, nonsignificant_size: int = 25
     ) -> np.ndarray:
-        """Adjust the sizes of nodes in the network graph based on whether they are enriched or not.
+        """Adjust the sizes of nodes in the network graph based on whether they are significant or not.
 
         Args:
-            enriched_size (int): Size for enriched nodes. Defaults to 50.
-            nonenriched_size (int): Size for non-enriched nodes. Defaults to 25.
+            significant_size (int): Size for significant nodes. Defaults to 50.
+            nonsignificant_size (int): Size for non-significant nodes. Defaults to 25.
 
         Returns:
-            np.ndarray: Array of node sizes, with enriched nodes larger than non-enriched ones.
+            np.ndarray: Array of node sizes, with significant nodes larger than non-significant ones.
         """
-        # Merge all enriched nodes from the domain_id_to_node_ids_map dictionary
-        enriched_nodes = set()
+        # Merge all significant nodes from the domain_id_to_node_ids_map dictionary
+        significant_nodes = set()
         for _, node_ids in self.graph.domain_id_to_node_ids_map.items():
-            enriched_nodes.update(node_ids)
+            significant_nodes.update(node_ids)
 
-        # Initialize all node sizes to the non-enriched size
-        node_sizes = np.full(len(self.graph.network.nodes), nonenriched_size)
-        # Set the size for enriched nodes
-        for node in enriched_nodes:
+        # Initialize all node sizes to the non-significant size
+        node_sizes = np.full(len(self.graph.network.nodes), nonsignificant_size)
+        # Set the size for significant nodes
+        for node in significant_nodes:
             if node in self.graph.network.nodes:
-                node_sizes[node] = enriched_size
+                node_sizes[node] = significant_size
 
         return node_sizes

risk/network/plot/utils/color.py

@@ -35,14 +35,14 @@ def get_annotated_domain_colors(
         blend_gamma (float, optional): Gamma correction factor for perceptual color blending. Defaults to 2.2.
         min_scale (float, optional): Minimum scale for color intensity when generating domain colors. Defaults to 0.8.
         max_scale (float, optional): Maximum scale for color intensity when generating domain colors. Defaults to 1.0.
-        scale_factor (float, optional): Factor for adjusting the contrast in the colors generated based on enrichment. Higher values
+        scale_factor (float, optional): Factor for adjusting the contrast in the colors generated based on significance. Higher values
             increase the contrast. Defaults to 1.0.
         random_seed (int, optional): Seed for random number generation to ensure reproducibility. Defaults to 888.
 
     Returns:
         np.ndarray: Array of RGBA colors for each domain.
     """
-    # Generate domain colors based on the enrichment data
+    # Generate domain colors based on the significance data
     node_colors = get_domain_colors(
         graph=graph,
         cmap=cmap,
@@ -82,7 +82,7 @@ def get_domain_colors(
     scale_factor: float = 1.0,
     random_seed: int = 888,
 ) -> np.ndarray:
-    """Generate composite colors for domains based on enrichment or specified colors.
+    """Generate composite colors for domains based on significance or specified colors.
 
     Args:
         graph (NetworkGraph): The network data and attributes to be visualized.
@@ -95,12 +95,12 @@ def get_domain_colors(
             Defaults to 0.8.
         max_scale (float, optional): Maximum intensity scale for the colors generated by the colormap. Controls the brightest colors.
             Defaults to 1.0.
-        scale_factor (float, optional): Exponent for adjusting the color scaling based on enrichment scores. Higher values increase
+        scale_factor (float, optional): Exponent for adjusting the color scaling based on significance scores. Higher values increase
             contrast by dimming lower scores more. Defaults to 1.0.
         random_seed (int, optional): Seed for random number generation to ensure reproducibility of color assignments. Defaults to 888.
 
     Returns:
-        np.ndarray: Array of RGBA colors generated for each domain, based on enrichment or the specified color.
+        np.ndarray: Array of RGBA colors generated for each domain, based on significance or the specified color.
     """
     # Get colors for each domain
     domain_colors = _get_domain_colors(graph=graph, cmap=cmap, color=color, random_seed=random_seed)
@@ -111,7 +111,7 @@ def get_domain_colors(
     # Transform colors to ensure proper alpha values and intensity
     transformed_colors = _transform_colors(
         node_colors,
-        graph.node_enrichment_sums,
+        graph.node_significance_sums,
         min_scale=min_scale,
         max_scale=max_scale,
         scale_factor=scale_factor,
@@ -151,7 +151,7 @@ def _get_domain_colors(
 def _get_composite_node_colors(
     graph, domain_colors: np.ndarray, blend_colors: bool = False, blend_gamma: float = 2.2
 ) -> np.ndarray:
-    """Generate composite colors for nodes based on domain colors and enrichment values, with optional color blending.
+    """Generate composite colors for nodes based on domain colors and significance values, with optional color blending.
 
     Args:
         graph (NetworkGraph): The network data and attributes to be visualized.
@@ -177,26 +177,26 @@ def _get_composite_node_colors(
 
     # If blending is required
     else:
-        for node, node_info in graph.node_id_to_domain_ids_and_enrichments_map.items():
+        for node, node_info in graph.node_id_to_domain_ids_and_significance_map.items():
             domains = node_info["domains"]  # List of domain IDs
-            enrichments = node_info["enrichments"]  # List of enrichment values
-            # Filter domains and enrichments to keep only those with corresponding colors in domain_colors
-            filtered_domains_enrichments = [
-                (domain_id, enrichment)
-                for domain_id, enrichment in zip(domains, enrichments)
+            significances = node_info["significances"]  # List of significance values
+            # Filter domains and significances to keep only those with corresponding colors in domain_colors
+            filtered_domains_significances = [
+                (domain_id, significance)
+                for domain_id, significance in zip(domains, significances)
                 if domain_id in domain_colors
             ]
             # If no valid domains exist, skip this node
-            if not filtered_domains_enrichments:
+            if not filtered_domains_significances:
                 continue
 
-            # Unpack filtered domains and enrichments
-            filtered_domains, filtered_enrichments = zip(*filtered_domains_enrichments)
+            # Unpack filtered domains and significances
+            filtered_domains, filtered_significances = zip(*filtered_domains_significances)
             # Get the colors corresponding to the valid filtered domains
             colors = [domain_colors[domain_id] for domain_id in filtered_domains]
             # Blend the colors using the given gamma (default is 2.2 if None)
             gamma = blend_gamma if blend_gamma is not None else 2.2
-            composite_color = _blend_colors_perceptually(colors, filtered_enrichments, gamma)
+            composite_color = _blend_colors_perceptually(colors, filtered_significances, gamma)
             # Assign the composite color to the node
             composite_colors[node] = composite_color
 
@@ -282,21 +282,21 @@ def _assign_distant_colors(dist_matrix, num_colors_to_generate):
 
 
 def _blend_colors_perceptually(
-    colors: Union[List, Tuple, np.ndarray], enrichments: List[float], gamma: float = 2.2
+    colors: Union[List, Tuple, np.ndarray], significances: List[float], gamma: float = 2.2
 ) -> Tuple[float, float, float, float]:
     """Blends a list of RGBA colors using gamma correction for perceptually uniform color mixing.
 
     Args:
         colors (List, Tuple, np.ndarray): List of RGBA colors. Can be a list, tuple, or NumPy array of RGBA values.
-        enrichments (List[float]): Corresponding list of enrichment values.
+        significances (List[float]): Corresponding list of significance values.
         gamma (float, optional): Gamma correction factor, default is 2.2 (typical for perceptual blending).
 
     Returns:
         Tuple[float, float, float, float]: The blended RGBA color.
     """
-    # Normalize enrichments so they sum up to 1 (proportions)
-    total_enrichment = sum(enrichments)
-    proportions = [enrichment / total_enrichment for enrichment in enrichments]
+    # Normalize significances so they sum up to 1 (proportions)
+    total_significance = sum(significances)
+    proportions = [significance / total_significance for significance in significances]
     # Convert colors to gamma-corrected space (apply gamma correction to RGB channels)
     gamma_corrected_colors = [[channel**gamma for channel in color[:3]] for color in colors]
     # Blend the colors in gamma-corrected space
@@ -310,17 +310,17 @@ def _blend_colors_perceptually(
 
 def _transform_colors(
     colors: np.ndarray,
-    enrichment_sums: np.ndarray,
+    significance_sums: np.ndarray,
     min_scale: float = 0.8,
     max_scale: float = 1.0,
     scale_factor: float = 1.0,
 ) -> np.ndarray:
-    """Transform colors using power scaling to emphasize high enrichment sums more. Black colors are replaced with
+    """Transform colors using power scaling to emphasize high significance sums more. Black colors are replaced with
     very dark grey to avoid issues with color scaling (rgb(0.1, 0.1, 0.1)).
 
     Args:
         colors (np.ndarray): An array of RGBA colors.
-        enrichment_sums (np.ndarray): An array of enrichment sums corresponding to the colors.
+        significance_sums (np.ndarray): An array of significance 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
@@ -340,8 +340,8 @@ def _transform_colors(
     is_black = np.all(colors[:, :3] == black_color, axis=1)
     colors[is_black, :3] = dark_grey
 
-    # Normalize the enrichment sums to the range [0, 1]
-    normalized_sums = enrichment_sums / np.max(enrichment_sums)
+    # Normalize the significance sums to the range [0, 1]
+    normalized_sums = significance_sums / np.max(significance_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]

risk/risk.py

@@ -259,9 +259,9 @@ class RISK(NetworkIO, AnnotationsIO):
         network: nx.Graph,
         annotations: Dict[str, Any],
         neighborhoods: Dict[str, Any],
-        tail: str = "right",  # OPTIONS: "right" (enrichment), "left" (depletion), "both"
-        pval_cutoff: float = 0.01,  # OPTIONS: Any value between 0 to 1
-        fdr_cutoff: float = 0.9999,  # OPTIONS: Any value between 0 to 1
+        tail: str = "right",
+        pval_cutoff: float = 0.01,
+        fdr_cutoff: float = 0.9999,
         impute_depth: int = 0,
         prune_threshold: float = 0.0,
         linkage_criterion: str = "distance",
@@ -275,7 +275,7 @@ class RISK(NetworkIO, AnnotationsIO):
         Args:
             network (nx.Graph): The network graph.
             annotations (pd.DataFrame): DataFrame containing annotation data for the network.
-            neighborhoods (Dict[str, Any]): Neighborhood enrichment data.
+            neighborhoods (Dict[str, Any]): Neighborhood significance data.
             tail (str, optional): Type of significance tail ("right", "left", "both"). Defaults to "right".
             pval_cutoff (float, optional): p-value cutoff for significance. Defaults to 0.01.
             fdr_cutoff (float, optional): FDR cutoff for significance. Defaults to 0.9999.
@@ -360,10 +360,10 @@ class RISK(NetworkIO, AnnotationsIO):
             max_cluster_size=max_cluster_size,
         )
 
-        # Prepare node mapping and enrichment sums for the final NetworkGraph object
+        # Prepare node mapping and significance sums for the final NetworkGraph object
         ordered_nodes = annotations["ordered_nodes"]
         node_label_to_id = dict(zip(ordered_nodes, range(len(ordered_nodes))))
-        node_enrichment_sums = processed_neighborhoods["node_enrichment_sums"]
+        node_significance_sums = processed_neighborhoods["node_significance_sums"]
 
         # Return the fully initialized NetworkGraph object
         return NetworkGraph(
@@ -372,7 +372,7 @@ class RISK(NetworkIO, AnnotationsIO):
             domains=domains,
             trimmed_domains=trimmed_domains,
             node_label_to_node_id_map=node_label_to_id,
-            node_enrichment_sums=node_enrichment_sums,
+            node_significance_sums=node_significance_sums,
         )
 
     def load_plotter(
@@ -467,7 +467,7 @@ class RISK(NetworkIO, AnnotationsIO):
         Args:
             network (nx.Graph): The network graph.
             annotations (Dict[str, Any]): Annotations data for the network.
-            neighborhoods (Dict[str, Any]): Neighborhood enrichment data.
+            neighborhoods (Dict[str, Any]): Neighborhood significance data.
             min_cluster_size (int, optional): Minimum size for clusters. Defaults to 5.
             max_cluster_size (int, optional): Maximum size for clusters. Defaults to 1000.
 
@@ -476,16 +476,18 @@ class RISK(NetworkIO, AnnotationsIO):
         """
         # Extract necessary data from annotations and neighborhoods
         ordered_annotations = annotations["ordered_annotations"]
-        neighborhood_enrichment_sums = neighborhoods["neighborhood_enrichment_counts"]
-        significant_enrichment_matrix = neighborhoods["significant_enrichment_matrix"]
-        significant_binary_enrichment_matrix = neighborhoods["significant_binary_enrichment_matrix"]
+        neighborhood_significance_sums = neighborhoods["neighborhood_significance_counts"]
+        significant_significance_matrix = neighborhoods["significant_significance_matrix"]
+        significant_binary_significance_matrix = neighborhoods[
+            "significant_binary_significance_matrix"
+        ]
         # Call external function to define top annotations
         return define_top_annotations(
             network=network,
             ordered_annotation_labels=ordered_annotations,
-            neighborhood_enrichment_sums=neighborhood_enrichment_sums,
-            significant_enrichment_matrix=significant_enrichment_matrix,
-            significant_binary_enrichment_matrix=significant_binary_enrichment_matrix,
+            neighborhood_significance_sums=neighborhood_significance_sums,
+            significant_significance_matrix=significant_significance_matrix,
+            significant_binary_significance_matrix=significant_binary_significance_matrix,
             min_cluster_size=min_cluster_size,
             max_cluster_size=max_cluster_size,
         )
@@ -498,7 +500,7 @@ class RISK(NetworkIO, AnnotationsIO):
         linkage_method: str,
         linkage_metric: str,
     ) -> pd.DataFrame:
-        """Define domains in the network based on enrichment data.
+        """Define domains in the network based on significance data.
 
         Args:
             neighborhoods (Dict[str, Any]): Enrichment data for neighborhoods.
@@ -510,12 +512,12 @@ class RISK(NetworkIO, AnnotationsIO):
         Returns:
             pd.DataFrame: Matrix of defined domains.
         """
-        # Extract the significant enrichment matrix from the neighborhoods data
-        significant_neighborhoods_enrichment = neighborhoods["significant_enrichment_matrix"]
+        # Extract the significant significance matrix from the neighborhoods data
+        significant_neighborhoods_significance = neighborhoods["significant_significance_matrix"]
         # Call external function to define domains based on the extracted data
         return define_domains(
             top_annotations=top_annotations,
-            significant_neighborhoods_enrichment=significant_neighborhoods_enrichment,
+            significant_neighborhoods_significance=significant_neighborhoods_significance,
             linkage_criterion=linkage_criterion,
             linkage_method=linkage_method,
             linkage_metric=linkage_metric,

risk/stats/stats.py

@@ -44,7 +44,7 @@ def calculate_significance_matrices(
             enrichment_pvals, enrichment_qvals, pval_cutoff=pval_cutoff, fdr_cutoff=fdr_cutoff
         )
         # Compute the enrichment matrix using both q-values and p-values
-        enrichment_matrix = (enrichment_qvals**2) * (enrichment_pvals**0.5)
+        enrichment_matrix = (enrichment_pvals**0.5) * (enrichment_qvals**2)
     else:
         # Compute threshold matrices based on p-value cutoffs only
         depletion_alpha_threshold_matrix = _compute_threshold_matrix(
@@ -62,7 +62,7 @@ def calculate_significance_matrices(
     log_enrichment_matrix = -np.log10(enrichment_matrix)
 
     # Select the appropriate significance matrices based on the specified tail
-    enrichment_matrix, significant_binary_enrichment_matrix = _select_significance_matrices(
+    significance_matrix, significant_binary_significance_matrix = _select_significance_matrices(
         tail,
         log_depletion_matrix,
         depletion_alpha_threshold_matrix,
@@ -71,14 +71,14 @@ def calculate_significance_matrices(
     )
 
     # Filter the enrichment matrix using the binary significance matrix
-    significant_enrichment_matrix = np.where(
-        significant_binary_enrichment_matrix == 1, enrichment_matrix, 0
+    significant_significance_matrix = np.where(
+        significant_binary_significance_matrix == 1, significance_matrix, 0
     )
 
     return {
-        "enrichment_matrix": enrichment_matrix,
-        "significant_binary_enrichment_matrix": significant_binary_enrichment_matrix,
-        "significant_enrichment_matrix": significant_enrichment_matrix,
+        "significance_matrix": significance_matrix,
+        "significant_significance_matrix": significant_significance_matrix,
+        "significant_binary_significance_matrix": significant_binary_significance_matrix,
     }
 
 
@@ -109,15 +109,15 @@ def _select_significance_matrices(
 
     if tail == "left":
         # Select depletion matrix and corresponding alpha threshold for left-tail analysis
-        enrichment_matrix = -log_depletion_matrix
+        significance_matrix = -log_depletion_matrix
         alpha_threshold_matrix = depletion_alpha_threshold_matrix
     elif tail == "right":
         # Select enrichment matrix and corresponding alpha threshold for right-tail analysis
-        enrichment_matrix = log_enrichment_matrix
+        significance_matrix = log_enrichment_matrix
         alpha_threshold_matrix = enrichment_alpha_threshold_matrix
     elif tail == "both":
         # Select the matrix with the highest absolute values while preserving the sign
-        enrichment_matrix = np.where(
+        significance_matrix = np.where(
             np.abs(log_depletion_matrix) >= np.abs(log_enrichment_matrix),
             -log_depletion_matrix,
             log_enrichment_matrix,
@@ -129,10 +129,10 @@ def _select_significance_matrices(
 
     # Create a binary significance matrix where valid indices meet the alpha threshold
     valid_idxs = ~np.isnan(alpha_threshold_matrix)
-    significant_binary_enrichment_matrix = np.zeros(alpha_threshold_matrix.shape)
-    significant_binary_enrichment_matrix[valid_idxs] = alpha_threshold_matrix[valid_idxs]
+    significant_binary_significance_matrix = np.zeros(alpha_threshold_matrix.shape)
+    significant_binary_significance_matrix[valid_idxs] = alpha_threshold_matrix[valid_idxs]
 
-    return enrichment_matrix, significant_binary_enrichment_matrix
+    return significance_matrix, significant_binary_significance_matrix
 
 
 def _compute_threshold_matrix(

{risk_network-0.0.8b26.dist-info → risk_network-0.0.9b1.dist-info}/METADATA

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