risk-network 0.0.7b11__py3-none-any.whl → 0.0.8__py3-none-any.whl

risk/risk.py

@@ -3,7 +3,8 @@ risk/risk
 ~~~~~~~~~
 """
 
-from typing import Any, Dict, Tuple
+import copy
+from typing import Any, Dict, List, Tuple, Union
 
 import networkx as nx
 import numpy as np
@@ -33,24 +34,17 @@ class RISK(NetworkIO, AnnotationsIO):
     and performing network-based statistical analysis, such as neighborhood significance testing.
     """
 
-    def __init__(self, *args, verbose: bool = True, **kwargs):
+    def __init__(self, verbose: bool = True):
         """Initialize the RISK class with configuration settings.
 
         Args:
             verbose (bool): If False, suppresses all log messages to the console. Defaults to True.
-            *args: Variable length argument list.
-            **kwargs: Arbitrary keyword arguments.
-
-        Note:
-            - All *args and **kwargs are passed to NetworkIO's __init__ method.
-            - AnnotationsIO does not take any arguments and is initialized without them.
         """
         # Set global verbosity for logging
         set_global_verbosity(verbose)
         # Initialize and log network parameters
         params.initialize()
-        # Use super() to call NetworkIO's __init__ with the given arguments and keyword arguments
-        super().__init__(*args, **kwargs)
+        super().__init__()
 
     @property
     def params(self) -> params:
@@ -65,9 +59,9 @@ class RISK(NetworkIO, AnnotationsIO):
         self,
         network: nx.Graph,
         annotations: Dict[str, Any],
-        distance_metric: str = "louvain",
+        distance_metric: Union[str, List, Tuple, np.ndarray] = "louvain",
         louvain_resolution: float = 0.1,
-        edge_length_threshold: float = 0.5,
+        edge_length_threshold: Union[float, List, Tuple, np.ndarray] = 0.5,
         null_distribution: str = "network",
         random_seed: int = 888,
     ) -> Dict[str, Any]:
@@ -75,15 +69,19 @@ class RISK(NetworkIO, AnnotationsIO):
 
         Args:
             network (nx.Graph): The network graph.
-            annotations (dict): The annotations associated with the network.
-            distance_metric (str, optional): Distance metric for neighborhood analysis. Defaults to "louvain".
+            annotations (Dict[str, Any]): The annotations associated with the network.
+            distance_metric (str, List, Tuple, or np.ndarray, optional): The distance metric(s) to use. Can be a string for one
+                metric or a list/tuple/ndarray of metrics ('greedy_modularity', 'louvain', 'label_propagation',
+                'markov_clustering', 'walktrap', 'spinglass'). Defaults to 'louvain'.
             louvain_resolution (float, optional): Resolution parameter for Louvain clustering. Defaults to 0.1.
-            edge_length_threshold (float, optional): Edge length threshold for neighborhood analysis. Defaults to 0.5.
+            edge_length_threshold (float, List, Tuple, or np.ndarray, optional): Edge length threshold(s) for creating subgraphs.
+                Can be a single float for one threshold or a list/tuple of floats corresponding to multiple thresholds.
+                Defaults to 0.5.
             null_distribution (str, optional): Type of null distribution ('network' or 'annotations'). Defaults to "network".
             random_seed (int, optional): Seed for random number generation. Defaults to 888.
 
         Returns:
-            dict: Computed significance of neighborhoods.
+            Dict[str, Any]: Computed significance of neighborhoods.
         """
         log_header("Running hypergeometric test")
         # Log neighborhood analysis parameters
@@ -96,6 +94,9 @@ class RISK(NetworkIO, AnnotationsIO):
             random_seed=random_seed,
         )
 
+        # Make a copy of the network to avoid modifying the original
+        network = copy.deepcopy(network)
+
         # Load neighborhoods based on the network and distance metric
         neighborhoods = self._load_neighborhoods(
             network,
@@ -118,9 +119,9 @@ class RISK(NetworkIO, AnnotationsIO):
         self,
         network: nx.Graph,
         annotations: Dict[str, Any],
-        distance_metric: str = "louvain",
+        distance_metric: Union[str, List, Tuple, np.ndarray] = "louvain",
         louvain_resolution: float = 0.1,
-        edge_length_threshold: float = 0.5,
+        edge_length_threshold: Union[float, List, Tuple, np.ndarray] = 0.5,
         null_distribution: str = "network",
         random_seed: int = 888,
     ) -> Dict[str, Any]:
@@ -128,15 +129,19 @@ class RISK(NetworkIO, AnnotationsIO):
 
         Args:
             network (nx.Graph): The network graph.
-            annotations (dict): The annotations associated with the network.
-            distance_metric (str, optional): Distance metric for neighborhood analysis. Defaults to "louvain".
+            annotations (Dict[str, Any]): The annotations associated with the network.
+            distance_metric (str, List, Tuple, or np.ndarray, optional): The distance metric(s) to use. Can be a string for one
+                metric or a list/tuple/ndarray of metrics ('greedy_modularity', 'louvain', 'label_propagation',
+                'markov_clustering', 'walktrap', 'spinglass'). Defaults to 'louvain'.
             louvain_resolution (float, optional): Resolution parameter for Louvain clustering. Defaults to 0.1.
-            edge_length_threshold (float, optional): Edge length threshold for neighborhood analysis. Defaults to 0.5.
+            edge_length_threshold (float, List, Tuple, or np.ndarray, optional): Edge length threshold(s) for creating subgraphs.
+                Can be a single float for one threshold or a list/tuple of floats corresponding to multiple thresholds.
+                Defaults to 0.5.
             null_distribution (str, optional): Type of null distribution ('network' or 'annotations'). Defaults to "network".
             random_seed (int, optional): Seed for random number generation. Defaults to 888.
 
         Returns:
-            dict: Computed significance of neighborhoods.
+            Dict[str, Any]: Computed significance of neighborhoods.
         """
         log_header("Running Poisson test")
         # Log neighborhood analysis parameters
@@ -149,6 +154,9 @@ class RISK(NetworkIO, AnnotationsIO):
             random_seed=random_seed,
         )
 
+        # Make a copy of the network to avoid modifying the original
+        network = copy.deepcopy(network)
+
         # Load neighborhoods based on the network and distance metric
         neighborhoods = self._load_neighborhoods(
             network,
@@ -171,9 +179,9 @@ class RISK(NetworkIO, AnnotationsIO):
         self,
         network: nx.Graph,
         annotations: Dict[str, Any],
-        distance_metric: str = "louvain",
+        distance_metric: Union[str, List, Tuple, np.ndarray] = "louvain",
         louvain_resolution: float = 0.1,
-        edge_length_threshold: float = 0.5,
+        edge_length_threshold: Union[float, List, Tuple, np.ndarray] = 0.5,
         score_metric: str = "sum",
         null_distribution: str = "network",
         num_permutations: int = 1000,
@@ -184,10 +192,14 @@ class RISK(NetworkIO, AnnotationsIO):
 
         Args:
             network (nx.Graph): The network graph.
-            annotations (dict): The annotations associated with the network.
-            distance_metric (str, optional): Distance metric for neighborhood analysis. Defaults to "louvain".
+            annotations (Dict[str, Any]): The annotations associated with the network.
+            distance_metric (str, List, Tuple, or np.ndarray, optional): The distance metric(s) to use. Can be a string for one
+                metric or a list/tuple/ndarray of metrics ('greedy_modularity', 'louvain', 'label_propagation',
+                'markov_clustering', 'walktrap', 'spinglass'). Defaults to 'louvain'.
             louvain_resolution (float, optional): Resolution parameter for Louvain clustering. Defaults to 0.1.
-            edge_length_threshold (float, optional): Edge length threshold for neighborhood analysis. Defaults to 0.5.
+            edge_length_threshold (float, List, Tuple, or np.ndarray, optional): Edge length threshold(s) for creating subgraphs.
+                Can be a single float for one threshold or a list/tuple of floats corresponding to multiple thresholds.
+                Defaults to 0.5.
             score_metric (str, optional): Scoring metric for neighborhood significance. Defaults to "sum".
             null_distribution (str, optional): Type of null distribution ('network' or 'annotations'). Defaults to "network".
             num_permutations (int, optional): Number of permutations for significance testing. Defaults to 1000.
@@ -195,7 +207,7 @@ class RISK(NetworkIO, AnnotationsIO):
             max_workers (int, optional): Maximum number of workers for parallel computation. Defaults to 1.
 
         Returns:
-            dict: Computed significance of neighborhoods.
+            Dict[str, Any]: Computed significance of neighborhoods.
         """
         log_header("Running permutation test")
         # Log neighborhood analysis parameters
@@ -211,6 +223,9 @@ class RISK(NetworkIO, AnnotationsIO):
             max_workers=max_workers,
         )
 
+        # Make a copy of the network to avoid modifying the original
+        network = copy.deepcopy(network)
+
         # Load neighborhoods based on the network and distance metric
         neighborhoods = self._load_neighborhoods(
             network,
@@ -221,10 +236,10 @@ class RISK(NetworkIO, AnnotationsIO):
         )
 
         # Log and display permutation test settings
-        logger.info(f"Neighborhood scoring metric: '{score_metric}'")
-        logger.info(f"Null distribution: '{null_distribution}'")
-        logger.info(f"Number of permutations: {num_permutations}")
-        logger.info(f"Maximum workers: {max_workers}")
+        logger.debug(f"Neighborhood scoring metric: '{score_metric}'")
+        logger.debug(f"Null distribution: '{null_distribution}'")
+        logger.debug(f"Number of permutations: {num_permutations}")
+        logger.debug(f"Maximum workers: {max_workers}")
         # Run permutation test to compute neighborhood significance
         neighborhood_significance = compute_permutation_test(
             neighborhoods=neighborhoods,
@@ -260,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): Neighborhood enrichment data.
+            neighborhoods (Dict[str, Any]): Neighborhood enrichment 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.
@@ -290,9 +305,12 @@ class RISK(NetworkIO, AnnotationsIO):
             max_cluster_size=max_cluster_size,
         )
 
-        logger.info(f"p-value cutoff: {pval_cutoff}")
-        logger.info(f"FDR BH cutoff: {fdr_cutoff}")
-        logger.info(
+        # Make a copy of the network to avoid modifying the original
+        network = copy.deepcopy(network)
+
+        logger.debug(f"p-value cutoff: {pval_cutoff}")
+        logger.debug(f"FDR BH cutoff: {fdr_cutoff}")
+        logger.debug(
             f"Significance tail: '{tail}' ({'enrichment' if tail == 'right' else 'depletion' if tail == 'left' else 'both'})"
         )
         # Calculate significant neighborhoods based on the provided parameters
@@ -314,8 +332,8 @@ class RISK(NetworkIO, AnnotationsIO):
         )
 
         log_header("Finding top annotations")
-        logger.info(f"Min cluster size: {min_cluster_size}")
-        logger.info(f"Max cluster size: {max_cluster_size}")
+        logger.debug(f"Min cluster size: {min_cluster_size}")
+        logger.debug(f"Max cluster size: {max_cluster_size}")
         # Define top annotations based on processed neighborhoods
         top_annotations = self._define_top_annotations(
             network=network,
@@ -360,39 +378,41 @@ class RISK(NetworkIO, AnnotationsIO):
     def load_plotter(
         self,
         graph: NetworkGraph,
-        figsize: Tuple = (10, 10),
+        figsize: Union[List, Tuple, np.ndarray] = (10, 10),
         background_color: str = "white",
+        background_alpha: Union[float, None] = 1.0,
+        pad: float = 0.3,
     ) -> NetworkPlotter:
         """Get a NetworkPlotter object for plotting.
 
         Args:
             graph (NetworkGraph): The graph to plot.
-            figsize (tuple, optional): Size of the figure. Defaults to (10, 10).
+            figsize (List, Tuple, or np.ndarray, optional): Size of the plot. Defaults to (10, 10)., optional): Size of the figure. Defaults to (10, 10).
             background_color (str, optional): Background color of the plot. Defaults to "white".
+            background_alpha (float, None, optional): Transparency level of the background color. If provided, it overrides
+                any existing alpha values found in background_color. Defaults to 1.0.
+            pad (float, optional): Padding value to adjust the axis limits. Defaults to 0.3.
 
         Returns:
             NetworkPlotter: A NetworkPlotter object configured with the given parameters.
         """
         log_header("Loading plotter")
-        # Log the plotter settings
-        params.log_plotter(
-            figsize=figsize,
-            background_color=background_color,
-        )
 
         # Initialize and return a NetworkPlotter object
         return NetworkPlotter(
             graph,
             figsize=figsize,
             background_color=background_color,
+            background_alpha=background_alpha,
+            pad=pad,
         )
 
     def _load_neighborhoods(
         self,
         network: nx.Graph,
-        distance_metric: str = "louvain",
+        distance_metric: Union[str, List, Tuple, np.ndarray] = "louvain",
         louvain_resolution: float = 0.1,
-        edge_length_threshold: float = 0.5,
+        edge_length_threshold: Union[float, List, Tuple, np.ndarray] = 0.5,
         random_seed: int = 888,
     ) -> np.ndarray:
         """Load significant neighborhoods for the network.
@@ -400,9 +420,13 @@ class RISK(NetworkIO, AnnotationsIO):
         Args:
             network (nx.Graph): The network graph.
             annotations (pd.DataFrame): The matrix of annotations associated with the network.
-            distance_metric (str, optional): Distance metric for neighborhood analysis. Defaults to "louvain".
+            distance_metric (str, List, Tuple, or np.ndarray, optional): The distance metric(s) to use. Can be a string for one
+                metric or a list/tuple/ndarray of metrics ('greedy_modularity', 'louvain', 'label_propagation',
+                'markov_clustering', 'walktrap', 'spinglass'). Defaults to 'louvain'.
             louvain_resolution (float, optional): Resolution parameter for Louvain clustering. Defaults to 0.1.
-            edge_length_threshold (float, optional): Edge length threshold for neighborhood analysis. Defaults to 0.5.
+            edge_length_threshold (float, List, Tuple, or np.ndarray, optional): Edge length threshold(s) for creating subgraphs.
+                Can be a single float for one threshold or a list/tuple of floats corresponding to multiple thresholds.
+                Defaults to 0.5.
             random_seed (int, optional): Seed for random number generation. Defaults to 888.
 
         Returns:
@@ -414,9 +438,9 @@ class RISK(NetworkIO, AnnotationsIO):
         else:
             for_print_distance_metric = distance_metric
         # Log and display neighborhood settings
-        logger.info(f"Distance metric: '{for_print_distance_metric}'")
-        logger.info(f"Edge length threshold: {edge_length_threshold}")
-        logger.info(f"Random seed: {random_seed}")
+        logger.debug(f"Distance metric: '{for_print_distance_metric}'")
+        logger.debug(f"Edge length threshold: {edge_length_threshold}")
+        logger.debug(f"Random seed: {random_seed}")
 
         # Compute neighborhoods based on the network and distance metric
         neighborhoods = get_network_neighborhoods(
@@ -442,24 +466,26 @@ class RISK(NetworkIO, AnnotationsIO):
 
         Args:
             network (nx.Graph): The network graph.
-            annotations (dict): Annotations data for the network.
-            neighborhoods (dict): Neighborhood enrichment data.
+            annotations (Dict[str, Any]): Annotations data for the network.
+            neighborhoods (Dict[str, Any]): Neighborhood enrichment 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.
 
         Returns:
-            dict: Top annotations identified within the network.
+            Dict[str, Any]: Top annotations identified within the network.
         """
         # Extract necessary data from annotations and neighborhoods
         ordered_annotations = annotations["ordered_annotations"]
         neighborhood_enrichment_sums = neighborhoods["neighborhood_enrichment_counts"]
-        neighborhoods_binary_enrichment_matrix = neighborhoods["binary_enrichment_matrix"]
+        significant_enrichment_matrix = neighborhoods["significant_enrichment_matrix"]
+        significant_binary_enrichment_matrix = neighborhoods["significant_binary_enrichment_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,
-            binary_enrichment_matrix=neighborhoods_binary_enrichment_matrix,
+            significant_enrichment_matrix=significant_enrichment_matrix,
+            significant_binary_enrichment_matrix=significant_binary_enrichment_matrix,
             min_cluster_size=min_cluster_size,
             max_cluster_size=max_cluster_size,
         )
@@ -475,7 +501,7 @@ class RISK(NetworkIO, AnnotationsIO):
         """Define domains in the network based on enrichment data.
 
         Args:
-            neighborhoods (dict): Enrichment data for neighborhoods.
+            neighborhoods (Dict[str, Any]): Enrichment data for neighborhoods.
             top_annotations (pd.DataFrame): Enrichment matrix for top annotations.
             linkage_criterion (str): Clustering criterion for defining domains.
             linkage_method (str): Clustering method to use.

risk/stats/hypergeom.py

@@ -20,7 +20,7 @@ def compute_hypergeom_test(
         null_distribution (str, optional): Type of null distribution ('network' or 'annotations'). Defaults to "network".
 
     Returns:
-        dict: Dictionary containing depletion and enrichment p-values.
+        Dict[str, Any]: Dictionary containing depletion and enrichment p-values.
     """
     # Get the total number of nodes in the network
     total_node_count = neighborhoods.shape[0]

risk/stats/permutation/permutation.py

@@ -35,7 +35,7 @@ def compute_permutation_test(
         max_workers (int, optional): Number of workers for multiprocessing. Defaults to 1.
 
     Returns:
-        dict: Dictionary containing depletion and enrichment p-values.
+        Dict[str, Any]: Dictionary containing depletion and enrichment p-values.
     """
     # Ensure that the matrices are in the correct format and free of NaN values
     neighborhoods = neighborhoods.astype(np.float32)
@@ -133,6 +133,7 @@ def _run_permutation_test(
                     observed_neighborhood_scores,
                     neighborhood_score_func,
                     subset_size + (1 if i < remainder else 0),
+                    num_permutations,
                     progress_counter,
                     max_workers,
                     rng,  # Pass the random number generator to each worker
@@ -144,11 +145,9 @@ def _run_permutation_test(
             results = pool.starmap_async(_permutation_process_subset, params_list, chunksize=1)
 
             # Update progress bar based on progress_counter
-            # NOTE: Waiting for results to be ready while updating progress bar gives a big improvement
-            # in performance, especially for large number of permutations and workers
             while not results.ready():
                 progress.update(progress_counter.value - progress.n)
-                results.wait(0.05)  # Wait for 50ms
+                results.wait(0.1)  # Wait for 100ms
             # Ensure progress bar reaches 100%
             progress.update(total_progress - progress.n)
 
@@ -167,6 +166,7 @@ def _permutation_process_subset(
     observed_neighborhood_scores: np.ndarray,
     neighborhood_score_func: Callable,
     subset_size: int,
+    num_permutations: int,
     progress_counter: ValueProxy,
     max_workers: int,
     rng: np.random.Generator,
@@ -180,6 +180,7 @@ def _permutation_process_subset(
         observed_neighborhood_scores (np.ndarray): Observed neighborhood scores.
         neighborhood_score_func (Callable): Function to calculate neighborhood scores.
         subset_size (int): Number of permutations to run in this subset.
+        num_permutations (int): Number of total permutations across all subsets.
         progress_counter (multiprocessing.managers.ValueProxy): Shared counter for tracking progress.
         max_workers (int): Number of workers for multiprocessing.
         rng (np.random.Generator): Random number generator object.
@@ -190,11 +191,15 @@ def _permutation_process_subset(
     # Initialize local count matrices for this worker
     local_counts_depletion = np.zeros(observed_neighborhood_scores.shape)
     local_counts_enrichment = np.zeros(observed_neighborhood_scores.shape)
+
     # NOTE: Limit the number of threads used by NumPy's BLAS implementation to 1 when more than one worker is used.
-    # This can help prevent oversubscription of CPU resources during multiprocessing, ensuring that each process
-    # doesn't use more than one CPU core.
     limits = None if max_workers == 1 else 1
     with threadpool_limits(limits=limits, user_api="blas"):
+        # Initialize a local counter for batched progress updates
+        local_progress = 0
+        # Calculate the modulo value based on total permutations for 1/100th frequency updates
+        modulo_value = max(1, num_permutations // 100)
+
         for _ in range(subset_size):
             # Permute the annotation matrix using the RNG
             annotation_matrix_permut = annotation_matrix[rng.permutation(idxs)]
@@ -212,7 +217,15 @@ def _permutation_process_subset(
                 local_counts_enrichment,
                 permuted_neighborhood_scores >= observed_neighborhood_scores,
             )
-            # Update the shared progress counter
-            progress_counter.value += 1
+
+            # Update local progress counter
+            local_progress += 1
+            # Update shared progress counter every 1/100th of total permutations
+            if local_progress % modulo_value == 0:
+                progress_counter.value += modulo_value
+
+        # Final progress update for any remaining iterations
+        if local_progress % modulo_value != 0:
+            progress_counter.value += modulo_value
 
     return local_counts_depletion, local_counts_enrichment

risk/stats/poisson.py

@@ -3,7 +3,7 @@ risk/stats/poisson
 ~~~~~~~~~~~~~~~~~~
 """
 
-from typing import Dict, Any
+from typing import Any, Dict
 
 import numpy as np
 from scipy.stats import poisson
@@ -20,7 +20,7 @@ def compute_poisson_test(
         null_distribution (str, optional): Type of null distribution ('network' or 'annotations'). Defaults to "network".
 
     Returns:
-        dict: Dictionary containing depletion and enrichment p-values.
+        Dict[str, Any]: Dictionary containing depletion and enrichment p-values.
     """
     # Matrix multiplication to get the number of annotated nodes in each neighborhood
     annotated_in_neighborhood = neighborhoods @ annotations

risk/stats/stats.py

@@ -3,7 +3,7 @@ risk/stats/stats
 ~~~~~~~~~~~~~~~~
 """
 
-from typing import Union
+from typing import Any, Dict, Union
 
 import numpy as np
 from statsmodels.stats.multitest import fdrcorrection
@@ -15,7 +15,7 @@ def calculate_significance_matrices(
     tail: str = "right",
     pval_cutoff: float = 0.05,
     fdr_cutoff: float = 0.05,
-) -> dict:
+) -> Dict[str, Any]:
     """Calculate significance matrices based on p-values and specified tail.
 
     Args:
@@ -26,8 +26,8 @@ def calculate_significance_matrices(
         fdr_cutoff (float, optional): Cutoff for FDR significance if applied. Defaults to 0.05.
 
     Returns:
-        dict: Dictionary containing the enrichment matrix, binary significance matrix,
-              and the matrix of significant enrichment values.
+        Dict[str, Any]: Dictionary containing the enrichment matrix, binary significance matrix,
+            and the matrix of significant enrichment values.
     """
     if fdr_cutoff < 1.0:
         # Apply FDR correction to depletion p-values
@@ -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, binary_enrichment_matrix = _select_significance_matrices(
+    enrichment_matrix, significant_binary_enrichment_matrix = _select_significance_matrices(
         tail,
         log_depletion_matrix,
         depletion_alpha_threshold_matrix,
@@ -71,11 +71,13 @@ def calculate_significance_matrices(
     )
 
     # Filter the enrichment matrix using the binary significance matrix
-    significant_enrichment_matrix = np.where(binary_enrichment_matrix == 1, enrichment_matrix, 0)
+    significant_enrichment_matrix = np.where(
+        significant_binary_enrichment_matrix == 1, enrichment_matrix, 0
+    )
 
     return {
         "enrichment_matrix": enrichment_matrix,
-        "binary_enrichment_matrix": binary_enrichment_matrix,
+        "significant_binary_enrichment_matrix": significant_binary_enrichment_matrix,
         "significant_enrichment_matrix": significant_enrichment_matrix,
     }
 
@@ -127,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)
-    binary_enrichment_matrix = np.zeros(alpha_threshold_matrix.shape)
-    binary_enrichment_matrix[valid_idxs] = alpha_threshold_matrix[valid_idxs]
+    significant_binary_enrichment_matrix = np.zeros(alpha_threshold_matrix.shape)
+    significant_binary_enrichment_matrix[valid_idxs] = alpha_threshold_matrix[valid_idxs]
 
-    return enrichment_matrix, binary_enrichment_matrix
+    return enrichment_matrix, significant_binary_enrichment_matrix
 
 
 def _compute_threshold_matrix(

{risk_network-0.0.7b11.dist-info → risk_network-0.0.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: risk-network
-Version: 0.0.7b11
+Version: 0.0.8
 Summary: A Python package for biological network analysis
 Author: Ira Horecka
 Author-email: Ira Horecka <ira89@icloud.com>
@@ -709,42 +709,105 @@ Requires-Dist: statsmodels
 Requires-Dist: threadpoolctl
 Requires-Dist: tqdm
 
-<p align="center">
-  <img src="https://i.imgur.com/Fo9EmnK.png" width="400" />
-</p>
+# RISK Network
 
 <p align="center">
-  <a href="https://pypi.python.org/pypi/risk-network"><img src="https://img.shields.io/pypi/v/risk-network.svg" alt="pypiv"></a>
-  <a href="https://www.python.org/downloads/"><img src="https://img.shields.io/badge/python-3.8+-blue.svg" alt="Python 3.8+"></a>
-  <a href="https://raw.githubusercontent.com/irahorecka/chrono24/main/LICENSE"><img src="https://img.shields.io/badge/License-GPLv3-blue.svg" alt="License: GPL v3"></a>
+  <img src="https://i.imgur.com/8TleEJs.png" width="50%" />
 </p>
 
-## RISK
+<br>
+
+![Python](https://img.shields.io/badge/python-3.8%2B-yellow)
+[![pypiv](https://img.shields.io/pypi/v/risk-network.svg)](https://pypi.python.org/pypi/risk-network)
+![License](https://img.shields.io/badge/license-GPLv3-purple)
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.xxxxxxx.svg)](https://doi.org/10.5281/zenodo.xxxxxxx)
+![Downloads](https://img.shields.io/pypi/dm/risk-network)
+![Platforms](https://img.shields.io/badge/platform-linux%20%7C%20macos%20%7C%20windows-lightgrey)
+
+**RISK (RISK Infers Spatial Kinships)** is a next-generation tool designed to streamline the analysis of biological and non-biological networks. RISK enhances network analysis with its modular architecture, extensive file format support, and advanced clustering algorithms. It simplifies the creation of publication-quality figures, making it an important tool for researchers across disciplines.
 
-#### RISK Infers Spatial Kinships
+## Documentation and Tutorial
+
+- **Documentation**: Comprehensive documentation is available [here](Documentation link).
+- **Tutorial**: An interactive Jupyter notebook tutorial can be found [here](https://github.com/riskportal/network-tutorial).
+We highly recommend new users to consult the documentation and tutorial early on to fully leverage RISK's capabilities.
+
+## Installation
 
-RISK is a software tool for visualizing spatial relationships in networks. It aims to enhance network analysis by integrating advanced network annotation algorithms, such as Louvain and Markov Clustering, to identify key functional modules and pathways.
+RISK is compatible with Python 3.8 and later versions and operates on all major operating systems. Install RISK via pip:
+
+```bash
+pip install risk-network
+```
 
 ## Features
 
-- Spatial analysis of biological networks
-- Functional enrichment detection
-- Optimized performance
+- **Comprehensive Network Analysis**: Analyze biological networks such as protein–protein interaction (PPI) and gene regulatory networks, as well as non-biological networks.
+- **Advanced Clustering Algorithms**: Utilize algorithms like Louvain, Markov Clustering, Spinglass, and more to identify key functional modules.
+- **Flexible Visualization**: Generate clear, publication-quality figures with customizable node and edge attributes, including colors, shapes, sizes, and labels.
+- **Efficient Data Handling**: Optimized for large datasets, supporting multiple file formats such as JSON, CSV, TSV, Excel, Cytoscape, and GPickle.
+- **Statistical Analysis**: Integrated statistical tests, including hypergeometric, permutation, and Poisson tests, to assess the significance of enriched regions.
+- **Cross-Domain Applicability**: Suitable for network analysis across biological and non-biological domains, including social and communication networks.
 
-## Example
+## Example Usage
 
-*Saccharomyces cerevisiae* proteins oriented by physical interactions discovered through affinity enrichment and mass spectrometry (Michaelis et al., 2023).
+We applied RISK to a *Saccharomyces cerevisiae* protein–protein interaction network, revealing both established and novel functional relationships. The visualization below highlights key biological processes such as ribosomal assembly and mitochondrial organization.
 
-![PPI Network Demo](https://i.imgur.com/NnyK6nO.png)
+![RISK Main Figure](https://i.imgur.com/5OP3Hqe.jpeg)
 
-## Installation
+RISK successfully detected both known and novel functional clusters within the yeast interactome. Clusters related to Golgi transport and actin nucleation were clearly defined and closely located, showcasing RISK's ability to map well-characterized interactions. Additionally, RISK identified links between mRNA processing pathways and vesicle trafficking proteins, consistent with recent studies demonstrating the role of vesicles in mRNA localization and stability.
+
+## Citation
+
+If you use RISK in your research, please cite the following:
+
+**Horecka**, *et al.*, "RISK: a next-generation tool for biological network annotation and visualization", **[Journal Name]**, 2024. DOI: [10.1234/zenodo.xxxxxxx](https://doi.org/10.1234/zenodo.xxxxxxx)
+
+## Software Architecture and Implementation
 
-Coming soon...
+RISK features a streamlined, modular architecture designed to meet diverse research needs. Each module focuses on a specific task—such as network input/output, statistical analysis, or visualization—ensuring ease of adaptation and extension. This design enhances flexibility and reduces development overhead for users integrating RISK into their workflows.
 
-## Usage
+### Supported Data Formats
 
-Coming soon...
+- **Input/Output**: JSON, CSV, TSV, Excel, Cytoscape, GPickle.
+- **Visualization Outputs**: SVG, PNG, PDF.
+
+### Clustering Algorithms
+
+- **Available Algorithms**:
+  - Greedy Modularity
+  - Label Propagation
+  - Louvain
+  - Markov Clustering
+  - Spinglass
+  - Walktrap
+- **Distance Metrics**: Supports both spherical and Euclidean distance metrics.
+
+### Statistical Tests
+
+- **Hypergeometric Test**
+- **Permutation Test** (single- or multi-process modes)
+- **Poisson Test**
+
+## Performance and Efficiency
+
+In benchmarking tests using the yeast interactome network, RISK demonstrated substantial improvements over previous tools in both computational performance and memory efficiency. RISK processed the dataset approximately **3.25 times faster**, reducing CPU time by **69%**, and required **25% less peak memory usage**, underscoring its efficient utilization of computational resources.
+
+## Contributing
+
+We welcome contributions from the community. Please use the following resources:
+
+- [Issues Tracker](https://github.com/irahorecka/risk/issues)
+- [Source Code](https://github.com/irahorecka/risk/tree/main/risk)
+
+## Support
+
+If you encounter issues or have suggestions for new features, please use the [Issues Tracker](https://github.com/irahorecka/risk/issues) on GitHub.
 
 ## License
 
-This project is licensed under the GPL-3.0 license.
+RISK is freely available as open-source software under the [GNU General Public License v3.0](https://www.gnu.org/licenses/gpl-3.0.en.html).
+
+---
+
+**Note**: For detailed documentation and to access the interactive tutorial, please visit the links provided in the [Documentation and Tutorial](#documentation-and-tutorial) section.