risk-network 0.0.16b1__py3-none-any.whl → 0.0.16b2__py3-none-any.whl

risk/{_neighborhoods/_stats/_permutation/_permutation.py → stats/_stats/permutation/permutation.py}

@@ -1,6 +1,6 @@
 """
-risk/_neighborhoods/_stats/_permutation/_permutation
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+risk/stats/_stats/permutation/permutation
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
 from multiprocessing import Manager, get_context
@@ -16,7 +16,7 @@ from ._test_functions import DISPATCH_TEST_FUNCTIONS
 
 
 def compute_permutation_test(
-    neighborhoods: csr_matrix,
+    clusters: csr_matrix,
     annotation: csr_matrix,
     score_metric: str = "sum",
     null_distribution: str = "network",
@@ -25,10 +25,10 @@ def compute_permutation_test(
     max_workers: int = 1,
 ) -> Dict[str, Any]:
     """
-    Compute permutation test for enrichment and depletion in neighborhoods.
+    Compute permutation test for enrichment and depletion in clusters.
 
     Args:
-        neighborhoods (csr_matrix): Sparse binary matrix representing neighborhoods.
+        clusters (csr_matrix): Sparse binary matrix representing clusters.
         annotation (csr_matrix): Sparse binary matrix representing annotation.
         score_metric (str, optional): Metric to use for scoring ('sum' or 'stdev'). Defaults to "sum".
         null_distribution (str, optional): Type of null distribution ('network' or 'annotation'). Defaults to "network".
@@ -41,16 +41,16 @@ def compute_permutation_test(
     """
     # Ensure that the matrices are in the correct format and free of NaN values
     # NOTE: Keep the data type as float32 to avoid locking issues with dot product operations
-    neighborhoods = neighborhoods.astype(np.float32)
+    clusters = clusters.astype(np.float32)
     annotation = annotation.astype(np.float32)
-    # Retrieve the appropriate neighborhood score function based on the metric
-    neighborhood_score_func = DISPATCH_TEST_FUNCTIONS[score_metric]
+    # Retrieve the appropriate cluster score function based on the metric
+    cluster_score_func = DISPATCH_TEST_FUNCTIONS[score_metric]
 
     # Run the permutation test to calculate depletion and enrichment counts
     counts_depletion, counts_enrichment = _run_permutation_test(
-        neighborhoods=neighborhoods,
+        clusters=clusters,
         annotation=annotation,
-        neighborhood_score_func=neighborhood_score_func,
+        cluster_score_func=cluster_score_func,
         null_distribution=null_distribution,
         num_permutations=num_permutations,
         random_seed=random_seed,
@@ -68,9 +68,9 @@ def compute_permutation_test(
 
 
 def _run_permutation_test(
-    neighborhoods: csr_matrix,
+    clusters: csr_matrix,
     annotation: csr_matrix,
-    neighborhood_score_func: Callable,
+    cluster_score_func: Callable,
     null_distribution: str = "network",
     num_permutations: int = 1000,
     random_seed: int = 888,
@@ -80,9 +80,9 @@ def _run_permutation_test(
     Run the permutation test to calculate depletion and enrichment counts.
 
     Args:
-        neighborhoods (csr_matrix): Sparse binary matrix representing neighborhoods.
+        clusters (csr_matrix): Sparse binary matrix representing clusters.
         annotation (csr_matrix): Sparse binary matrix representing annotation.
-        neighborhood_score_func (Callable): Function to calculate neighborhood scores.
+        cluster_score_func (Callable): Function to calculate cluster scores.
         null_distribution (str, optional): Type of null distribution ('network' or 'annotation'). Defaults to "network".
         num_permutations (int, optional): Number of permutations. Defaults to 1000.
         random_seed (int, optional): Seed for random number generation. Defaults to 888.
@@ -109,16 +109,14 @@ def _run_permutation_test(
     # Replace NaNs with zeros in the sparse annotation matrix
     annotation.data[np.isnan(annotation.data)] = 0
     annotation_matrix_obsv = annotation[idxs]
-    neighborhoods_matrix_obsv = neighborhoods.T[idxs].T
-    # Calculate observed neighborhood scores
+    clusters_matrix_obsv = clusters.T[idxs].T
+    # Calculate observed cluster scores
     with np.errstate(invalid="ignore", divide="ignore"):
-        observed_neighborhood_scores = neighborhood_score_func(
-            neighborhoods_matrix_obsv, annotation_matrix_obsv
-        )
+        observed_cluster_scores = cluster_score_func(clusters_matrix_obsv, annotation_matrix_obsv)
 
     # Initialize count matrices for depletion and enrichment
-    counts_depletion = np.zeros(observed_neighborhood_scores.shape)
-    counts_enrichment = np.zeros(observed_neighborhood_scores.shape)
+    counts_depletion = np.zeros(observed_cluster_scores.shape)
+    counts_enrichment = np.zeros(observed_cluster_scores.shape)
     # Determine the number of permutations to run in each worker process
     subset_size = num_permutations // max_workers
     remainder = num_permutations % max_workers
@@ -145,9 +143,9 @@ def _run_permutation_test(
                 (
                     permutation_batches[i],  # Pass the batch of precomputed permutations
                     annotation,
-                    neighborhoods_matrix_obsv,
-                    observed_neighborhood_scores,
-                    neighborhood_score_func,
+                    clusters_matrix_obsv,
+                    observed_cluster_scores,
+                    cluster_score_func,
                     num_permutations,
                     progress_counter,
                     max_workers,
@@ -176,9 +174,9 @@ def _run_permutation_test(
 def _permutation_process_batch(
     permutations: Union[List, Tuple, np.ndarray],
     annotation_matrix: csr_matrix,
-    neighborhoods_matrix_obsv: csr_matrix,
-    observed_neighborhood_scores: np.ndarray,
-    neighborhood_score_func: Callable,
+    clusters_matrix_obsv: csr_matrix,
+    observed_cluster_scores: np.ndarray,
+    cluster_score_func: Callable,
     num_permutations: int,
     progress_counter: ValueProxy,
     max_workers: int,
@@ -189,9 +187,9 @@ def _permutation_process_batch(
     Args:
         permutations (Union[List, Tuple, np.ndarray]): Permutation batch to process.
         annotation_matrix (csr_matrix): Sparse binary matrix representing annotation.
-        neighborhoods_matrix_obsv (csr_matrix): Sparse binary matrix representing observed neighborhoods.
-        observed_neighborhood_scores (np.ndarray): Observed neighborhood scores.
-        neighborhood_score_func (Callable): Function to calculate neighborhood scores.
+        clusters_matrix_obsv (csr_matrix): Sparse binary matrix representing observed clusters.
+        observed_cluster_scores (np.ndarray): Observed cluster scores.
+        cluster_score_func (Callable): Function to calculate cluster scores.
         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.
@@ -200,8 +198,8 @@ def _permutation_process_batch(
         tuple: Local counts of depletion and enrichment.
     """
     # 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)
+    local_counts_depletion = np.zeros(observed_cluster_scores.shape)
+    local_counts_enrichment = np.zeros(observed_cluster_scores.shape)
 
     # Limit the number of threads used by NumPy's BLAS implementation to 1 when more than one worker is used
     # NOTE: This does not work for Mac M chips due to a bug in the threadpoolctl package
@@ -216,19 +214,19 @@ def _permutation_process_batch(
         for permuted_idxs in permutations:
             # Apply precomputed permutation
             annotation_matrix_permut = annotation_matrix[permuted_idxs]
-            # Calculate permuted neighborhood scores
+            # Calculate permuted cluster scores
             with np.errstate(invalid="ignore", divide="ignore"):
-                permuted_neighborhood_scores = neighborhood_score_func(
-                    neighborhoods_matrix_obsv, annotation_matrix_permut
+                permuted_cluster_scores = cluster_score_func(
+                    clusters_matrix_obsv, annotation_matrix_permut
                 )
 
             # Update local depletion and enrichment counts
             local_counts_depletion = np.add(
-                local_counts_depletion, permuted_neighborhood_scores <= observed_neighborhood_scores
+                local_counts_depletion, permuted_cluster_scores <= observed_cluster_scores
             )
             local_counts_enrichment = np.add(
                 local_counts_enrichment,
-                permuted_neighborhood_scores >= observed_neighborhood_scores,
+                permuted_cluster_scores >= observed_cluster_scores,
             )
 
             # Update progress

risk/{_neighborhoods/_stats/_tests.py → stats/_stats/tests.py}

@@ -1,25 +1,25 @@
 """
-risk/_neighborhoods/_stats/_tests
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+risk/stats/_stats/tests
+~~~~~~~~~~~~~~~~~~~~~~~
 """
 
 from typing import Any, Dict
 
 import numpy as np
 from scipy.sparse import csr_matrix
-from scipy.stats import binom, chi2, hypergeom, norm
+from scipy.stats import binom, chi2, hypergeom
 
 
 def compute_binom_test(
-    neighborhoods: csr_matrix,
+    clusters: csr_matrix,
     annotation: csr_matrix,
     null_distribution: str = "network",
 ) -> Dict[str, Any]:
     """
-    Compute Binomial test for enrichment and depletion in neighborhoods with selectable null distribution.
+    Compute Binomial test for enrichment and depletion in clusters with selectable null distribution.
 
     Args:
-        neighborhoods (csr_matrix): Sparse binary matrix representing neighborhoods.
+        clusters (csr_matrix): Sparse binary matrix representing clusters.
         annotation (csr_matrix): Sparse binary matrix representing annotation.
         null_distribution (str, optional): Type of null distribution ('network' or 'annotation'). Defaults to "network".
 
@@ -30,10 +30,10 @@ def compute_binom_test(
         ValueError: If an invalid null_distribution value is provided.
     """
     # Get the total number of nodes in the network
-    total_nodes = neighborhoods.shape[1]
+    total_nodes = clusters.shape[1]
 
     # Compute sums (remain sparse here)
-    neighborhood_sizes = neighborhoods.sum(axis=1)  # Row sums
+    cluster_sizes = clusters.sum(axis=1)  # Row sums
     annotation_totals = annotation.sum(axis=0)  # Column sums
     # Compute probabilities (convert to dense)
     if null_distribution == "network":
@@ -46,26 +46,26 @@ def compute_binom_test(
         )
 
     # Observed counts (sparse matrix multiplication)
-    annotated_counts = neighborhoods @ annotation  # Sparse result
+    annotated_counts = clusters @ annotation  # Sparse result
     annotated_counts_dense = annotated_counts.toarray()  # Convert for dense operations
 
     # Compute enrichment and depletion p-values
-    enrichment_pvals = 1 - binom.cdf(annotated_counts_dense - 1, neighborhood_sizes.A, p_values)
-    depletion_pvals = binom.cdf(annotated_counts_dense, neighborhood_sizes.A, p_values)
+    enrichment_pvals = 1 - binom.cdf(annotated_counts_dense - 1, cluster_sizes.A, p_values)
+    depletion_pvals = binom.cdf(annotated_counts_dense, cluster_sizes.A, p_values)
 
     return {"enrichment_pvals": enrichment_pvals, "depletion_pvals": depletion_pvals}
 
 
 def compute_chi2_test(
-    neighborhoods: csr_matrix,
+    clusters: csr_matrix,
     annotation: csr_matrix,
     null_distribution: str = "network",
 ) -> Dict[str, Any]:
     """
-    Compute chi-squared test for enrichment and depletion in neighborhoods with selectable null distribution.
+    Compute chi-squared test for enrichment and depletion in clusters with selectable null distribution.
 
     Args:
-        neighborhoods (csr_matrix): Sparse binary matrix representing neighborhoods.
+        clusters (csr_matrix): Sparse binary matrix representing clusters.
         annotation (csr_matrix): Sparse binary matrix representing annotation.
         null_distribution (str, optional): Type of null distribution ('network' or 'annotation'). Defaults to "network".
 
@@ -76,12 +76,12 @@ def compute_chi2_test(
         ValueError: If an invalid null_distribution value is provided.
     """
     # Total number of nodes in the network
-    total_node_count = neighborhoods.shape[0]
+    total_node_count = clusters.shape[0]
 
     if null_distribution == "network":
         # Case 1: Use all nodes as the background
         background_population = total_node_count
-        neighborhood_sums = neighborhoods.sum(axis=0)  # Column sums of neighborhoods
+        cluster_sums = clusters.sum(axis=0)  # Column sums of clusters
         annotation_sums = annotation.sum(axis=0)  # Column sums of annotations
     elif null_distribution == "annotation":
         # Case 2: Only consider nodes with at least one annotation
@@ -89,9 +89,7 @@ def compute_chi2_test(
             np.ravel(annotation.sum(axis=1)) > 0
         )  # Row-wise sum to filter nodes with annotations
         background_population = annotated_nodes.sum()  # Total number of annotated nodes
-        neighborhood_sums = neighborhoods[annotated_nodes].sum(
-            axis=0
-        )  # Neighborhood sums for annotated nodes
+        cluster_sums = clusters[annotated_nodes].sum(axis=0)  # Cluster sums for annotated nodes
         annotation_sums = annotation[annotated_nodes].sum(
             axis=0
         )  # Annotation sums for annotated nodes
@@ -101,13 +99,13 @@ def compute_chi2_test(
         )
 
     # Convert to dense arrays for downstream computations
-    neighborhood_sums = np.asarray(neighborhood_sums).reshape(-1, 1)  # Ensure column vector shape
+    cluster_sums = np.asarray(cluster_sums).reshape(-1, 1)  # Ensure column vector shape
     annotation_sums = np.asarray(annotation_sums).reshape(1, -1)  # Ensure row vector shape
 
-    # Observed values: number of annotated nodes in each neighborhood
-    observed = neighborhoods.T @ annotation  # Shape: (neighborhoods, annotation)
+    # Observed values: number of annotated nodes in each cluster
+    observed = clusters.T @ annotation  # Shape: (clusters, annotation)
     # Expected values under the null
-    expected = (neighborhood_sums @ annotation_sums) / background_population
+    expected = (cluster_sums @ annotation_sums) / background_population
     # Chi-squared statistic: sum((observed - expected)^2 / expected)
     with np.errstate(divide="ignore", invalid="ignore"):  # Handle divide-by-zero
         chi2_stat = np.where(expected > 0, np.power(observed - expected, 2) / expected, 0)
@@ -120,15 +118,15 @@ def compute_chi2_test(
 
 
 def compute_hypergeom_test(
-    neighborhoods: csr_matrix,
+    clusters: csr_matrix,
     annotation: csr_matrix,
     null_distribution: str = "network",
 ) -> Dict[str, Any]:
     """
-    Compute hypergeometric test for enrichment and depletion in neighborhoods with selectable null distribution.
+    Compute hypergeometric test for enrichment and depletion in clusters with selectable null distribution.
 
     Args:
-        neighborhoods (csr_matrix): Sparse binary matrix representing neighborhoods.
+        clusters (csr_matrix): Sparse binary matrix representing clusters.
         annotation (csr_matrix): Sparse binary matrix representing annotation.
         null_distribution (str, optional): Type of null distribution ('network' or 'annotation'). Defaults to "network".
 
@@ -139,10 +137,10 @@ def compute_hypergeom_test(
         ValueError: If an invalid null_distribution value is provided.
     """
     # Get the total number of nodes in the network
-    total_nodes = neighborhoods.shape[1]
+    total_nodes = clusters.shape[1]
 
     # Compute sums
-    neighborhood_sums = neighborhoods.sum(axis=0).A.flatten()  # Convert to dense array
+    cluster_sums = clusters.sum(axis=0).A.flatten()  # Convert to dense array
     annotation_sums = annotation.sum(axis=0).A.flatten()  # Convert to dense array
 
     if null_distribution == "network":
@@ -150,7 +148,7 @@ def compute_hypergeom_test(
     elif null_distribution == "annotation":
         annotated_nodes = annotation.sum(axis=1).A.flatten() > 0  # Boolean mask
         background_population = annotated_nodes.sum()
-        neighborhood_sums = neighborhoods[annotated_nodes].sum(axis=0).A.flatten()
+        cluster_sums = clusters[annotated_nodes].sum(axis=0).A.flatten()
         annotation_sums = annotation[annotated_nodes].sum(axis=0).A.flatten()
     else:
         raise ValueError(
@@ -158,19 +156,19 @@ def compute_hypergeom_test(
         )
 
     # Observed counts
-    annotated_in_neighborhood = neighborhoods.T @ annotation  # Sparse result
-    annotated_in_neighborhood = annotated_in_neighborhood.toarray()  # Convert to dense
+    annotated_in_cluster = clusters.T @ annotation  # Sparse result
+    annotated_in_cluster = annotated_in_cluster.toarray()  # Convert to dense
     # Align shapes for broadcasting
-    neighborhood_sums = neighborhood_sums.reshape(-1, 1)
+    cluster_sums = cluster_sums.reshape(-1, 1)
     annotation_sums = annotation_sums.reshape(1, -1)
     background_population = np.array(background_population).reshape(1, 1)
 
     # Compute hypergeometric p-values
     depletion_pvals = hypergeom.cdf(
-        annotated_in_neighborhood, background_population, annotation_sums, neighborhood_sums
+        annotated_in_cluster, background_population, annotation_sums, cluster_sums
     )
     enrichment_pvals = hypergeom.sf(
-        annotated_in_neighborhood - 1, background_population, annotation_sums, neighborhood_sums
+        annotated_in_cluster - 1, background_population, annotation_sums, cluster_sums
     )
 
     return {"depletion_pvals": depletion_pvals, "enrichment_pvals": enrichment_pvals}

risk/stats/api.py

@@ -0,0 +1,202 @@
+"""
+risk/stats/api
+~~~~~~~~~~~~~~
+"""
+
+from typing import Any, Dict
+
+from scipy.sparse import csr_matrix
+
+from ..log import log_header, logger, params
+from ._stats import (
+    compute_binom_test,
+    compute_chi2_test,
+    compute_hypergeom_test,
+    compute_permutation_test,
+)
+
+
+class StatsAPI:
+    """
+    Handles the loading of statistical results and annotation significance for clusters.
+
+    The StatsAPI class provides methods to load cluster results from statistical tests.
+    """
+
+    def run_binom(
+        self,
+        annotation: Dict[str, Any],
+        clusters: csr_matrix,
+        null_distribution: str = "network",
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """
+        Compute cluster significance using the binomial test.
+
+        Args:
+            annotation (Dict[str, Any]): The annotation associated with the network.
+            clusters (csr_matrix): The cluster assignments for the network.
+            null_distribution (str, optional): Type of null distribution ('network' or 'annotation').
+
+        Returns:
+            Dict[str, Any]: The computed significance of clusters based on the specified statistical test.
+        """
+        log_header("Running binomial test")
+        # Compute cluster significance using the binomial test
+        return self._run_statistical_test(
+            annotation=annotation,
+            clusters=clusters,
+            null_distribution=null_distribution,
+            statistical_test_key="binom",
+            statistical_test_function=compute_binom_test,
+            **kwargs,
+        )
+
+    def run_chi2(
+        self,
+        annotation: Dict[str, Any],
+        clusters: csr_matrix,
+        null_distribution: str = "network",
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """
+        Compute cluster significance using the chi-squared test.
+
+        Args:
+            annotation (Dict[str, Any]): The annotation associated with the network.
+            clusters (csr_matrix): The cluster assignments for the network.
+            null_distribution (str, optional): Type of null distribution ('network' or 'annotation'). Defaults to "network".
+
+        Returns:
+            Dict[str, Any]: The computed significance of clusters based on the specified statistical test.
+        """
+        log_header("Running chi-squared test")
+        # Compute cluster significance using the chi-squared test
+        return self._run_statistical_test(
+            annotation=annotation,
+            clusters=clusters,
+            null_distribution=null_distribution,
+            statistical_test_key="chi2",
+            statistical_test_function=compute_chi2_test,
+            **kwargs,
+        )
+
+    def run_hypergeom(
+        self,
+        annotation: Dict[str, Any],
+        clusters: csr_matrix,
+        null_distribution: str = "network",
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """
+        Compute cluster significance using the hypergeometric test.
+
+        Args:
+            annotation (Dict[str, Any]): The annotation associated with the network.
+            clusters (csr_matrix): The cluster matrix to use.
+            null_distribution (str, optional): Type of null distribution ('network' or 'annotation'). Defaults to "network".
+
+        Returns:
+            Dict[str, Any]: The computed significance of clusters based on the specified statistical test.
+        """
+        log_header("Running hypergeometric test")
+        # Compute cluster significance using the hypergeometric test
+        return self._run_statistical_test(
+            annotation=annotation,
+            clusters=clusters,
+            null_distribution=null_distribution,
+            statistical_test_key="hypergeom",
+            statistical_test_function=compute_hypergeom_test,
+            **kwargs,
+        )
+
+    def run_permutation(
+        self,
+        annotation: Dict[str, Any],
+        clusters: csr_matrix,
+        score_metric: str = "sum",
+        null_distribution: str = "network",
+        num_permutations: int = 1000,
+        random_seed: int = 888,
+        max_workers: int = 1,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """
+        Compute cluster significance using the permutation test.
+
+        Args:
+            annotation (Dict[str, Any]): The annotation associated with the network.
+            clusters (csr_matrix): The cluster matrix to use.
+            score_metric (str, optional): Scoring metric for cluster significance. Defaults to "sum".
+            null_distribution (str, optional): Type of null distribution ('network' or 'annotation'). Defaults to "network".
+            num_permutations (int, optional): Number of permutations for significance testing. Defaults to 1000.
+            random_seed (int, optional): Seed for random number generation. Defaults to 888.
+            max_workers (int, optional): Maximum number of workers for parallel computation. Defaults to 1.
+
+        Returns:
+            Dict[str, Any]: The computed significance of clusters based on the specified statistical test.
+        """
+        log_header("Running permutation test")
+        # Log and display permutation test settings, which is unique to this test
+        logger.debug(f"Cluster scoring metric: '{score_metric}'")
+        logger.debug(f"Number of permutations: {num_permutations}")
+        logger.debug(f"Maximum workers: {max_workers}")
+        # Compute cluster significance using the permutation test
+        return self._run_statistical_test(
+            annotation=annotation,
+            clusters=clusters,
+            null_distribution=null_distribution,
+            random_seed=random_seed,
+            statistical_test_key="permutation",
+            statistical_test_function=compute_permutation_test,
+            score_metric=score_metric,
+            num_permutations=num_permutations,
+            max_workers=max_workers,
+            **kwargs,
+        )
+
+    def _run_statistical_test(
+        self,
+        annotation: Dict[str, Any],
+        clusters: csr_matrix,
+        null_distribution: str = "network",
+        statistical_test_key: str = "hypergeom",
+        statistical_test_function: Any = compute_hypergeom_test,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """
+        Run the specified statistical test to compute cluster significance.
+
+        Args:
+            annotation (Dict[str, Any]): Annotation data associated with the network.
+            clusters (csr_matrix): The cluster matrix to analyze.
+            null_distribution (str, optional): The type of null distribution to use ('network' or 'annotation').
+                Defaults to "network".
+            random_seed (int, optional): Seed for random number generation to ensure reproducibility. Defaults to 888.
+            statistical_test_key (str, optional): Key or name of the statistical test to be applied (e.g., "hypergeom", "binom").
+                Used for logging and debugging. Defaults to "hypergeom".
+            statistical_test_function (Any, optional): The function implementing the statistical test.
+                It should accept clusters, annotation, null distribution, and additional kwargs.
+                Defaults to `compute_hypergeom_test`.
+            **kwargs: Additional parameters to be passed to the statistical test function.
+
+        Returns:
+            Dict[str, Any]: A dictionary containing the computed significance values for clusters.
+        """
+        # Log null distribution type
+        logger.debug(f"Null distribution: '{null_distribution}'")
+        # Log cluster analysis parameters
+        params.log_stats(
+            statistical_test_function=statistical_test_key,
+            null_distribution=null_distribution,
+            **kwargs,
+        )
+        # Apply statistical test function to compute cluster significance
+        cluster_significance = statistical_test_function(
+            clusters=clusters,
+            annotation=annotation["matrix"],
+            null_distribution=null_distribution,
+            **kwargs,
+        )
+        # Return the computed cluster significance
+        return cluster_significance

{risk_network-0.0.16b1.dist-info → risk_network-0.0.16b2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: risk-network
-Version: 0.0.16b1
+Version: 0.0.16b2
 Summary: A Python package for scalable network analysis and high-quality visualization.
 Author-email: Ira Horecka <ira89@icloud.com>
 License: GPL-3.0-or-later
@@ -44,7 +44,7 @@ Dynamic: license-file
 ![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.17257418.svg)](https://doi.org/10.5281/zenodo.17257418)
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.17257417.svg)](https://doi.org/10.5281/zenodo.17257417)
 ![Tests](https://github.com/riskportal/risk/actions/workflows/ci.yml/badge.svg)
 
 **RISK** (Regional Inference of Significant Kinships) is a next-generation tool for biological network annotation and visualization. It integrates community detection algorithms, rigorous overrepresentation analysis, and a modular framework for diverse network types. RISK identifies biologically coherent relationships within networks and generates publication-ready visualizations, making it a useful tool for biological and interdisciplinary network analysis.

risk_network-0.0.16b2.dist-info/RECORD

@@ -0,0 +1,43 @@
+risk/__init__.py,sha256=8kw8nQa4l3_e5whBhKyspNfK6gv9ACvnrFRffg7RO40,142
+risk/risk.py,sha256=EHq4jfsx1TssuzkfYd8joaogW0heS0SuM38BWj4CX0E,1063
+risk/annotation/__init__.py,sha256=1F_P_JVQD7ai4bWNjL5dIHTR6SuaFIfnD-MC7wZW0vY,162
+risk/annotation/_nltk_setup.py,sha256=YUlB7bqiHELn8rb5tE5o7_FiXyirnxWL3Vzm47HWtiM,3581
+risk/annotation/annotation.py,sha256=FVYFJoIFUzjhQCba44ocXz65u5Kwr_b0h431ewb_QZc,14980
+risk/annotation/io.py,sha256=_bA-sRDh4ynvgNVCz60AChzh_f22Oxv1AkVnQK-LTPw,12451
+risk/cluster/__init__.py,sha256=vP7ZTKRogKtfMZt7HquJes6TZqQvufIvIeIYbM_bwAE,161
+risk/cluster/_community.py,sha256=wgcoUiFL8tJZTmfnUA2_0LkK_pOFtNCC_d1vBX6ENL4,17665
+risk/cluster/api.py,sha256=d5IT-th4uVotGrt-sctqs3EsWjgvSi4ncQrdB1ghp-c,9337
+risk/cluster/cluster.py,sha256=sWPWBlfy3bZoPBh6LSHc54sZrXMSf6AA9vBVu_z0TmA,21469
+risk/cluster/label.py,sha256=TtN1gbfoDITTc2KWBz8rC8HLr2CZzuhnZU2EClh3dNs,16811
+risk/log/__init__.py,sha256=wEJ0hXt8yyIAS-IGGL7Kd8xoPD_beVWQwhF-buxW6J4,203
+risk/log/console.py,sha256=x1sFpOqKzPVoBHr9sDJJYAbFqQmRUV2HPKBvEn9_AX4,4649
+risk/log/parameters.py,sha256=bKQKYs4cRXnIlEboys8pVjs23NBgMtQWRSg1lGgFUR0,6103
+risk/network/__init__.py,sha256=ZdJRKDXc9DOCIFzDYOsnqmnHvFbODNjaJ8XmeNby93M,124
+risk/network/io.py,sha256=909YYj1h9TKW-VpcdYSya3i1V-hOLXvjU795Y5v6roA,28337
+risk/network/graph/__init__.py,sha256=sU46_opsN9ep9jh6fVoBYRzbohjm6_Nx1IVYqv0sMj4,98
+risk/network/graph/_stats.py,sha256=Q2LPu6vzW-lpDCOLtdBna9tCfuCJ4jxjRjvtb3SD9os,7355
+risk/network/graph/_summary.py,sha256=wCSPXHtA6wfjJwRRuD9RzherNOB8RGQzq1weDa-sHBY,10188
+risk/network/graph/api.py,sha256=E8wjC_RvaHTmdQyD5aGmlSOFtjCrVHpkbqcca570ajQ,8456
+risk/network/graph/graph.py,sha256=Ztw6-rcr4cgQgW1uujbU4y_RHYJRzT_oNOtsgmYCf9s,12475
+risk/network/plotter/__init__.py,sha256=gw2fV1atXlxC5ckST2TnBV3yhVYfQSFadPYBBTiDatk,79
+risk/network/plotter/_canvas.py,sha256=fQEcBCQEI4vwj6sAHgULYMdMuWyqeRrVYp7NxHkyXng,13591
+risk/network/plotter/_contour.py,sha256=8QshMFxZXZmZRzfru5a3Bpf5pGL-ElukegVMvculgFM,15551
+risk/network/plotter/_labels.py,sha256=JZ6KOy_kTz-m_qkedKJ181kppjhk09Z63zlyRv18lnw,46909
+risk/network/plotter/_network.py,sha256=IiK1mnByoTvjc7xmuRHfewjC1t8TR8ZIvDxgITSU5Fk,14306
+risk/network/plotter/_plotter.py,sha256=6OTGz1md5v_1iKGru__2QeV3-gUULLJscyLPWPOBCGo,6004
+risk/network/plotter/api.py,sha256=LIrXZJBdTCnh6ntFHEl5vbQs35f4cytqixizxzUQqvU,1686
+risk/network/plotter/_utils/__init__.py,sha256=F2W_R_lhtTDap3xJ25qN-C3Ba1fb0NYkDBiR8vB-4Eo,205
+risk/network/plotter/_utils/colors.py,sha256=CKmZ-Ki1oh40nNGBHE4PTirJ8dF0Y4yReTF6VzzQlrA,19170
+risk/network/plotter/_utils/layout.py,sha256=UQQHT-A-iHQxKEzFla_8fvnjBJTc_zsm2-ZJpvLLbOk,3627
+risk/stats/__init__.py,sha256=Mb8h-1Z3upFS0zrlFVbyfO5afLkVaZXfqZpOs4lj_lg,57
+risk/stats/api.py,sha256=1U-cABIZzVQjmTF7M09QaRZfCLI82C8OzSXOSuM37XI,8075
+risk/stats/_stats/__init__.py,sha256=yMGqINN7Z4A2V4ln5f6lhdV-5GRfV5ABm-m-mni4YNQ,197
+risk/stats/_stats/tests.py,sha256=mTCwu6CnZjU_qURmKKc8Dd37Gar8xukttIm2qXhrCY0,7279
+risk/stats/_stats/permutation/__init__.py,sha256=BDELJoCtaz0Byc4V6f7chtfYqkG4l_trM30kgzNxluM,134
+risk/stats/_stats/permutation/_test_functions.py,sha256=qeHsljh_gVG1EqFPzYPvLG_G3HnoXtKwsmowVXmEKnI,2970
+risk/stats/_stats/permutation/permutation.py,sha256=aglSO8NiP0hzTdcZKIQy1ZwaTJaXPBPBULTB8JG_02E,10377
+risk_network-0.0.16b2.dist-info/licenses/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+risk_network-0.0.16b2.dist-info/METADATA,sha256=7usyb0e7b7qPUqaxIYp-UT2zrasH5Ur4N6E96jqA7aY,5390
+risk_network-0.0.16b2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+risk_network-0.0.16b2.dist-info/top_level.txt,sha256=NX7C2PFKTvC1JhVKv14DFlFAIFnKc6Lpsu1ZfxvQwVw,5
+risk_network-0.0.16b2.dist-info/RECORD,,

risk/_neighborhoods/__init__.py

@@ -1,8 +0,0 @@
-"""
-risk/_neighborhoods
-~~~~~~~~~~~~~~~~~~~
-"""
-
-from ._api import NeighborhoodsAPI
-from ._domains import define_domains, trim_domains
-from ._neighborhoods import process_neighborhoods