risk-network 0.0.9b24__py3-none-any.whl → 0.0.9b25__py3-none-any.whl

risk/__init__.py

@@ -7,4 +7,4 @@ RISK: Regional Inference of Significant Kinships
 
 from risk.risk import RISK
 
-__version__ = "0.0.9-beta.24"
+__version__ = "0.0.9-beta.25"

risk/annotations/annotations.py

@@ -16,6 +16,7 @@ from nltk.tokenize import word_tokenize
 from nltk.corpus import stopwords
 
 from risk.log import logger
+from scipy.sparse import csr_matrix
 
 
 def _setup_nltk():
@@ -47,17 +48,15 @@ def load_annotations(
         annotations_input (Dict[str, Any]): A dictionary with annotations.
         min_nodes_per_term (int, optional): The minimum number of network nodes required for each annotation
             term to be included. Defaults to 2.
+        use_sparse (bool, optional): Whether to return the annotations matrix as a sparse matrix. Defaults to True.
 
     Returns:
-        Dict[str, Any]: A dictionary containing ordered nodes, ordered annotations, and the binary annotations matrix.
+        Dict[str, Any]: A dictionary containing ordered nodes, ordered annotations, and the sparse binary annotations
+            matrix.
 
     Raises:
         ValueError: If no annotations are found for the nodes in the network.
         ValueError: If no annotations have at least min_nodes_per_term nodes in the network.
-
-    Comment:
-        This function should be optimized to handle large networks and annotations efficiently. An attempt
-        to use sparse matrices did not yield significant performance improvements, so it was not implemented.
     """
     # Flatten the dictionary to a list of tuples for easier DataFrame creation
     flattened_annotations = [
@@ -78,7 +77,6 @@ def load_annotations(
         raise ValueError("No terms found in the annotation file for the nodes in the network.")
 
     # Filter out annotations with fewer than min_nodes_per_term occurrences
-    # This assists in reducing noise and focusing on more relevant annotations for statistical analysis
     num_terms_before_filtering = annotations_pivot.shape[1]
     annotations_pivot = annotations_pivot.loc[
         :, (annotations_pivot.sum(axis=0) >= min_nodes_per_term)
@@ -96,13 +94,15 @@ def load_annotations(
     # Extract ordered nodes and annotations
     ordered_nodes = tuple(annotations_pivot.index)
     ordered_annotations = tuple(annotations_pivot.columns)
-    # Convert the annotations_pivot matrix to a numpy array and ensure it's binary
-    annotations_pivot_numpy = (annotations_pivot.fillna(0).to_numpy() > 0).astype(int)
+    # Convert the annotations_pivot matrix to a numpy array or sparse matrix
+    annotations_pivot_binary = (annotations_pivot.fillna(0).to_numpy() > 0).astype(int)
+    # Convert the binary annotations matrix to a sparse matrix
+    annotations_pivot_binary = csr_matrix(annotations_pivot_binary)
 
     return {
         "ordered_nodes": ordered_nodes,
         "ordered_annotations": ordered_annotations,
-        "matrix": annotations_pivot_numpy,
+        "matrix": annotations_pivot_binary,
     }
 
 

risk/neighborhoods/__init__.py

@@ -4,5 +4,5 @@ risk/neighborhoods
 """
 
 from risk.neighborhoods.domains import define_domains, trim_domains
-from risk.neighborhoods.io import NeighborhoodsIO
+from risk.neighborhoods.api import NeighborhoodsAPI
 from risk.neighborhoods.neighborhoods import process_neighborhoods

risk/neighborhoods/{io.py → api.py}

@@ -1,6 +1,6 @@
 """
-risk/neighborhoods/io
-~~~~~~~~~~~~~~~~~~~~~
+risk/neighborhoods/api
+~~~~~~~~~~~~~~~~~~~~~~
 """
 
 import copy
@@ -8,6 +8,7 @@ from typing import Any, Dict, List, Tuple, Union
 
 import networkx as nx
 import numpy as np
+from scipy.sparse import csr_matrix
 
 from risk.log import logger, log_header, params
 from risk.neighborhoods.neighborhoods import get_network_neighborhoods
@@ -21,10 +22,10 @@ from risk.stats import (
 )
 
 
-class NeighborhoodsIO:
+class NeighborhoodsAPI:
     """Handles the loading of statistical results and annotation significance for neighborhoods.
 
-    The NeighborhoodsIO class provides methods to load neighborhood results from statistical tests.
+    The NeighborhoodsAPI class provides methods to load neighborhood results from statistical tests.
     """
 
     def __init__() -> None:
@@ -86,7 +87,7 @@ class NeighborhoodsIO:
         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.
@@ -396,12 +397,11 @@ class NeighborhoodsIO:
         leiden_resolution: float = 1.0,
         fraction_shortest_edges: Union[float, List, Tuple, np.ndarray] = 0.5,
         random_seed: int = 888,
-    ) -> np.ndarray:
+    ) -> csr_matrix:
         """Load significant neighborhoods for the network.
 
         Args:
             network (nx.Graph): The network graph.
-            annotations (pd.DataFrame): The matrix of 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', 'leiden', 'label_propagation',
                 'markov_clustering', 'walktrap', 'spinglass'). Defaults to 'louvain'.
@@ -413,7 +413,7 @@ class NeighborhoodsIO:
             random_seed (int, optional): Seed for random number generation. Defaults to 888.
 
         Returns:
-            np.ndarray: Neighborhood matrix calculated based on the selected distance metric.
+            csr_matrix: Sparse neighborhood matrix calculated based on the selected distance metric.
         """
         # Display the chosen distance metric
         if distance_metric == "louvain":
@@ -422,12 +422,13 @@ class NeighborhoodsIO:
             for_print_distance_metric = f"leiden (resolution={leiden_resolution})"
         else:
             for_print_distance_metric = distance_metric
+
         # Log and display neighborhood settings
         logger.debug(f"Distance metric: '{for_print_distance_metric}'")
         logger.debug(f"Edge length threshold: {fraction_shortest_edges}")
         logger.debug(f"Random seed: {random_seed}")
 
-        # Compute neighborhoods based on the network and distance metric
+        # Compute neighborhoods
         neighborhoods = get_network_neighborhoods(
             network,
             distance_metric,
@@ -437,5 +438,9 @@ class NeighborhoodsIO:
             random_seed=random_seed,
         )
 
-        # Return the computed neighborhoods
+        # Ensure the neighborhood matrix is in sparse format
+        if not isinstance(neighborhoods, csr_matrix):
+            neighborhoods = csr_matrix(neighborhoods)
+
+        # Return the sparse neighborhood matrix
         return neighborhoods

risk/network/__init__.py

@@ -3,6 +3,4 @@ risk/network
 ~~~~~~~~~~~~
 """
 
-from risk.network.graph import GraphIO
 from risk.network.io import NetworkIO
-from risk.network.plot import PlotterIO

risk/network/graph/__init__.py

@@ -3,4 +3,4 @@ risk/network/graph
 ~~~~~~~~~~~~~~~~~~
 """
 
-from risk.network.graph.io import GraphIO
+from risk.network.graph.api import GraphAPI

risk/network/graph/{io.py → api.py}

@@ -1,6 +1,6 @@
 """
-risk/network/graph/io
-~~~~~~~~~~~~~~~~~~~~~
+risk/network/graph/api
+~~~~~~~~~~~~~~~~~~~~~~
 """
 
 import copy
@@ -20,10 +20,10 @@ from risk.network.graph.network import NetworkGraph
 from risk.stats import calculate_significance_matrices
 
 
-class GraphIO:
+class GraphAPI:
     """Handles the loading of network graphs and associated data.
 
-    The GraphIO class provides methods to load and process network graphs, annotations, and neighborhoods.
+    The GraphAPI class provides methods to load and process network graphs, annotations, and neighborhoods.
     """
 
     def __init__() -> None:

risk/network/graph/summary.py

@@ -240,8 +240,12 @@ class AnalysisSummary:
         except ValueError:
             return ""  # Description not found
 
-        # Get nodes present for the annotation and sort by node label
-        nodes_present = np.where(self.annotations["matrix"][:, annotation_idx] == 1)[0]
+        # Get the column (safely) from the sparse matrix
+        column = self.annotations["matrix"][:, annotation_idx]
+        # Convert the column to a dense array if needed
+        column = column.toarray().ravel()  # Convert to a 1D dense array
+        # Get nodes present for the annotation and sort by node label - use np.where on the dense array
+        nodes_present = np.where(column == 1)[0]
         node_labels = sorted(
             self.graph.node_id_to_node_label_map[node_id]
             for node_id in nodes_present

risk/network/plotter/__init__.py

@@ -0,0 +1,6 @@
+"""
+risk/network/plot
+~~~~~~~~~~~~~~~~~
+"""
+
+from risk.network.plotter.api import PlotterAPI

risk/network/{plot/io.py → plotter/api.py}

@@ -1,6 +1,6 @@
 """
-risk/network/graph/io
-~~~~~~~~~~~~~~~~~~~~~
+risk/network/graph/api
+~~~~~~~~~~~~~~~~~~~~~~
 """
 
 from typing import List, Tuple, Union
@@ -9,13 +9,13 @@ import numpy as np
 
 from risk.log import log_header
 from risk.network.graph.network import NetworkGraph
-from risk.network.plot.network import NetworkPlotter
+from risk.network.plotter.network import NetworkPlotter
 
 
-class PlotterIO:
+class PlotterAPI:
     """Handles the loading of network plotter objects.
 
-    The PlotterIO class provides methods to load and configure NetworkPlotter objects for plotting network graphs.
+    The PlotterAPI class provides methods to load and configure NetworkPlotter objects for plotting network graphs.
     """
 
     def __init__() -> None:

risk/network/{plot → plotter}/canvas.py

@@ -10,8 +10,8 @@ import numpy as np
 
 from risk.log import params
 from risk.network.graph.network import NetworkGraph
-from risk.network.plot.utils.colors import to_rgba
-from risk.network.plot.utils.layout import calculate_bounding_box
+from risk.network.plotter.utils.colors import to_rgba
+from risk.network.plotter.utils.layout import calculate_bounding_box
 
 
 class Canvas:

risk/network/{plot → plotter}/contour.py

@@ -13,7 +13,7 @@ from scipy.stats import gaussian_kde
 
 from risk.log import params, logger
 from risk.network.graph.network import NetworkGraph
-from risk.network.plot.utils.colors import get_annotated_domain_colors, to_rgba
+from risk.network.plotter.utils.colors import get_annotated_domain_colors, to_rgba
 
 
 class Contour:

risk/network/{plot → plotter}/labels.py

@@ -12,8 +12,8 @@ import pandas as pd
 
 from risk.log import params
 from risk.network.graph.network import NetworkGraph
-from risk.network.plot.utils.colors import get_annotated_domain_colors, to_rgba
-from risk.network.plot.utils.layout import calculate_bounding_box
+from risk.network.plotter.utils.colors import get_annotated_domain_colors, to_rgba
+from risk.network.plotter.utils.layout import calculate_bounding_box
 
 TERM_DELIMITER = "::::"  # String used to separate multiple domain terms when constructing composite domain labels
 

risk/network/{plot → plotter}/network.py

@@ -11,11 +11,11 @@ import numpy as np
 
 from risk.log import params
 from risk.network.graph.network import NetworkGraph
-from risk.network.plot.canvas import Canvas
-from risk.network.plot.contour import Contour
-from risk.network.plot.labels import Labels
-from risk.network.plot.utils.colors import get_domain_colors, to_rgba
-from risk.network.plot.utils.layout import calculate_bounding_box
+from risk.network.plotter.canvas import Canvas
+from risk.network.plotter.contour import Contour
+from risk.network.plotter.labels import Labels
+from risk.network.plotter.utils.colors import get_domain_colors, to_rgba
+from risk.network.plotter.utils.layout import calculate_bounding_box
 
 
 class Network:

risk/risk.py

@@ -3,13 +3,16 @@ risk/risk
 ~~~~~~~~~
 """
 
+from risk.network import NetworkIO
 from risk.annotations import AnnotationsIO
+from risk.neighborhoods import NeighborhoodsAPI
+from risk.network.graph import GraphAPI
+from risk.network.plotter import PlotterAPI
+
 from risk.log import params, set_global_verbosity
-from risk.neighborhoods import NeighborhoodsIO
-from risk.network import GraphIO, NetworkIO, PlotterIO
 
 
-class RISK(NetworkIO, AnnotationsIO, NeighborhoodsIO, GraphIO, PlotterIO):
+class RISK(NetworkIO, AnnotationsIO, NeighborhoodsAPI, GraphAPI, PlotterAPI):
     """RISK: A class for network analysis and visualization.
 
     The RISK class integrates functionalities for loading networks, processing annotations,

risk/stats/binom.py

@@ -5,43 +5,47 @@ risk/stats/binomial
 
 from typing import Any, Dict
 
-import numpy as np
+from scipy.sparse import csr_matrix
 from scipy.stats import binom
 
 
 def compute_binom_test(
-    neighborhoods: np.ndarray, annotations: np.ndarray, null_distribution: str = "network"
+    neighborhoods: csr_matrix,
+    annotations: csr_matrix,
+    null_distribution: str = "network",
 ) -> Dict[str, Any]:
     """Compute Binomial test for enrichment and depletion in neighborhoods with selectable null distribution.
 
     Args:
-        neighborhoods (np.ndarray): Binary matrix representing neighborhoods (rows as nodes, columns as neighbors).
-        annotations (np.ndarray): Binary matrix representing annotations (rows as nodes, columns as annotations).
+        neighborhoods (csr_matrix): Sparse binary matrix representing neighborhoods.
+        annotations (csr_matrix): Sparse binary matrix representing annotations.
         null_distribution (str, optional): Type of null distribution ('network' or 'annotations'). Defaults to "network".
 
     Returns:
         Dict[str, Any]: Dictionary containing depletion and enrichment p-values.
     """
-    # Calculate the total counts of annotated nodes and neighborhood sizes
-    annotated_counts = neighborhoods @ annotations
-    neighborhood_sizes = neighborhoods.sum(axis=1, keepdims=True)
-    annotation_totals = annotations.sum(axis=0, keepdims=True)
-    total_nodes = neighborhoods.shape[1]  # Total number of nodes in the network
+    # Get the total number of nodes in the network
+    total_nodes = neighborhoods.shape[1]
 
-    # Compute p for the Binomial distribution based on the chosen null distribution
+    # Compute sums (remain sparse here)
+    neighborhood_sizes = neighborhoods.sum(axis=1)  # Row sums
+    annotation_totals = annotations.sum(axis=0)  # Column sums
+    # Compute probabilities (convert to dense)
     if null_distribution == "network":
-        p_values = (
-            annotation_totals / total_nodes
-        )  # Probability of annotation per node across the network
+        p_values = (annotation_totals / total_nodes).A.flatten()  # Dense 1D array
     elif null_distribution == "annotations":
-        p_values = annotation_totals / annotations.sum()  # Probability weighted by annotations
+        p_values = (annotation_totals / annotations.sum()).A.flatten()  # Dense 1D array
     else:
         raise ValueError(
             "Invalid null_distribution value. Choose either 'network' or 'annotations'."
         )
 
+    # Observed counts (sparse matrix multiplication)
+    annotated_counts = neighborhoods @ annotations  # 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 - 1, neighborhood_sizes, p_values)
-    depletion_pvals = binom.cdf(annotated_counts, neighborhood_sizes, 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)
 
     return {"enrichment_pvals": enrichment_pvals, "depletion_pvals": depletion_pvals}

risk/stats/chi2.py

@@ -4,51 +4,63 @@ risk/stats/chi2
 """
 
 from typing import Any, Dict
+
 import numpy as np
+from scipy.sparse import csr_matrix
 from scipy.stats import chi2
 
 
 def compute_chi2_test(
-    neighborhoods: np.ndarray, annotations: np.ndarray, null_distribution: str = "network"
+    neighborhoods: csr_matrix,
+    annotations: csr_matrix,
+    null_distribution: str = "network",
 ) -> Dict[str, Any]:
     """Compute chi-squared test for enrichment and depletion in neighborhoods with selectable null distribution.
 
     Args:
-        neighborhoods (np.ndarray): Binary matrix representing neighborhoods.
-        annotations (np.ndarray): Binary matrix representing annotations.
+        neighborhoods (csr_matrix): Sparse binary matrix representing neighborhoods.
+        annotations (csr_matrix): Sparse binary matrix representing annotations.
         null_distribution (str, optional): Type of null distribution ('network' or 'annotations'). Defaults to "network".
 
     Returns:
         Dict[str, Any]: Dictionary containing depletion and enrichment p-values.
     """
-    # Get the total number of nodes in the network
+    # Total number of nodes in the network
     total_node_count = neighborhoods.shape[0]
 
     if null_distribution == "network":
         # Case 1: Use all nodes as the background
         background_population = total_node_count
-        neighborhood_sums = np.sum(
-            neighborhoods, axis=0, keepdims=True
-        ).T  # Column sums of neighborhoods
-        annotation_sums = np.sum(annotations, axis=0, keepdims=True)  # Column sums of annotations
+        neighborhood_sums = neighborhoods.sum(axis=0)  # Column sums of neighborhoods
+        annotation_sums = annotations.sum(axis=0)  # Column sums of annotations
     elif null_distribution == "annotations":
         # Case 2: Only consider nodes with at least one annotation
-        annotated_nodes = np.sum(annotations, axis=1) > 0
-        background_population = np.sum(annotated_nodes)
-        neighborhood_sums = np.sum(neighborhoods[annotated_nodes], axis=0, keepdims=True).T
-        annotation_sums = np.sum(annotations[annotated_nodes], axis=0, keepdims=True)
+        annotated_nodes = (
+            np.ravel(annotations.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
+        annotation_sums = annotations[annotated_nodes].sum(
+            axis=0
+        )  # Annotation sums for annotated nodes
     else:
         raise ValueError(
             "Invalid null_distribution value. Choose either 'network' or 'annotations'."
         )
 
+    # Convert to dense arrays for downstream computations
+    neighborhood_sums = np.asarray(neighborhood_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 @ annotations  # Shape: (neighborhoods, annotations)
     # Expected values under the null
     expected = (neighborhood_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, (observed - expected) ** 2 / expected, 0)
+        chi2_stat = np.where(expected > 0, np.power(observed - expected, 2) / expected, 0)
 
     # Compute p-values for enrichment (upper tail) and depletion (lower tail)
     enrichment_pvals = chi2.sf(chi2_stat, df=1)  # Survival function for upper tail

risk/stats/hypergeom.py

@@ -6,44 +6,54 @@ risk/stats/hypergeom
 from typing import Any, Dict
 
 import numpy as np
+from scipy.sparse import csr_matrix
 from scipy.stats import hypergeom
 
 
 def compute_hypergeom_test(
-    neighborhoods: np.ndarray, annotations: np.ndarray, null_distribution: str = "network"
+    neighborhoods: csr_matrix,
+    annotations: 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 neighborhoods with selectable null distribution.
 
     Args:
-        neighborhoods (np.ndarray): Binary matrix representing neighborhoods.
-        annotations (np.ndarray): Binary matrix representing annotations.
+        neighborhoods (csr_matrix): Sparse binary matrix representing neighborhoods.
+        annotations (csr_matrix): Sparse binary matrix representing annotations.
         null_distribution (str, optional): Type of null distribution ('network' or 'annotations'). Defaults to "network".
 
     Returns:
         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]
+    total_nodes = neighborhoods.shape[1]
+
+    # Compute sums
+    neighborhood_sums = neighborhoods.sum(axis=0).A.flatten()  # Convert to dense array
+    annotation_sums = annotations.sum(axis=0).A.flatten()  # Convert to dense array
 
     if null_distribution == "network":
-        # Case 1: Use all nodes as the background
-        background_population = total_node_count
-        neighborhood_sums = np.sum(neighborhoods, axis=0, keepdims=True).T
-        annotation_sums = np.sum(annotations, axis=0, keepdims=True)
+        background_population = total_nodes
     elif null_distribution == "annotations":
-        # Case 2: Only consider nodes with at least one annotation
-        annotated_nodes = np.sum(annotations, axis=1) > 0
-        background_population = np.sum(annotated_nodes)
-        neighborhood_sums = np.sum(neighborhoods[annotated_nodes], axis=0, keepdims=True).T
-        annotation_sums = np.sum(annotations[annotated_nodes], axis=0, keepdims=True)
+        annotated_nodes = annotations.sum(axis=1).A.flatten() > 0  # Boolean mask
+        background_population = annotated_nodes.sum()
+        neighborhood_sums = neighborhoods[annotated_nodes].sum(axis=0).A.flatten()
+        annotation_sums = annotations[annotated_nodes].sum(axis=0).A.flatten()
     else:
         raise ValueError(
             "Invalid null_distribution value. Choose either 'network' or 'annotations'."
         )
 
-    # Matrix multiplication for annotated nodes in each neighborhood
-    annotated_in_neighborhood = neighborhoods.T @ annotations
-    # Calculate depletion and enrichment p-values using the hypergeometric distribution
+    # Observed counts
+    annotated_in_neighborhood = neighborhoods.T @ annotations  # Sparse result
+    annotated_in_neighborhood = annotated_in_neighborhood.toarray()  # Convert to dense
+    # Align shapes for broadcasting
+    neighborhood_sums = neighborhood_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
     )

risk/stats/permutation/permutation.py

@@ -3,11 +3,12 @@ risk/stats/permutation/permutation
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
-from multiprocessing import get_context, shared_memory, Manager
+from multiprocessing import get_context, Manager
 from multiprocessing.managers import ValueProxy
 from typing import Any, Callable, Dict, List, Tuple, Union
 
 import numpy as np
+from scipy.sparse import csr_matrix
 from threadpoolctl import threadpool_limits
 from tqdm import tqdm
 
@@ -15,8 +16,8 @@ from risk.stats.permutation.test_functions import DISPATCH_TEST_FUNCTIONS
 
 
 def compute_permutation_test(
-    neighborhoods: np.ndarray,
-    annotations: np.ndarray,
+    neighborhoods: csr_matrix,
+    annotations: csr_matrix,
     score_metric: str = "sum",
     null_distribution: str = "network",
     num_permutations: int = 1000,
@@ -26,9 +27,9 @@ def compute_permutation_test(
     """Compute permutation test for enrichment and depletion in neighborhoods.
 
     Args:
-        neighborhoods (np.ndarray): Binary matrix representing neighborhoods.
-        annotations (np.ndarray): Binary matrix representing annotations.
-        score_metric (str, optional): Metric to use for scoring ('sum', 'mean', etc.). Defaults to "sum".
+        neighborhoods (csr_matrix): Sparse binary matrix representing neighborhoods.
+        annotations (csr_matrix): Sparse binary matrix representing annotations.
+        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 'annotations'). Defaults to "network".
         num_permutations (int, optional): Number of permutations to run. Defaults to 1000.
         random_seed (int, optional): Seed for random number generation. Defaults to 888.
@@ -66,19 +67,19 @@ def compute_permutation_test(
 
 
 def _run_permutation_test(
-    neighborhoods: np.ndarray,
-    annotations: np.ndarray,
+    neighborhoods: csr_matrix,
+    annotations: csr_matrix,
     neighborhood_score_func: Callable,
     null_distribution: str = "network",
     num_permutations: int = 1000,
     random_seed: int = 888,
     max_workers: int = 4,
 ) -> tuple:
-    """Run a permutation test to calculate enrichment and depletion counts.
+    """Run the permutation test to calculate depletion and enrichment counts.
 
     Args:
-        neighborhoods (np.ndarray): The neighborhood matrix.
-        annotations (np.ndarray): The annotation matrix.
+        neighborhoods (csr_matrix): Sparse binary matrix representing neighborhoods.
+        annotations (csr_matrix): Sparse binary matrix representing annotations.
         neighborhood_score_func (Callable): Function to calculate neighborhood scores.
         null_distribution (str, optional): Type of null distribution ('network' or 'annotations'). Defaults to "network".
         num_permutations (int, optional): Number of permutations. Defaults to 1000.
@@ -100,8 +101,8 @@ def _run_permutation_test(
             "Invalid null_distribution value. Choose either 'network' or 'annotations'."
         )
 
-    # Replace NaNs with zeros in the annotations matrix
-    annotations[np.isnan(annotations)] = 0
+    # Replace NaNs with zeros in the sparse annotations matrix
+    annotations.data[np.isnan(annotations.data)] = 0
     annotation_matrix_obsv = annotations[idxs]
     neighborhoods_matrix_obsv = neighborhoods.T[idxs].T
     # Calculate observed neighborhood scores
@@ -131,45 +132,33 @@ def _run_permutation_test(
         permutations[i * batch_size : (i + 1) * batch_size] for i in range(max_workers)
     ]
 
-    # Create shared memory for annotations
-    shm_annotations = shared_memory.SharedMemory(create=True, size=annotations.nbytes)
-    shared_annotations = np.ndarray(
-        annotations.shape, dtype=annotations.dtype, buffer=shm_annotations.buf
-    )
-    np.copyto(shared_annotations, annotations)
-
     # Execute the permutation test using multiprocessing
-    try:
-        with ctx.Pool(max_workers) as pool:
-            with tqdm(total=total_progress, desc="Total progress", position=0) as progress:
-                # Prepare parameters for multiprocessing
-                params_list = [
-                    (
-                        permutation_batches[i],  # Pass the batch of precomputed permutations
-                        annotations,
-                        neighborhoods_matrix_obsv,
-                        observed_neighborhood_scores,
-                        neighborhood_score_func,
-                        num_permutations,
-                        progress_counter,
-                        max_workers,
-                    )
-                    for i in range(max_workers)
-                ]
-
-                # Start the permutation process in parallel
-                results = pool.starmap_async(_permutation_process_batch, params_list, chunksize=1)
-
-                # Update progress bar based on progress_counter
-                while not results.ready():
-                    progress.update(progress_counter.value - progress.n)
-                    results.wait(0.1)  # Wait for 100ms
-                # Ensure progress bar reaches 100%
-                progress.update(total_progress - progress.n)
-    finally:
-        # Clean up shared memory
-        shm_annotations.close()
-        shm_annotations.unlink()
+    with ctx.Pool(max_workers) as pool:
+        with tqdm(total=total_progress, desc="Total progress", position=0) as progress:
+            # Prepare parameters for multiprocessing
+            params_list = [
+                (
+                    permutation_batches[i],  # Pass the batch of precomputed permutations
+                    annotations,
+                    neighborhoods_matrix_obsv,
+                    observed_neighborhood_scores,
+                    neighborhood_score_func,
+                    num_permutations,
+                    progress_counter,
+                    max_workers,
+                )
+                for i in range(max_workers)
+            ]
+
+            # Start the permutation process in parallel
+            results = pool.starmap_async(_permutation_process_batch, params_list, chunksize=1)
+
+            # Update progress bar based on progress_counter
+            while not results.ready():
+                progress.update(progress_counter.value - progress.n)
+                results.wait(0.1)  # Wait for 100ms
+            # Ensure progress bar reaches 100%
+            progress.update(total_progress - progress.n)
 
     # Accumulate results from each worker
     for local_counts_depletion, local_counts_enrichment in results.get():
@@ -181,8 +170,8 @@ def _run_permutation_test(
 
 def _permutation_process_batch(
     permutations: Union[List, Tuple, np.ndarray],
-    annotation_matrix: np.ndarray,
-    neighborhoods_matrix_obsv: np.ndarray,
+    annotation_matrix: csr_matrix,
+    neighborhoods_matrix_obsv: csr_matrix,
     observed_neighborhood_scores: np.ndarray,
     neighborhood_score_func: Callable,
     num_permutations: int,
@@ -193,8 +182,8 @@ def _permutation_process_batch(
 
     Args:
         permutations (Union[List, Tuple, np.ndarray]): Permutation batch to process.
-        annotation_matrix (np.ndarray): The annotation matrix.
-        neighborhoods_matrix_obsv (np.ndarray): Observed neighborhoods matrix.
+        annotation_matrix (csr_matrix): Sparse binary matrix representing annotations.
+        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.
         num_permutations (int): Number of total permutations across all subsets.

risk/stats/permutation/test_functions.py

@@ -4,6 +4,7 @@ risk/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.
@@ -11,46 +12,53 @@ import numpy as np
 
 
 def compute_neighborhood_score_by_sum(
-    neighborhoods_matrix: np.ndarray, annotation_matrix: np.ndarray
+    neighborhoods_matrix: csr_matrix, annotation_matrix: csr_matrix
 ) -> np.ndarray:
-    """Compute the sum of attribute values for each neighborhood.
+    """Compute the sum of attribute values for each neighborhood using sparse matrices.
 
     Args:
-        neighborhoods_matrix (np.ndarray): Binary matrix representing neighborhoods.
-        annotation_matrix (np.ndarray): Matrix representing annotation values.
+        neighborhoods_matrix (csr_matrix): Sparse binary matrix representing neighborhoods.
+        annotation_matrix (csr_matrix): Sparse matrix representing annotation values.
 
     Returns:
-        np.ndarray: Sum of attribute values for each neighborhood.
+        np.ndarray: Dense array of summed attribute values for each neighborhood.
     """
     # Calculate the neighborhood score as the dot product of neighborhoods and annotations
-    neighborhood_sum = np.dot(neighborhoods_matrix, annotation_matrix)
-    return neighborhood_sum
+    neighborhood_score = neighborhoods_matrix @ annotation_matrix  # Sparse matrix multiplication
+    # Convert the result to a dense array for downstream calculations
+    neighborhood_score_dense = neighborhood_score.toarray()
+    return neighborhood_score_dense
 
 
 def compute_neighborhood_score_by_stdev(
-    neighborhoods_matrix: np.ndarray, annotation_matrix: np.ndarray
+    neighborhoods_matrix: csr_matrix, annotation_matrix: csr_matrix
 ) -> np.ndarray:
-    """Compute the standard deviation of neighborhood scores.
+    """Compute the standard deviation of neighborhood scores for sparse matrices.
 
     Args:
-        neighborhoods_matrix (np.ndarray): Binary matrix representing neighborhoods.
-        annotation_matrix (np.ndarray): Matrix representing annotation values.
+        neighborhoods_matrix (csr_matrix): Sparse binary matrix representing neighborhoods.
+        annotation_matrix (csr_matrix): Sparse matrix representing annotation values.
 
     Returns:
         np.ndarray: Standard deviation of the neighborhood scores.
     """
     # Calculate the neighborhood score as the dot product of neighborhoods and annotations
-    neighborhood_score = np.dot(neighborhoods_matrix, annotation_matrix)
-    # Calculate the number of elements in each neighborhood
-    N = np.sum(neighborhoods_matrix, axis=1)
+    neighborhood_score = neighborhoods_matrix @ annotation_matrix  # Sparse matrix multiplication
+    # Calculate the number of elements in each neighborhood (sum of rows)
+    N = neighborhoods_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 neighborhood scores
-    M = neighborhood_score / N[:, None]
+    M = neighborhood_score.multiply(1 / N[:, None]).toarray()  # Sparse element-wise division
     # Compute the mean of squares (EXX) directly using squared annotation matrix
-    EXX = np.dot(neighborhoods_matrix, annotation_matrix**2) / N[:, None]
+    annotation_squared = annotation_matrix.multiply(annotation_matrix)  # Element-wise squaring
+    EXX = (neighborhoods_matrix @ annotation_squared).multiply(1 / N[:, None]).toarray()
     # Calculate variance as EXX - M^2
-    variance = EXX - M**2
+    variance = EXX - np.power(M, 2)
     # Compute the standard deviation as the square root of the variance
     neighborhood_stdev = np.sqrt(variance)
+    # Replace np.nan back with zeros in case N was 0 (no elements in the neighborhood)
+    neighborhood_stdev[np.isnan(neighborhood_stdev)] = 0
     return neighborhood_stdev
 
 

risk/stats/poisson.py

@@ -6,39 +6,45 @@ risk/stats/poisson
 from typing import Any, Dict
 
 import numpy as np
+from scipy.sparse import csr_matrix
 from scipy.stats import poisson
 
 
 def compute_poisson_test(
-    neighborhoods: np.ndarray, annotations: np.ndarray, null_distribution: str = "network"
+    neighborhoods: csr_matrix,
+    annotations: csr_matrix,
+    null_distribution: str = "network",
 ) -> Dict[str, Any]:
-    """Compute Poisson test for enrichment and depletion in neighborhoods with selectable null distribution.
+    """
+    Compute Poisson test for enrichment and depletion in neighborhoods with selectable null distribution.
 
     Args:
-        neighborhoods (np.ndarray): Binary matrix representing neighborhoods.
-        annotations (np.ndarray): Binary matrix representing annotations.
+        neighborhoods (csr_matrix): Sparse binary matrix representing neighborhoods.
+        annotations (csr_matrix): Sparse binary matrix representing annotations.
         null_distribution (str, optional): Type of null distribution ('network' or 'annotations'). Defaults to "network".
 
     Returns:
         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
+    annotated_in_neighborhood = neighborhoods @ annotations  # Sparse result
+    # Convert annotated counts to dense for downstream calculations
+    annotated_in_neighborhood_dense = annotated_in_neighborhood.toarray()
 
     # Compute lambda_expected based on the chosen null distribution
     if null_distribution == "network":
         # Use the mean across neighborhoods (axis=1)
-        lambda_expected = np.mean(annotated_in_neighborhood, axis=1, keepdims=True)
+        lambda_expected = np.mean(annotated_in_neighborhood_dense, axis=1, keepdims=True)
     elif null_distribution == "annotations":
         # Use the mean across annotations (axis=0)
-        lambda_expected = np.mean(annotated_in_neighborhood, axis=0, keepdims=True)
+        lambda_expected = np.mean(annotated_in_neighborhood_dense, axis=0, keepdims=True)
     else:
         raise ValueError(
             "Invalid null_distribution value. Choose either 'network' or 'annotations'."
         )
 
     # Compute p-values for enrichment and depletion using Poisson distribution
-    enrichment_pvals = 1 - poisson.cdf(annotated_in_neighborhood - 1, lambda_expected)
-    depletion_pvals = poisson.cdf(annotated_in_neighborhood, lambda_expected)
+    enrichment_pvals = 1 - poisson.cdf(annotated_in_neighborhood_dense - 1, lambda_expected)
+    depletion_pvals = poisson.cdf(annotated_in_neighborhood_dense, lambda_expected)
 
     return {"enrichment_pvals": enrichment_pvals, "depletion_pvals": depletion_pvals}

risk/stats/zscore.py

@@ -6,55 +6,61 @@ risk/stats/zscore
 from typing import Any, Dict
 
 import numpy as np
+from scipy.sparse import csr_matrix
 from scipy.stats import norm
 
 
 def compute_zscore_test(
-    neighborhoods: np.ndarray, annotations: np.ndarray, null_distribution: str = "network"
+    neighborhoods: csr_matrix,
+    annotations: csr_matrix,
+    null_distribution: str = "network",
 ) -> Dict[str, Any]:
-    """Compute Z-score test for enrichment and depletion in neighborhoods with selectable null distribution.
+    """
+    Compute Z-score test for enrichment and depletion in neighborhoods with selectable null distribution.
 
     Args:
-        neighborhoods (np.ndarray): Binary matrix representing neighborhoods.
-        annotations (np.ndarray): Binary matrix representing annotations.
+        neighborhoods (csr_matrix): Sparse binary matrix representing neighborhoods.
+        annotations (csr_matrix): Sparse binary matrix representing annotations.
         null_distribution (str, optional): Type of null distribution ('network' or 'annotations'). Defaults to "network".
 
     Returns:
         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]
+    # Total number of nodes in the network
+    total_node_count = neighborhoods.shape[1]
 
+    # Compute sums
     if null_distribution == "network":
-        # Case 1: Use all nodes as the background
         background_population = total_node_count
-        neighborhood_sums = np.sum(neighborhoods, axis=0, keepdims=True).T
-        annotation_sums = np.sum(annotations, axis=0, keepdims=True)
+        neighborhood_sums = neighborhoods.sum(axis=0).A.flatten()  # Dense column sums
+        annotation_sums = annotations.sum(axis=0).A.flatten()  # Dense row sums
     elif null_distribution == "annotations":
-        # Case 2: Only consider nodes with at least one annotation
-        annotated_nodes = np.sum(annotations, axis=1) > 0
-        background_population = np.sum(annotated_nodes)
-        neighborhood_sums = np.sum(neighborhoods[annotated_nodes], axis=0, keepdims=True).T
-        annotation_sums = np.sum(annotations[annotated_nodes], axis=0, keepdims=True)
+        annotated_nodes = annotations.sum(axis=1).A.flatten() > 0  # Dense boolean mask
+        background_population = annotated_nodes.sum()
+        neighborhood_sums = neighborhoods[annotated_nodes].sum(axis=0).A.flatten()
+        annotation_sums = annotations[annotated_nodes].sum(axis=0).A.flatten()
     else:
         raise ValueError(
             "Invalid null_distribution value. Choose either 'network' or 'annotations'."
         )
 
-    # Matrix multiplication for annotated nodes in each neighborhood
-    observed = neighborhoods.T @ annotations
-    # Compute expected values under the null distribution
+    # Observed values
+    observed = (neighborhoods.T @ annotations).toarray()  # Convert sparse result to dense
+    # Expected values under the null
+    neighborhood_sums = neighborhood_sums.reshape(-1, 1)  # Ensure correct shape
+    annotation_sums = annotation_sums.reshape(1, -1)  # Ensure correct shape
     expected = (neighborhood_sums @ annotation_sums) / background_population
-    # Compute standard deviation under the null distribution
+
+    # Standard deviation under the null
     std_dev = np.sqrt(
         expected
         * (1 - annotation_sums / background_population)
         * (1 - neighborhood_sums / background_population)
     )
-    # Avoid division by zero
-    std_dev[std_dev == 0] = np.nan  # Mark invalid computations
+    std_dev[std_dev == 0] = np.nan  # Avoid division by zero
     # Compute Z-scores
     z_scores = (observed - expected) / std_dev
+
     # Convert Z-scores to depletion and enrichment p-values
     enrichment_pvals = norm.sf(z_scores)  # Upper tail
     depletion_pvals = norm.cdf(z_scores)  # Lower tail

{risk_network-0.0.9b24.dist-info → risk_network-0.0.9b25.dist-info}/METADATA

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

risk_network-0.0.9b25.dist-info/RECORD

@@ -0,0 +1,44 @@
+risk/__init__.py,sha256=Rgsnt64VMhbyTleA_DXr5VcFJG6748i86zd0VZHy9r4,127
+risk/constants.py,sha256=XInRaH78Slnw_sWgAsBFbUHkyA0h0jL0DKGuQNbOvjM,550
+risk/risk.py,sha256=s827_lRknFseOP9O4zW8sP-IcCd2EzrpV_tnVY_tz5s,1104
+risk/annotations/__init__.py,sha256=parsbcux1U4urpUqh9AdzbDWuLj9HlMidycMPkpSQFo,179
+risk/annotations/annotations.py,sha256=XmVuLL5NFAj6F30fZY22N8nb4LK6sig7fE0NXL1iZp8,14497
+risk/annotations/io.py,sha256=z1AJySsU-KL_IYuHa7j3nvuczmOHgK3WfaQ4TRunvrA,10499
+risk/log/__init__.py,sha256=7LxDysQu7doi0LAvlY2YbjN6iJH0fNknqy8lSLgeljo,217
+risk/log/console.py,sha256=PgjyEvyhYLUSHXPUKEqOmxsDsfrjPICIgqo_cAHq0N8,4575
+risk/log/parameters.py,sha256=VtwfMzLU1xI4yji3-Ch5vHjH-KdwTfwaEMmi7hFQTs0,5716
+risk/neighborhoods/__init__.py,sha256=Q74HwTH7okI-vaskJPy2bYwb5sNjGASTzJ6m8V8arCU,234
+risk/neighborhoods/api.py,sha256=KdUouMHJPwvePJGdz7Ck1GWYhN96QDb_SuPyTt3KwAc,23515
+risk/neighborhoods/community.py,sha256=VIDvB-SsMDDvWkUaYXf_E-gcg0HELMVv2MKshPwJAFQ,15480
+risk/neighborhoods/domains.py,sha256=MufM4cbvP3HrJyESOuGT0wYD_cz3rjT0SGqEnbytkh8,12523
+risk/neighborhoods/neighborhoods.py,sha256=bBUY7hXqcsOoAEkPdRoRNuj36WsllXicmz_LxZfEuyw,21186
+risk/network/__init__.py,sha256=oVi3FA1XXKD84014Cykq-9bpX4_s0F3aAUfNOU-07Qw,73
+risk/network/geometry.py,sha256=omyb9afSKMUtQ-RKVHUoRyxJifOW0ASenHjyCjg43kg,6836
+risk/network/io.py,sha256=JV5hqf1oIwWUVw07BjhD0qACQGbtIeA8NSMDcFql88k,23465
+risk/network/graph/__init__.py,sha256=ziGJew3yhtqvrb9LUuneDu_LwW2Wa9vd4UuhoL5l1CA,91
+risk/network/graph/api.py,sha256=Ag4PjFTX6BUvmW7ZdfIgwdsr8URigX9jD9yEFRXUxrU,8220
+risk/network/graph/network.py,sha256=KdIBM_-flHMWcBK4RUjU_QRfOZIf_yv9fv4L7AOLkqU,12199
+risk/network/graph/summary.py,sha256=8IenFZfhyzcg5aGNJp7Zjb0Umy0mFNmJlfwXcO7y8MU,10311
+risk/network/plotter/__init__.py,sha256=ixXQxpBVpNIz1y9tUHZ7CiJmGfewvbvjuB1LQ-AIf1s,93
+risk/network/plotter/api.py,sha256=cLZHq-rn_5FJwIWM5hYlQMobPmaxCE-P2iqgxTDIOTQ,1860
+risk/network/plotter/canvas.py,sha256=l-Se86DMDJMHh8Yn-_hsl0_ipoazHLJGRCqXcc9HK4M,13498
+risk/network/plotter/contour.py,sha256=svi76suYlVYq2VoDQxXmun8Hmo0lI2CQRjAyHg0qdhk,15490
+risk/network/plotter/labels.py,sha256=QesD1ybseA6ldLmWMqVaAqSPR34yVEgEzXzg1AKQD6o,45513
+risk/network/plotter/network.py,sha256=wcBf1GaM1wPzW-iXTrLzOmlG2_9wwfll_hJUzUO2u2Y,19917
+risk/network/plotter/utils/colors.py,sha256=EFlIUZ3MGSKoHeZi9cgR6uLKK5GGJ4QzE6lmnrHViLw,18967
+risk/network/plotter/utils/layout.py,sha256=2P4Bqi1dGiX9KsriLYqiq1KlHpsMdZemAUza4WcYoNA,3634
+risk/stats/__init__.py,sha256=1CPRtT1LDwudrvFgkVtSom8cp4cM7b4X6b4fHPaNHw0,405
+risk/stats/binom.py,sha256=8Qwcxnq1u-AycwQs_sQxwuxgkgDpES-A-kIcj4fRc3g,2032
+risk/stats/chi2.py,sha256=MGFNrWP40i9TxnMsZYbDgqdMrN_Fe0xFsnWU8xNsVSs,3046
+risk/stats/hypergeom.py,sha256=VfQBtpgSGG826uBP1WyBMavP3ylZnhponUZ2rHFdGAE,2502
+risk/stats/poisson.py,sha256=_KHe9g8XNRD4-Q486zx2UgHCO2QyvBOiHuX3hRZLEqc,2050
+risk/stats/stats.py,sha256=y2DMJF3uKRIWRyYiCd2Kwxa-EqOzX5HsMBms_Vw6wK8,7322
+risk/stats/zscore.py,sha256=Jx9cLKAHiDnrgW_Su9KZYYQiTVsuyJMC7vXBusnEI-c,2648
+risk/stats/permutation/__init__.py,sha256=OLmYLm2uj96hPsSaUs0vUqFYw6Thwch_aHtpL7L0ZFw,127
+risk/stats/permutation/permutation.py,sha256=693DyWPNz6L_wCL06F7gj2u1df0qVc4F3Na36jCLYMI,10577
+risk/stats/permutation/test_functions.py,sha256=D3XMPM8CasUNytWSRce22TI6KK6XulYn5uGG4lWxaHs,3120
+risk_network-0.0.9b25.dist-info/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+risk_network-0.0.9b25.dist-info/METADATA,sha256=XJSNAooxsGNwoMnp-6Nx0YCnp1zBWVm9ej2yjtUUPDg,47627
+risk_network-0.0.9b25.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+risk_network-0.0.9b25.dist-info/top_level.txt,sha256=NX7C2PFKTvC1JhVKv14DFlFAIFnKc6Lpsu1ZfxvQwVw,5
+risk_network-0.0.9b25.dist-info/RECORD,,

risk/network/plot/__init__.py

@@ -1,6 +0,0 @@
-"""
-risk/network/plot
-~~~~~~~~~~~~~~~~~
-"""
-
-from risk.network.plot.io import PlotterIO

risk_network-0.0.9b24.dist-info/RECORD

@@ -1,44 +0,0 @@
-risk/__init__.py,sha256=m6D5527XrsqQAj0y2VgVhiWu-5vdX8wBFcTqP397l7g,127
-risk/constants.py,sha256=XInRaH78Slnw_sWgAsBFbUHkyA0h0jL0DKGuQNbOvjM,550
-risk/risk.py,sha256=M7OxLNrkIwmI7yvbdMGkSACwIgJFRbPnB_L5ZaayhrE,1035
-risk/annotations/__init__.py,sha256=parsbcux1U4urpUqh9AdzbDWuLj9HlMidycMPkpSQFo,179
-risk/annotations/annotations.py,sha256=rekG32mUOyh9wQvVrye037vz9f6IiPT3JPFDzSV5ROg,14534
-risk/annotations/io.py,sha256=z1AJySsU-KL_IYuHa7j3nvuczmOHgK3WfaQ4TRunvrA,10499
-risk/log/__init__.py,sha256=7LxDysQu7doi0LAvlY2YbjN6iJH0fNknqy8lSLgeljo,217
-risk/log/console.py,sha256=PgjyEvyhYLUSHXPUKEqOmxsDsfrjPICIgqo_cAHq0N8,4575
-risk/log/parameters.py,sha256=VtwfMzLU1xI4yji3-Ch5vHjH-KdwTfwaEMmi7hFQTs0,5716
-risk/neighborhoods/__init__.py,sha256=GUS9uT4BIqTOs2_htYjKM_7MmyS_LtHnVqLWCNRkRrU,232
-risk/neighborhoods/community.py,sha256=VIDvB-SsMDDvWkUaYXf_E-gcg0HELMVv2MKshPwJAFQ,15480
-risk/neighborhoods/domains.py,sha256=MufM4cbvP3HrJyESOuGT0wYD_cz3rjT0SGqEnbytkh8,12523
-risk/neighborhoods/io.py,sha256=oL_Xn5qyqwdXapHHQQlyqcUshE3wb9fn1WWePiFNC2g,23429
-risk/neighborhoods/neighborhoods.py,sha256=bBUY7hXqcsOoAEkPdRoRNuj36WsllXicmz_LxZfEuyw,21186
-risk/network/__init__.py,sha256=70tppeoGooNknUwAlJudtwlnG8G0jZ_bOR7TZpLOvs0,152
-risk/network/geometry.py,sha256=omyb9afSKMUtQ-RKVHUoRyxJifOW0ASenHjyCjg43kg,6836
-risk/network/io.py,sha256=JV5hqf1oIwWUVw07BjhD0qACQGbtIeA8NSMDcFql88k,23465
-risk/network/graph/__init__.py,sha256=ljD51OEvJ4HrJQJbOZJ5kwyB_9oltJnc-Znfo87xgPM,89
-risk/network/graph/io.py,sha256=yundGlbKx9SCuE0vf5NeqY3ADyUHGp-h15xbKNEpGGs,8216
-risk/network/graph/network.py,sha256=KdIBM_-flHMWcBK4RUjU_QRfOZIf_yv9fv4L7AOLkqU,12199
-risk/network/graph/summary.py,sha256=8ukRlCPLZjkzvVc80QlNmXVRFY7A9yCnDWpfT3IV7ek,10067
-risk/network/plot/__init__.py,sha256=v_rKZgpq5tnOVNEMdOLhyZvBeWl7Mgc9ZXkZ9LQ8Mso,88
-risk/network/plot/canvas.py,sha256=sqLFUIwDRPb-va2oQMwp7mF-NefrA3pWUuajQgvSEug,13492
-risk/network/plot/contour.py,sha256=dO_zaVMaEY1WKaJXwulZrh9Ybvk3A3531ZQ6gXWMuuM,15487
-risk/network/plot/io.py,sha256=1_zJqbDvJra33PjJ0jMaA-WhqW0x1OXcf2kSPpaccOM,1853
-risk/network/plot/labels.py,sha256=re9hvwFG5fLjjtbKb6Vs_CkwqWeSWwyaPpDiwDERNqY,45507
-risk/network/plot/network.py,sha256=XUYuz8ER_ilvs7ZvRzsYfrQafsCD5P8f3EqWuWijWnU,19902
-risk/network/plot/utils/colors.py,sha256=EFlIUZ3MGSKoHeZi9cgR6uLKK5GGJ4QzE6lmnrHViLw,18967
-risk/network/plot/utils/layout.py,sha256=2P4Bqi1dGiX9KsriLYqiq1KlHpsMdZemAUza4WcYoNA,3634
-risk/stats/__init__.py,sha256=1CPRtT1LDwudrvFgkVtSom8cp4cM7b4X6b4fHPaNHw0,405
-risk/stats/binom.py,sha256=b70_C4-AnXJiHfjMOas0tDP8N3-M4_0zYYaZkDKVPxU,2015
-risk/stats/chi2.py,sha256=mhdppli1KI_F-dIvX6MALgnWpjS_89aZVENofa6u41o,2604
-risk/stats/hypergeom.py,sha256=oc39f02ViB1vQ-uaDrxG_tzAT6dxQBRjc88EK2EGn78,2282
-risk/stats/poisson.py,sha256=polLgwS08MTCNzupYdmMUoEUYrJOjAbcYtYwjlfeE5Y,1803
-risk/stats/stats.py,sha256=y2DMJF3uKRIWRyYiCd2Kwxa-EqOzX5HsMBms_Vw6wK8,7322
-risk/stats/zscore.py,sha256=D_v1tBnhLbmrRG0Ats3e1L75GKsen_ja0uTv6xEpWGA,2570
-risk/stats/permutation/__init__.py,sha256=OLmYLm2uj96hPsSaUs0vUqFYw6Thwch_aHtpL7L0ZFw,127
-risk/stats/permutation/permutation.py,sha256=UBR0j6sqFowwR0tLWWr0bLtCWgRx7LLv-0P0OPmA4a4,10943
-risk/stats/permutation/test_functions.py,sha256=lftOude6hee0pyR80HlBD32522JkDoN5hrKQ9VEbuoY,2345
-risk_network-0.0.9b24.dist-info/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
-risk_network-0.0.9b24.dist-info/METADATA,sha256=vkkt_9ILy_6UdguZ8AXwMi_3MeQoHJ4eySAR7pSs-7o,47627
-risk_network-0.0.9b24.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-risk_network-0.0.9b24.dist-info/top_level.txt,sha256=NX7C2PFKTvC1JhVKv14DFlFAIFnKc6Lpsu1ZfxvQwVw,5
-risk_network-0.0.9b24.dist-info/RECORD,,