risk-network 0.0.13b3__py3-none-any.whl → 0.0.13b5__py3-none-any.whl

risk/{log/parameters.py → _log/_parameters.py}

@@ -1,6 +1,6 @@
 """
-risk/log/parameters
-~~~~~~~~~~~~~~~~~~~
+risk/_log/_parameters
+~~~~~~~~~~~~~~~~~~~~~
 """
 
 import csv
@@ -11,14 +11,15 @@ from typing import Any, Dict
 
 import numpy as np
 
-from risk.log.console import log_header, logger
+from ._console import log_header, logger
 
 # Suppress all warnings - this is to resolve warnings from multiprocessing
 warnings.filterwarnings("ignore")
 
 
 class Params:
-    """Handles the storage and logging of various parameters for network analysis.
+    """
+    Handles the storage and logging of various parameters for network analysis.
 
     The Params class provides methods to log parameters related to different components of the analysis,
     such as the network, annotation, neighborhoods, graph, and plotter settings. It also stores
@@ -39,7 +40,8 @@ class Params:
         self.plotter = {}
 
     def log_network(self, **kwargs) -> None:
-        """Log network-related parameters.
+        """
+        Log network-related parameters.
 
         Args:
             **kwargs: Network parameters to log.
@@ -47,7 +49,8 @@ class Params:
         self.network = {**self.network, **kwargs}
 
     def log_annotation(self, **kwargs) -> None:
-        """Log annotation-related parameters.
+        """
+        Log annotation-related parameters.
 
         Args:
             **kwargs: Annotation parameters to log.
@@ -55,7 +58,8 @@ class Params:
         self.annotation = {**self.annotation, **kwargs}
 
     def log_neighborhoods(self, **kwargs) -> None:
-        """Log neighborhood-related parameters.
+        """
+        Log neighborhood-related parameters.
 
         Args:
             **kwargs: Neighborhood parameters to log.
@@ -63,7 +67,8 @@ class Params:
         self.neighborhoods = {**self.neighborhoods, **kwargs}
 
     def log_graph(self, **kwargs) -> None:
-        """Log graph-related parameters.
+        """
+        Log graph-related parameters.
 
         Args:
             **kwargs: Graph parameters to log.
@@ -71,7 +76,8 @@ class Params:
         self.graph = {**self.graph, **kwargs}
 
     def log_plotter(self, **kwargs) -> None:
-        """Log plotter-related parameters.
+        """
+        Log plotter-related parameters.
 
         Args:
             **kwargs: Plotter parameters to log.
@@ -79,7 +85,8 @@ class Params:
         self.plotter = {**self.plotter, **kwargs}
 
     def to_csv(self, filepath: str) -> None:
-        """Export the parameters to a CSV file.
+        """
+        Export the parameters to a CSV file.
 
         Args:
             filepath (str): The path where the CSV file will be saved.
@@ -102,7 +109,8 @@ class Params:
         logger.info(f"Parameters exported to CSV file: {filepath}")
 
     def to_json(self, filepath: str) -> None:
-        """Export the parameters to a JSON file.
+        """
+        Export the parameters to a JSON file.
 
         Args:
             filepath (str): The path where the JSON file will be saved.
@@ -113,7 +121,8 @@ class Params:
         logger.info(f"Parameters exported to JSON file: {filepath}")
 
     def to_txt(self, filepath: str) -> None:
-        """Export the parameters to a text file.
+        """
+        Export the parameters to a text file.
 
         Args:
             filepath (str): The path where the text file will be saved.
@@ -131,7 +140,8 @@ class Params:
         logger.info(f"Parameters exported to text file: {filepath}")
 
     def load(self) -> Dict[str, Any]:
-        """Load and process various parameters, converting any np.ndarray values to lists.
+        """
+        Load and process various parameters, converting any np.ndarray values to lists.
 
         Returns:
             Dict[str, Any]: A dictionary containing the processed parameters.
@@ -149,7 +159,8 @@ class Params:
         )
 
     def _convert_ndarray_to_list(self, d: Dict[str, Any]) -> Dict[str, Any]:
-        """Recursively convert all np.ndarray values in the dictionary to lists.
+        """
+        Recursively convert all np.ndarray values in the dictionary to lists.
 
         Args:
             d (Dict[str, Any]): The dictionary to process.

risk/_neighborhoods/__init__.py

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

risk/{neighborhoods/api.py → _neighborhoods/_api.py}

@@ -1,6 +1,6 @@
 """
-risk/neighborhoods/api
-~~~~~~~~~~~~~~~~~~~~~~
+risk/_neighborhoods/_api
+~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
 import copy
@@ -10,9 +10,9 @@ import networkx as nx
 import numpy as np
 from scipy.sparse import csr_matrix
 
-from risk.log import log_header, logger, params
-from risk.neighborhoods.neighborhoods import get_network_neighborhoods
-from risk.neighborhoods.stats import (
+from .._log import log_header, logger, params
+from ._neighborhoods import get_network_neighborhoods
+from ._stats import (
     compute_binom_test,
     compute_chi2_test,
     compute_hypergeom_test,
@@ -23,7 +23,8 @@ from risk.neighborhoods.stats import (
 
 
 class NeighborhoodsAPI:
-    """Handles the loading of statistical results and annotation significance for neighborhoods.
+    """
+    Handles the loading of statistical results and annotation significance for neighborhoods.
 
     The NeighborhoodsAPI class provides methods to load neighborhood results from statistical tests.
     """
@@ -42,7 +43,8 @@ class NeighborhoodsAPI:
         null_distribution: str = "network",
         random_seed: int = 888,
     ) -> Dict[str, Any]:
-        """Load significant neighborhoods for the network using the binomial test.
+        """
+        Load significant neighborhoods for the network using the binomial test.
 
         Args:
             network (nx.Graph): The network graph.
@@ -87,7 +89,8 @@ class NeighborhoodsAPI:
         null_distribution: str = "network",
         random_seed: int = 888,
     ) -> Dict[str, Any]:
-        """Load significant neighborhoods for the network using the chi-squared test.
+        """
+        Load significant neighborhoods for the network using the chi-squared test.
 
         Args:
             network (nx.Graph): The network graph.
@@ -132,7 +135,8 @@ class NeighborhoodsAPI:
         null_distribution: str = "network",
         random_seed: int = 888,
     ) -> Dict[str, Any]:
-        """Load significant neighborhoods for the network using the hypergeometric test.
+        """
+        Load significant neighborhoods for the network using the hypergeometric test.
 
         Args:
             network (nx.Graph): The network graph.
@@ -180,7 +184,8 @@ class NeighborhoodsAPI:
         random_seed: int = 888,
         max_workers: int = 1,
     ) -> Dict[str, Any]:
-        """Load significant neighborhoods for the network using the permutation test.
+        """
+        Load significant neighborhoods for the network using the permutation test.
 
         Args:
             network (nx.Graph): The network graph.
@@ -235,7 +240,8 @@ class NeighborhoodsAPI:
         null_distribution: str = "network",
         random_seed: int = 888,
     ) -> Dict[str, Any]:
-        """Load significant neighborhoods for the network using the Poisson test.
+        """
+        Load significant neighborhoods for the network using the Poisson test.
 
         Args:
             network (nx.Graph): The network graph.
@@ -280,7 +286,8 @@ class NeighborhoodsAPI:
         null_distribution: str = "network",
         random_seed: int = 888,
     ) -> Dict[str, Any]:
-        """Load significant neighborhoods for the network using the z-score test.
+        """
+        Load significant neighborhoods for the network using the z-score test.
 
         Args:
             network (nx.Graph): The network graph.
@@ -328,7 +335,8 @@ class NeighborhoodsAPI:
         statistical_test_function: Any = compute_hypergeom_test,
         **kwargs,
     ):
-        """Load and compute significant neighborhoods for the network using a specified statistical test.
+        """
+        Load and compute significant neighborhoods for the network using a specified statistical test.
 
         Args:
             network (nx.Graph): The input network graph.
@@ -398,7 +406,8 @@ class NeighborhoodsAPI:
         fraction_shortest_edges: Union[float, List, Tuple, np.ndarray] = 0.5,
         random_seed: int = 888,
     ) -> csr_matrix:
-        """Load significant neighborhoods for the network.
+        """
+        Load significant neighborhoods for the network.
 
         Args:
             network (nx.Graph): The network graph.

risk/{neighborhoods/community.py → _neighborhoods/_community.py}

@@ -1,6 +1,6 @@
 """
-risk/neighborhoods/community
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+risk/_neighborhoods/_community
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
 import community as community_louvain
@@ -12,13 +12,14 @@ from leidenalg import RBConfigurationVertexPartition, find_partition
 from networkx.algorithms.community import greedy_modularity_communities
 from scipy.sparse import csr_matrix
 
-from risk.log import logger
+from .._log import logger
 
 
 def calculate_greedy_modularity_neighborhoods(
     network: nx.Graph, fraction_shortest_edges: float = 1.0
 ) -> csr_matrix:
-    """Calculate neighborhoods using the Greedy Modularity method with CSR matrix output.
+    """
+    Calculate neighborhoods using the Greedy Modularity method with CSR matrix output.
 
     Args:
         network (nx.Graph): The network graph.
@@ -62,7 +63,8 @@ def calculate_greedy_modularity_neighborhoods(
 def calculate_label_propagation_neighborhoods(
     network: nx.Graph, fraction_shortest_edges: float = 1.0
 ) -> csr_matrix:
-    """Apply Label Propagation to the network to detect communities.
+    """
+    Apply Label Propagation to the network to detect communities.
 
     Args:
         network (nx.Graph): The network graph.
@@ -112,7 +114,8 @@ def calculate_leiden_neighborhoods(
     fraction_shortest_edges: float = 1.0,
     random_seed: int = 888,
 ) -> csr_matrix:
-    """Calculate neighborhoods using the Leiden method with CSR matrix output.
+    """
+    Calculate neighborhoods using the Leiden method with CSR matrix output.
 
     Args:
         network (nx.Graph): The network graph.
@@ -168,7 +171,8 @@ def calculate_louvain_neighborhoods(
     fraction_shortest_edges: float = 1.0,
     random_seed: int = 888,
 ) -> csr_matrix:
-    """Calculate neighborhoods using the Louvain method.
+    """
+    Calculate neighborhoods using the Louvain method.
 
     Args:
         network (nx.Graph): The network graph.
@@ -221,7 +225,8 @@ def calculate_louvain_neighborhoods(
 def calculate_markov_clustering_neighborhoods(
     network: nx.Graph, fraction_shortest_edges: float = 1.0
 ) -> csr_matrix:
-    """Apply Markov Clustering (MCL) to the network and return a binary neighborhood matrix (CSR).
+    """
+    Apply Markov Clustering (MCL) to the network and return a binary neighborhood matrix (CSR).
 
     Args:
         network (nx.Graph): The network graph.
@@ -291,7 +296,8 @@ def calculate_markov_clustering_neighborhoods(
 def calculate_spinglass_neighborhoods(
     network: nx.Graph, fraction_shortest_edges: float = 1.0
 ) -> csr_matrix:
-    """Apply Spinglass Community Detection to the network, handling disconnected components.
+    """
+    Apply Spinglass Community Detection to the network, handling disconnected components.
 
     Args:
         network (nx.Graph): The network graph.
@@ -355,7 +361,8 @@ def calculate_spinglass_neighborhoods(
 def calculate_walktrap_neighborhoods(
     network: nx.Graph, fraction_shortest_edges: float = 1.0
 ) -> csr_matrix:
-    """Apply Walktrap Community Detection to the network with CSR matrix output.
+    """
+    Apply Walktrap Community Detection to the network with CSR matrix output.
 
     Args:
         network (nx.Graph): The network graph.
@@ -399,7 +406,8 @@ def calculate_walktrap_neighborhoods(
 
 
 def _create_percentile_limited_subgraph(G: nx.Graph, fraction_shortest_edges: float) -> nx.Graph:
-    """Create a subgraph containing the shortest edges based on the specified rank fraction
+    """
+    Create a subgraph containing the shortest edges based on the specified rank fraction
     of all edge lengths in the input graph.
 
     Args:

risk/{neighborhoods/domains.py → _neighborhoods/_domains.py}

@@ -1,6 +1,6 @@
 """
-risk/neighborhoods/domains
-~~~~~~~~~~~~~~~~~~~~~~~~~~
+risk/_neighborhoods/_domains
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
 from itertools import product
@@ -13,8 +13,9 @@ from scipy.cluster.hierarchy import fcluster, linkage
 from sklearn.metrics import silhouette_score
 from tqdm import tqdm
 
-from risk.annotation import get_weighted_description
-from risk.log import logger
+from risk._annotation import get_weighted_description
+
+from .._log import logger
 
 # Define constants for clustering
 # fmt: off
@@ -35,7 +36,8 @@ def define_domains(
     linkage_metric: str,
     linkage_threshold: Union[float, str],
 ) -> pd.DataFrame:
-    """Define domains and assign nodes to these domains based on their significance scores and clustering,
+    """
+    Define domains and assign nodes to these domains based on their significance scores and clustering,
     handling errors by assigning unique domains when clustering fails.
 
     Args:
@@ -112,7 +114,8 @@ def trim_domains(
     min_cluster_size: int = 5,
     max_cluster_size: int = 1000,
 ) -> Tuple[pd.DataFrame, pd.DataFrame]:
-    """Trim domains that do not meet size criteria and find outliers.
+    """
+    Trim domains that do not meet size criteria and find outliers.
 
     Args:
         domains (pd.DataFrame): DataFrame of domain data for the network nodes.
@@ -182,7 +185,8 @@ def trim_domains(
 
 
 def _safeguard_matrix(matrix: np.ndarray) -> np.ndarray:
-    """Safeguard the matrix by replacing NaN, Inf, and -Inf values.
+    """
+    Safeguard the matrix by replacing NaN, Inf, and -Inf values.
 
     Args:
         matrix (np.ndarray): Data matrix.
@@ -211,7 +215,8 @@ def _optimize_silhouette_across_linkage_and_metrics(
     linkage_metric: str,
     linkage_threshold: Union[str, float],
 ) -> Tuple[str, str, float]:
-    """Optimize silhouette score across different linkage methods and distance metrics.
+    """
+    Optimize silhouette score across different linkage methods and distance metrics.
 
     Args:
         m (np.ndarray): Data matrix.
@@ -287,7 +292,8 @@ def _find_best_silhouette_score(
     lower_bound: float = 0.001,
     upper_bound: float = 1.0,
 ) -> Tuple[float, float]:
-    """Find the best silhouette score using binary search.
+    """
+    Find the best silhouette score using binary search.
 
     Args:
         Z (np.ndarray): Linkage matrix.

risk/{neighborhoods/neighborhoods.py → _neighborhoods/_neighborhoods.py}

@@ -1,6 +1,6 @@
 """
-risk/neighborhoods/neighborhoods
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+risk/_neighborhoods/_neighborhoods
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
 import random
@@ -13,8 +13,8 @@ from scipy.sparse import csr_matrix
 from sklearn.exceptions import DataConversionWarning
 from sklearn.metrics.pairwise import cosine_similarity
 
-from risk.log import logger
-from risk.neighborhoods.community import (
+from .._log import logger
+from ._community import (
     calculate_greedy_modularity_neighborhoods,
     calculate_label_propagation_neighborhoods,
     calculate_leiden_neighborhoods,
@@ -36,7 +36,8 @@ def get_network_neighborhoods(
     leiden_resolution: float = 1.0,
     random_seed: int = 888,
 ) -> csr_matrix:
-    """Calculate the combined neighborhoods for each node using sparse matrices.
+    """
+    Calculate the combined neighborhoods for each node using sparse matrices.
 
     Args:
         network (nx.Graph): The network graph.
@@ -125,7 +126,8 @@ def get_network_neighborhoods(
 
 
 def _set_max_row_value_to_one_sparse(matrix: csr_matrix) -> csr_matrix:
-    """Set the maximum value in each row of a sparse matrix to 1.
+    """
+    Set the maximum value in each row of a sparse matrix to 1.
 
     Args:
         matrix (csr_matrix): The input sparse matrix.
@@ -142,34 +144,14 @@ def _set_max_row_value_to_one_sparse(matrix: csr_matrix) -> csr_matrix:
     return matrix
 
 
-def _set_max_row_value_to_one(matrix: np.ndarray) -> np.ndarray:
-    """For each row in the input matrix, set the maximum value(s) to 1 and all other values to 0. This is particularly
-    useful for neighborhood matrices that have undergone multiple neighborhood detection algorithms, where the
-    maximum value in each row represents the most significant relationship per node in the combined neighborhoods.
-
-    Args:
-        matrix (np.ndarray): A 2D numpy array representing the neighborhood matrix.
-
-    Returns:
-        np.ndarray: The modified matrix where only the maximum value(s) in each row is set to 1, and others are set to 0.
-    """
-    # Find the maximum value in each row (column-wise max operation)
-    max_values = np.max(matrix, axis=1, keepdims=True)
-    # Create a boolean mask where elements are True if they are the max value in their row
-    max_mask = matrix == max_values
-    # Set all elements to 0, and then set the maximum value positions to 1
-    matrix[:] = 0  # Set everything to 0
-    matrix[max_mask] = 1  # Set only the max values to 1
-    return matrix
-
-
 def process_neighborhoods(
     network: nx.Graph,
     neighborhoods: Dict[str, Any],
     impute_depth: int = 0,
     prune_threshold: float = 0.0,
 ) -> Dict[str, Any]:
-    """Process neighborhoods based on the imputation and pruning settings.
+    """
+    Process neighborhoods based on the imputation and pruning settings.
 
     Args:
         network (nx.Graph): The network data structure used for imputing and pruning neighbors.
@@ -226,7 +208,8 @@ def _impute_neighbors(
     significant_binary_significance_matrix: np.ndarray,
     max_depth: int = 3,
 ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
-    """Impute rows with sums of zero in the significance matrix based on the closest non-zero neighbors in the network graph.
+    """
+    Impute rows with sums of zero in the significance matrix based on the closest non-zero neighbors in the network graph.
 
     Args:
         network (nx.Graph): The network graph with nodes having IDs matching the matrix indices.
@@ -262,7 +245,8 @@ def _impute_neighbors_with_similarity(
     significant_binary_significance_matrix: np.ndarray,
     max_depth: int = 3,
 ) -> Tuple[np.ndarray, np.ndarray]:
-    """Impute non-significant nodes based on the closest significant neighbors' profiles and their similarity.
+    """
+    Impute non-significant nodes based on the closest significant neighbors' profiles and their similarity.
 
     Args:
         network (nx.Graph): The network graph with nodes having IDs matching the matrix indices.
@@ -306,7 +290,8 @@ def _process_node_imputation(
     significant_binary_significance_matrix: np.ndarray,
     depth: int,
 ) -> Tuple[np.ndarray, np.ndarray]:
-    """Process the imputation for a single node based on its significant neighbors.
+    """
+    Process the imputation for a single node based on its significant neighbors.
 
     Args:
         row_index (int): The index of the significant node being processed.
@@ -391,7 +376,8 @@ def _prune_neighbors(
     significant_binary_significance_matrix: np.ndarray,
     distance_threshold: float = 0.9,
 ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
-    """Remove outliers based on their rank for edge lengths.
+    """
+    Remove outliers based on their rank for edge lengths.
 
     Args:
         network (nx.Graph): The network graph with nodes having IDs matching the matrix indices.
@@ -450,7 +436,8 @@ def _prune_neighbors(
 
 
 def _get_euclidean_distance(node1: Any, node2: Any, network: nx.Graph) -> float:
-    """Calculate the Euclidean distance between two nodes in the network.
+    """
+    Calculate the Euclidean distance between two nodes in the network.
 
     Args:
         node1 (Any): The first node.
@@ -466,7 +453,8 @@ def _get_euclidean_distance(node1: Any, node2: Any, network: nx.Graph) -> float:
 
 
 def _get_node_position(network: nx.Graph, node: Any) -> np.ndarray:
-    """Retrieve the position of a node in the network as a numpy array.
+    """
+    Retrieve the position of a node in the network as a numpy array.
 
     Args:
         network (nx.Graph): The network graph containing node positions.
@@ -485,7 +473,8 @@ def _get_node_position(network: nx.Graph, node: Any) -> np.ndarray:
 
 
 def _calculate_threshold(median_distances: List, distance_threshold: float) -> float:
-    """Calculate the distance threshold based on the given median distances and a percentile threshold.
+    """
+    Calculate the distance threshold based on the given median distances and a percentile threshold.
 
     Args:
         median_distances (List): An array of median distances.

risk/_neighborhoods/_stats/__init__.py

@@ -0,0 +1,13 @@
+"""
+risk/_neighborhoods/_stats
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+"""
+
+from ._permutation import compute_permutation_test
+from ._tests import (
+    compute_binom_test,
+    compute_chi2_test,
+    compute_hypergeom_test,
+    compute_poisson_test,
+    compute_zscore_test,
+)

risk/_neighborhoods/_stats/_permutation/__init__.py

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

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

@@ -1,6 +1,6 @@
 """
-risk/neighborhoods/stats/permutation/permutation
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+risk/_neighborhoods/_stats/_permutation/_permutation
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
 from multiprocessing import Manager, get_context
@@ -12,7 +12,7 @@ from scipy.sparse import csr_matrix
 from threadpoolctl import threadpool_limits
 from tqdm import tqdm
 
-from risk.neighborhoods.stats.permutation.test_functions import DISPATCH_TEST_FUNCTIONS
+from ._test_functions import DISPATCH_TEST_FUNCTIONS
 
 
 def compute_permutation_test(
@@ -24,7 +24,8 @@ def compute_permutation_test(
     random_seed: int = 888,
     max_workers: int = 1,
 ) -> Dict[str, Any]:
-    """Compute permutation test for enrichment and depletion in neighborhoods.
+    """
+    Compute permutation test for enrichment and depletion in neighborhoods.
 
     Args:
         neighborhoods (csr_matrix): Sparse binary matrix representing neighborhoods.
@@ -75,7 +76,8 @@ def _run_permutation_test(
     random_seed: int = 888,
     max_workers: int = 4,
 ) -> tuple:
-    """Run the permutation test to calculate depletion and enrichment counts.
+    """
+    Run the permutation test to calculate depletion and enrichment counts.
 
     Args:
         neighborhoods (csr_matrix): Sparse binary matrix representing neighborhoods.
@@ -181,7 +183,8 @@ def _permutation_process_batch(
     progress_counter: ValueProxy,
     max_workers: int,
 ) -> tuple:
-    """Process a batch of permutations in a worker process.
+    """
+    Process a batch of permutations in a worker process.
 
     Args:
         permutations (Union[List, Tuple, np.ndarray]): Permutation batch to process.

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

@@ -1,6 +1,6 @@
 """
-risk/neighborhoods/stats/permutation/test_functions
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+risk/_neighborhoods/_stats/_permutation/_test_functions
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
 import numpy as np
@@ -15,7 +15,8 @@ from scipy.sparse import csr_matrix
 def compute_neighborhood_score_by_sum(
     neighborhoods_matrix: csr_matrix, annotation_matrix: csr_matrix
 ) -> np.ndarray:
-    """Compute the sum of attribute values for each neighborhood using sparse matrices.
+    """
+    Compute the sum of attribute values for each neighborhood using sparse matrices.
 
     Args:
         neighborhoods_matrix (csr_matrix): Sparse binary matrix representing neighborhoods.
@@ -34,7 +35,8 @@ def compute_neighborhood_score_by_sum(
 def compute_neighborhood_score_by_stdev(
     neighborhoods_matrix: csr_matrix, annotation_matrix: csr_matrix
 ) -> np.ndarray:
-    """Compute the standard deviation of neighborhood scores for sparse matrices.
+    """
+    Compute the standard deviation of neighborhood scores for sparse matrices.
 
     Args:
         neighborhoods_matrix (csr_matrix): Sparse binary matrix representing neighborhoods.