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

risk/{_network/_plotter → network/plotter}/_network.py

@@ -1,6 +1,6 @@
 """
-risk/_network/_plotter/_network
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+risk/network/plotter/_network
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
 from typing import Any, Dict, List, Tuple, Union
@@ -8,8 +8,8 @@ from typing import Any, Dict, List, Tuple, Union
 import networkx as nx
 import numpy as np
 
-from ..._log import params
-from .._graph import Graph
+from ...log import params
+from ..graph import Graph
 from ._utils import get_domain_colors, to_rgba
 
 
@@ -273,14 +273,14 @@ class Network:
         return adjusted_network_colors
 
     def get_annotated_node_sizes(
-        self, significant_size: int = 50, nonsignificant_size: int = 25
+        self, significant_size: Union[int, float] = 50, nonsignificant_size: Union[int, float] = 25
     ) -> np.ndarray:
         """
         Adjust the sizes of nodes in the network graph based on whether they are significant or not.
 
         Args:
-            significant_size (int): Size for significant nodes. Defaults to 50.
-            nonsignificant_size (int): Size for non-significant nodes. Defaults to 25.
+            significant_size (int or float): Size for significant nodes. Can be an integer or float value. Defaults to 50.
+            nonsignificant_size (int or float): Size for non-significant nodes. Can be an integer or float value. Defaults to 25.
 
         Returns:
             np.ndarray: Array of node sizes, with significant nodes larger than non-significant ones.

risk/{_network/_plotter → network/plotter}/_plotter.py

@@ -1,6 +1,6 @@
 """
-risk/_network/_plotter/_plotter
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+risk/network/plotter/_plotter
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
 from typing import List, Tuple, Union
@@ -8,8 +8,8 @@ from typing import List, Tuple, Union
 import matplotlib.pyplot as plt
 import numpy as np
 
-from ..._log import params
-from .._graph._graph import Graph
+from ...log import params
+from ..graph.graph import Graph
 from ._canvas import Canvas
 from ._contour import Contour
 from ._labels import Labels
@@ -123,7 +123,7 @@ class Plotter(Canvas, Network, Contour, Labels):
         Args:
             *args: Positional arguments passed to `plt.savefig`.
             pad_inches (float, optional): Padding around the figure when saving. Defaults to 0.5.
-            dpi (int, optional): Dots per inch (DPI) for the exported image. Defaults to 300.
+            dpi (int, optional): Dots per inch (DPI) for the exported image. Defaults to 100.
             **kwargs: Keyword arguments passed to `plt.savefig`, such as filename and format.
         """
         # Ensure user-provided kwargs take precedence

risk/network/plotter/_utils/__init__.py

@@ -0,0 +1,7 @@
+"""
+risk/network/plotter/_utils
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+"""
+
+from .colors import get_annotated_domain_colors, get_domain_colors, to_rgba
+from .layout import calculate_bounding_box, calculate_centroids

risk/{_network/_plotter/_utils/_colors.py → network/plotter/_utils/colors.py}

@@ -1,6 +1,6 @@
 """
-risk/_network/_plotter/_utils/_colors
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+risk/network/plotter/_utils/colors
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
 from typing import Any, Dict, List, Tuple, Union
@@ -9,7 +9,7 @@ import matplotlib
 import matplotlib.colors as mcolors
 import numpy as np
 
-from ..._graph import Graph
+from ...graph import Graph
 
 
 def get_annotated_domain_colors(

risk/{_network/_plotter/_utils/_layout.py → network/plotter/_utils/layout.py}

@@ -1,6 +1,6 @@
 """
-risk/_network/_plotter/_utils/_layout
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+risk/network/plotter/_utils/layout
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
 from typing import Any, Dict, List, Tuple

risk/{_network/_plotter/_api.py → network/plotter/api.py}

@@ -1,14 +1,14 @@
 """
-risk/_network/_plotter/_api
-~~~~~~~~~~~~~~~~~~~~~~~~~~~
+risk/network/plotter/api
+~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
 from typing import List, Tuple, Union
 
 import numpy as np
 
-from ..._log import log_header
-from .._graph import Graph
+from ...log import log_header
+from ..graph import Graph
 from ._plotter import Plotter
 
 
@@ -32,7 +32,7 @@ class PlotterAPI:
 
         Args:
             graph (Graph): The graph to plot.
-            figsize (List, Tuple, or np.ndarray, optional): Size of the plot. Defaults to (10, 10)., optional): Size of the figure. Defaults to (10, 10).
+            figsize (List, Tuple, or np.ndarray, optional): Figure size in inches (width, height). 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.

risk/{_risk.py → risk.py}

@@ -1,20 +1,21 @@
 """
-risk/_risk
-~~~~~~~~~~
+risk/risk
+~~~~~~~~~
 """
 
-from ._annotation import AnnotationHandler
-from ._log import params, set_global_verbosity
-from ._neighborhoods import NeighborhoodsAPI
-from ._network import GraphAPI, NetworkAPI, PlotterAPI
+from .annotation import AnnotationHandler
+from .cluster import ClusterAPI
+from .log import params, set_global_verbosity
+from .network import GraphAPI, NetworkAPI, PlotterAPI
+from .stats import StatsAPI
 
 
-class RISK(NetworkAPI, AnnotationHandler, NeighborhoodsAPI, GraphAPI, PlotterAPI):
+class RISK(NetworkAPI, AnnotationHandler, ClusterAPI, StatsAPI, GraphAPI, PlotterAPI):
     """
     RISK: A class for network analysis and visualization.
 
     The RISK class integrates functionalities for loading networks, processing annotations,
-    performing network-based statistical analysis to quantify neighborhood relationships,
+    performing network-based statistical analysis to quantify cluster relationships,
     and visualizing networks and their properties.
     """
 

risk/stats/__init__.py

@@ -0,0 +1,6 @@
+"""
+risk/stats
+~~~~~~~~~~
+"""
+
+from .api import StatsAPI

risk/stats/_stats/__init__.py

@@ -0,0 +1,11 @@
+"""
+risk/cluster/_stats
+~~~~~~~~~~~~~~~~~~~
+"""
+
+from .permutation import compute_permutation_test
+from .tests import (
+    compute_binom_test,
+    compute_chi2_test,
+    compute_hypergeom_test,
+)

risk/stats/_stats/permutation/__init__.py

@@ -0,0 +1,6 @@
+"""
+risk/_clusters/_stats/_permutation
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+"""
+
+from .permutation import compute_permutation_test

risk/stats/_stats/permutation/_test_functions.py

@@ -0,0 +1,72 @@
+"""
+risk/stats/_stats/permutation/_test_functions
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+"""
+
+import numpy as np
+from scipy.sparse import csr_matrix
+
+# NOTE: Cython optimizations provided minimal performance benefits.
+# The final version with Cython is archived in the `cython_permutation` branch.
+
+# DISPATCH_TEST_FUNCTIONS can be found at the end of the file.
+
+
+def compute_cluster_score_by_sum(
+    clusters_matrix: csr_matrix, annotation_matrix: csr_matrix
+) -> np.ndarray:
+    """
+    Compute the sum of attribute values for each cluster using sparse matrices.
+
+    Args:
+        clusters_matrix (csr_matrix): Sparse binary matrix representing clusters.
+        annotation_matrix (csr_matrix): Sparse matrix representing annotation values.
+
+    Returns:
+        np.ndarray: Dense array of summed attribute values for each cluster.
+    """
+    # Calculate the cluster score as the dot product of clusters and annotation
+    cluster_score = clusters_matrix @ annotation_matrix  # Sparse matrix multiplication
+    # Convert the result to a dense array for downstream calculations
+    cluster_score_dense = cluster_score.toarray()
+    return cluster_score_dense
+
+
+def compute_cluster_score_by_stdev(
+    clusters_matrix: csr_matrix, annotation_matrix: csr_matrix
+) -> np.ndarray:
+    """
+    Compute the standard deviation of cluster scores for sparse matrices.
+
+    Args:
+        clusters_matrix (csr_matrix): Sparse binary matrix representing clusters.
+        annotation_matrix (csr_matrix): Sparse matrix representing annotation values.
+
+    Returns:
+        np.ndarray: Standard deviation of the cluster scores.
+    """
+    # Calculate the cluster score as the dot product of clusters and annotation
+    cluster_score = clusters_matrix @ annotation_matrix  # Sparse matrix multiplication
+    # Calculate the number of elements in each cluster (sum of rows)
+    N = clusters_matrix.sum(axis=1).A.flatten()  # Convert to 1D array
+    # Avoid division by zero by replacing zeros in N with np.nan temporarily
+    N[N == 0] = np.nan
+    # Compute the mean of the cluster scores
+    M = cluster_score.multiply(1 / N[:, None]).toarray()  # Sparse element-wise division
+    # Compute the mean of squares (EXX) directly using squared annotation matrix
+    annotation_squared = annotation_matrix.multiply(annotation_matrix)  # Element-wise squaring
+    EXX = (clusters_matrix @ annotation_squared).multiply(1 / N[:, None]).toarray()
+    # Calculate variance as EXX - M^2
+    variance = EXX - np.power(M, 2)
+    # Compute the standard deviation as the square root of the variance
+    cluster_stdev = np.sqrt(variance)
+    # Replace np.nan back with zeros in case N was 0 (no elements in the cluster)
+    cluster_stdev[np.isnan(cluster_stdev)] = 0
+    return cluster_stdev
+
+
+# Dictionary to dispatch statistical test functions based on the score metric
+DISPATCH_TEST_FUNCTIONS = {
+    "sum": compute_cluster_score_by_sum,
+    "stdev": compute_cluster_score_by_stdev,
+}

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}