risk-network 0.0.3b3__py3-none-any.whl → 0.0.4__py3-none-any.whl

risk/stats/permutation/permutation.py

@@ -0,0 +1,212 @@
+"""
+risk/stats/permutation/permutation
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+"""
+
+from multiprocessing import get_context, Manager
+from tqdm import tqdm
+from typing import Any, Callable, Dict
+
+import numpy as np
+from threadpoolctl import threadpool_limits
+
+from risk.stats.permutation.test_functions import DISPATCH_TEST_FUNCTIONS
+
+
+def compute_permutation_test(
+    neighborhoods: np.ndarray,
+    annotations: np.ndarray,
+    score_metric: str = "sum",
+    null_distribution: str = "network",
+    num_permutations: int = 1000,
+    random_seed: int = 888,
+    max_workers: int = 1,
+) -> Dict[str, Any]:
+    """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".
+        null_distribution (str, optional): Type of null distribution ('network' or other). 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.
+        max_workers (int, optional): Number of workers for multiprocessing. Defaults to 1.
+
+    Returns:
+        dict: Dictionary containing depletion and enrichment p-values.
+    """
+    # Ensure that the matrices are in the correct format and free of NaN values
+    neighborhoods = neighborhoods.astype(np.float32)
+    annotations = annotations.astype(np.float32)
+    # Retrieve the appropriate neighborhood score function based on the metric
+    neighborhood_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,
+        annotations=annotations,
+        neighborhood_score_func=neighborhood_score_func,
+        null_distribution=null_distribution,
+        num_permutations=num_permutations,
+        random_seed=random_seed,
+        max_workers=max_workers,
+    )
+    # Compute p-values for depletion and enrichment
+    # If counts are 0, set p-value to 1/num_permutations to avoid zero p-values
+    depletion_pvals = np.maximum(counts_depletion, 1) / num_permutations
+    enrichment_pvals = np.maximum(counts_enrichment, 1) / num_permutations
+
+    return {
+        "depletion_pvals": depletion_pvals,
+        "enrichment_pvals": enrichment_pvals,
+    }
+
+
+def _run_permutation_test(
+    neighborhoods: np.ndarray,
+    annotations: np.ndarray,
+    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.
+
+    Args:
+        neighborhoods (np.ndarray): The neighborhood matrix.
+        annotations (np.ndarray): The annotation matrix.
+        neighborhood_score_func (Callable): Function to calculate neighborhood scores.
+        null_distribution (str, optional): Type of null distribution. 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.
+        max_workers (int, optional): Number of workers for multiprocessing. Defaults to 4.
+
+    Returns:
+        tuple: Depletion and enrichment counts.
+    """
+    # Initialize the RNG for reproducibility
+    rng = np.random.default_rng(seed=random_seed)
+    # Determine the indices to use based on the null distribution type
+    if null_distribution == "network":
+        idxs = range(annotations.shape[0])
+    else:
+        idxs = np.nonzero(np.sum(~np.isnan(annotations), axis=1))[0]
+
+    # Replace NaNs with zeros in the annotations matrix
+    annotations[np.isnan(annotations)] = 0
+    annotation_matrix_obsv = annotations[idxs]
+    neighborhoods_matrix_obsv = neighborhoods.T[idxs].T
+    # Calculate observed neighborhood scores
+    with np.errstate(invalid="ignore", divide="ignore"):
+        observed_neighborhood_scores = neighborhood_score_func(
+            neighborhoods_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)
+
+    # Determine the number of permutations to run in each worker process
+    subset_size = num_permutations // max_workers
+    remainder = num_permutations % max_workers
+
+    # Use the spawn context for creating a new multiprocessing pool
+    ctx = get_context("spawn")
+    manager = Manager()
+    progress_counter = manager.Value("i", 0)
+    total_progress = num_permutations
+
+    # Execute the permutation test using multiprocessing
+    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 = [
+                (
+                    annotations,
+                    np.array(idxs),
+                    neighborhoods_matrix_obsv,
+                    observed_neighborhood_scores,
+                    neighborhood_score_func,
+                    subset_size + (1 if i < remainder else 0),
+                    progress_counter,
+                    rng,  # Pass the RNG to each process
+                )
+                for i in range(max_workers)
+            ]
+
+            # Start the permutation process in parallel
+            results = pool.starmap_async(_permutation_process_subset, params_list, chunksize=1)
+
+            # Update progress bar based on progress_counter
+            # NOTE: Waiting for results to be ready while updating progress bar gives a big improvement
+            # in performance, especially for large number of permutations and workers
+            while not results.ready():
+                progress.update(progress_counter.value - progress.n)
+                results.wait(0.05)  # Wait for 50ms
+            # 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():
+                counts_depletion = np.add(counts_depletion, local_counts_depletion)
+                counts_enrichment = np.add(counts_enrichment, local_counts_enrichment)
+
+    return counts_depletion, counts_enrichment
+
+
+def _permutation_process_subset(
+    annotation_matrix: np.ndarray,
+    idxs: np.ndarray,
+    neighborhoods_matrix_obsv: np.ndarray,
+    observed_neighborhood_scores: np.ndarray,
+    neighborhood_score_func: Callable,
+    subset_size: int,
+    progress_counter,
+    rng: np.random.Generator,
+) -> tuple:
+    """Process a subset of permutations for the permutation test.
+
+    Args:
+        annotation_matrix (np.ndarray): The annotation matrix.
+        idxs (np.ndarray): Indices of valid rows in the matrix.
+        neighborhoods_matrix_obsv (np.ndarray): Observed neighborhoods matrix.
+        observed_neighborhood_scores (np.ndarray): Observed neighborhood scores.
+        neighborhood_score_func (Callable): Function to calculate neighborhood scores.
+        subset_size (int): Number of permutations to run in this subset.
+        progress_counter: Shared counter for tracking progress.
+        rng (np.random.Generator): Random number generator object.
+
+    Returns:
+        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)
+    # NOTE: Limit the number of threads used by NumPy's BLAS implementation to 1.
+    # This can help prevent oversubscription of CPU resources during multiprocessing,
+    # ensuring that each process doesn't use more than one CPU core.
+    with threadpool_limits(limits=1, user_api="blas"):
+        for _ in range(subset_size):
+            # Permute the annotation matrix using the RNG
+            annotation_matrix_permut = annotation_matrix[rng.permutation(idxs)]
+            # Calculate permuted neighborhood scores
+            with np.errstate(invalid="ignore", divide="ignore"):
+                permuted_neighborhood_scores = neighborhood_score_func(
+                    neighborhoods_matrix_obsv, annotation_matrix_permut
+                )
+
+            # Update local depletion and enrichment counts based on permuted scores
+            local_counts_depletion = np.add(
+                local_counts_depletion, permuted_neighborhood_scores <= observed_neighborhood_scores
+            )
+            local_counts_enrichment = np.add(
+                local_counts_enrichment,
+                permuted_neighborhood_scores >= observed_neighborhood_scores,
+            )
+
+            # Update the shared progress counter
+            progress_counter.value += 1
+
+    return local_counts_depletion, local_counts_enrichment

risk/stats/{permutation.py → permutation/test_functions.py}

@@ -1,12 +1,13 @@
 """
-risk/stats/permutation
-~~~~~~~~~~~~~~~~~~~~~~
+risk/stats/permutation/test_function
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
 import numpy as np
 
 # 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_neighborhood_score_by_sum(
@@ -22,8 +23,8 @@ def compute_neighborhood_score_by_sum(
         np.ndarray: Sum of attribute values for each neighborhood.
     """
     # Calculate the neighborhood score as the dot product of neighborhoods and annotations
-    neighborhood_score = np.dot(neighborhoods_matrix, annotation_matrix)
-    return neighborhood_score
+    neighborhood_sum = np.dot(neighborhoods_matrix, annotation_matrix)
+    return neighborhood_sum
 
 
 def compute_neighborhood_score_by_stdev(
@@ -49,40 +50,12 @@ def compute_neighborhood_score_by_stdev(
     # Calculate variance as EXX - M^2
     variance = EXX - M**2
     # Compute the standard deviation as the square root of the variance
-    stdev = np.sqrt(variance)
-    return stdev
-
-
-def compute_neighborhood_score_by_z_score(
-    neighborhoods_matrix: np.ndarray, annotation_matrix: np.ndarray
-) -> np.ndarray:
-    """Compute Z-scores for neighborhood scores.
-
-    Args:
-        neighborhoods_matrix (np.ndarray): Binary matrix representing neighborhoods.
-        annotation_matrix (np.ndarray): Matrix representing annotation values.
+    neighborhood_stdev = np.sqrt(variance)
+    return neighborhood_stdev
 
-    Returns:
-        np.ndarray: Z-scores for each neighborhood.
-    """
-    # 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.dot(
-        neighborhoods_matrix, np.ones(annotation_matrix.shape[1], dtype=annotation_matrix.dtype)
-    )
-    # Compute the mean of the neighborhood scores
-    M = neighborhood_score / N
-    # Compute the mean of squares (EXX)
-    EXX = np.dot(neighborhoods_matrix, annotation_matrix**2) / N
-    # Calculate the standard deviation for each neighborhood
-    variance = EXX - M**2
-    std = np.sqrt(variance)
-    # Calculate Z-scores, handling cases where std is 0 or N is less than 3
-    with np.errstate(divide="ignore", invalid="ignore"):
-        z_scores = M / std
-        z_scores[(std == 0) | (N < 3)] = (
-            np.nan
-        )  # Handle division by zero and apply minimum threshold
 
-    return z_scores
+# Dictionary to dispatch statistical test functions based on the score metric
+DISPATCH_TEST_FUNCTIONS = {
+    "sum": compute_neighborhood_score_by_sum,
+    "stdev": compute_neighborhood_score_by_stdev,
+}

risk/stats/stats.py

@@ -3,219 +3,10 @@ risk/stats/stats
 ~~~~~~~~~~~~~~~~
 """
 
-from multiprocessing import get_context, Manager
-from tqdm import tqdm
-from typing import Any, Callable, Dict, Union
+from typing import Union
 
 import numpy as np
 from statsmodels.stats.multitest import fdrcorrection
-from threadpoolctl import threadpool_limits
-
-from risk.stats.permutation import (
-    compute_neighborhood_score_by_sum,
-    compute_neighborhood_score_by_stdev,
-    compute_neighborhood_score_by_z_score,
-)
-
-DISPATCH_PERMUTATION_TABLE = {
-    "sum": compute_neighborhood_score_by_sum,
-    "stdev": compute_neighborhood_score_by_stdev,
-    "z_score": compute_neighborhood_score_by_z_score,
-}
-
-
-def compute_permutation(
-    neighborhoods: np.ndarray,
-    annotations: np.ndarray,
-    score_metric: str = "sum",
-    null_distribution: str = "network",
-    num_permutations: int = 1000,
-    random_seed: int = 888,
-    max_workers: int = 1,
-) -> Dict[str, Any]:
-    """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".
-        null_distribution (str, optional): Type of null distribution ('network' or other). 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.
-        max_workers (int, optional): Number of workers for multiprocessing. Defaults to 1.
-
-    Returns:
-        dict: Dictionary containing depletion and enrichment p-values.
-    """
-    # Ensure that the matrices are in the correct format and free of NaN values
-    neighborhoods = neighborhoods.astype(np.float32)
-    annotations = annotations.astype(np.float32)
-    # Retrieve the appropriate neighborhood score function based on the metric
-    neighborhood_score_func = DISPATCH_PERMUTATION_TABLE[score_metric]
-
-    # Run the permutation test to calculate depletion and enrichment counts
-    counts_depletion, counts_enrichment = _run_permutation_test(
-        neighborhoods=neighborhoods,
-        annotations=annotations,
-        neighborhood_score_func=neighborhood_score_func,
-        null_distribution=null_distribution,
-        num_permutations=num_permutations,
-        random_seed=random_seed,
-        max_workers=max_workers,
-    )
-
-    # Compute p-values for depletion and enrichment
-    # If counts are 0, set p-value to 1/num_permutations to avoid zero p-values
-    depletion_pvals = np.maximum(counts_depletion, 1) / num_permutations
-    enrichment_pvals = np.maximum(counts_enrichment, 1) / num_permutations
-
-    return {
-        "depletion_pvals": depletion_pvals,
-        "enrichment_pvals": enrichment_pvals,
-    }
-
-
-def _run_permutation_test(
-    neighborhoods: np.ndarray,
-    annotations: np.ndarray,
-    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.
-
-    Args:
-        neighborhoods (np.ndarray): The neighborhood matrix.
-        annotations (np.ndarray): The annotation matrix.
-        neighborhood_score_func (Callable): Function to calculate neighborhood scores.
-        null_distribution (str, optional): Type of null distribution. 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.
-        max_workers (int, optional): Number of workers for multiprocessing. Defaults to 4.
-
-    Returns:
-        tuple: Depletion and enrichment counts.
-    """
-    # Set the random seed for reproducibility
-    np.random.seed(random_seed)
-
-    # Determine the indices to use based on the null distribution type
-    if null_distribution == "network":
-        idxs = range(annotations.shape[0])
-    else:
-        idxs = np.nonzero(np.sum(~np.isnan(annotations), axis=1))[0]
-
-    # Replace NaNs with zeros in the annotations matrix
-    annotations[np.isnan(annotations)] = 0
-    annotation_matrix_obsv = annotations[idxs]
-    neighborhoods_matrix_obsv = neighborhoods.T[idxs].T
-
-    # Calculate observed neighborhood scores
-    with np.errstate(invalid="ignore", divide="ignore"):
-        observed_neighborhood_scores = neighborhood_score_func(
-            neighborhoods_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)
-
-    # Determine the number of permutations to run in each worker process
-    subset_size = num_permutations // max_workers
-    remainder = num_permutations % max_workers
-
-    # Use the spawn context for creating a new multiprocessing pool
-    ctx = get_context("spawn")
-    manager = Manager()
-    progress_counter = manager.Value("i", 0)
-    total_progress = num_permutations
-
-    # Execute the permutation test using multiprocessing
-    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 = [
-                (
-                    annotations,
-                    np.array(idxs),
-                    neighborhoods_matrix_obsv,
-                    observed_neighborhood_scores,
-                    neighborhood_score_func,
-                    subset_size + (1 if i < remainder else 0),
-                    progress_counter,
-                )
-                for i in range(max_workers)
-            ]
-
-            # Start the permutation process in parallel
-            results = pool.starmap_async(_permutation_process_subset, params_list)
-
-            # Update progress bar based on progress_counter
-            while not results.ready():
-                progress.update(progress_counter.value - progress.n)
-                results.wait(0.1)
-
-            # 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():
-                counts_depletion = np.add(counts_depletion, local_counts_depletion)
-                counts_enrichment = np.add(counts_enrichment, local_counts_enrichment)
-
-    return counts_depletion, counts_enrichment
-
-
-def _permutation_process_subset(
-    annotation_matrix: np.ndarray,
-    idxs: np.ndarray,
-    neighborhoods_matrix_obsv: np.ndarray,
-    observed_neighborhood_scores: np.ndarray,
-    neighborhood_score_func: Callable,
-    subset_size: int,
-    progress_counter,
-) -> tuple:
-    """Process a subset of permutations for the permutation test.
-
-    Args:
-        annotation_matrix (np.ndarray): The annotation matrix.
-        idxs (np.ndarray): Indices of valid rows in the matrix.
-        neighborhoods_matrix_obsv (np.ndarray): Observed neighborhoods matrix.
-        observed_neighborhood_scores (np.ndarray): Observed neighborhood scores.
-        neighborhood_score_func (Callable): Function to calculate neighborhood scores.
-        subset_size (int): Number of permutations to run in this subset.
-        progress_counter: Shared counter for tracking progress.
-
-    Returns:
-        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)
-
-    with threadpool_limits(limits=1, user_api="blas"):
-        for _ in range(subset_size):
-            # Permute the annotation matrix
-            annotation_matrix_permut = annotation_matrix[np.random.permutation(idxs)]
-            # Calculate permuted neighborhood scores
-            with np.errstate(invalid="ignore", divide="ignore"):
-                permuted_neighborhood_scores = neighborhood_score_func(
-                    neighborhoods_matrix_obsv, annotation_matrix_permut
-                )
-            # Update local depletion and enrichment counts based on permuted scores
-            local_counts_depletion = np.add(
-                local_counts_depletion, permuted_neighborhood_scores <= observed_neighborhood_scores
-            )
-            local_counts_enrichment = np.add(
-                local_counts_enrichment,
-                permuted_neighborhood_scores >= observed_neighborhood_scores,
-            )
-            # Update the shared progress counter
-            progress_counter.value += 1
-
-    return local_counts_depletion, local_counts_enrichment
 
 
 def calculate_significance_matrices(

{risk_network-0.0.3b3.dist-info → risk_network-0.0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: risk-network
-Version: 0.0.3b3
+Version: 0.0.4
 Summary: A Python package for biological network analysis
 Author: Ira Horecka
 Author-email: Ira Horecka <ira89@icloud.com>
@@ -684,14 +684,14 @@ Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
 Classifier: Topic :: Scientific/Engineering :: Information Analysis
 Classifier: Topic :: Scientific/Engineering :: Visualization
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Development Status :: 4 - Beta
-Requires-Python: >=3.7
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: ipywidgets
@@ -716,13 +716,13 @@ Requires-Dist: tqdm
 
 <p align="center">
   <a href="https://pypi.python.org/pypi/risk-network"><img src="https://img.shields.io/pypi/v/risk-network.svg" alt="pypiv"></a>
-  <a href="https://www.python.org/downloads/"><img src="https://img.shields.io/badge/python-3.7+-blue.svg" alt="Python 3.7+"></a>
+  <a href="https://www.python.org/downloads/"><img src="https://img.shields.io/badge/python-3.8+-blue.svg" alt="Python 3.8+"></a>
   <a href="https://raw.githubusercontent.com/irahorecka/chrono24/main/LICENSE"><img src="https://img.shields.io/badge/License-GPLv3-blue.svg" alt="License: GPL v3"></a>
 </p>
 
 ## RISK
 
-#### Regional Inference of Significant Kinships
+#### RISK Infers Spatial Kinships
 
 RISK is a software tool for visualizing spatial relationships in networks. It aims to enhance network analysis by integrating advanced network annotation algorithms, such as Louvain and Markov Clustering, to identify key functional modules and pathways.
 
@@ -736,7 +736,7 @@ RISK is a software tool for visualizing spatial relationships in networks. It ai
 
 *Saccharomyces cerevisiae* proteins oriented by physical interactions discovered through affinity enrichment and mass spectrometry (Michaelis et al., 2023).
 
-![Metabolic Network Demo](./docs/github/network.png)
+![PPI Network Demo](./docs/github/network.png)
 
 ## Installation
 

risk_network-0.0.4.dist-info/RECORD

@@ -0,0 +1,30 @@
+risk/__init__.py,sha256=5ydXZQ9nkGE0sf2oay7qxbSHwCkV1BqBqVoBIreNZog,104
+risk/constants.py,sha256=AICk3x5qRQhls_ijTb4VdbdxU6mZ1aLGbAjLEdBwfJI,550
+risk/risk.py,sha256=4Y-fViqdK9gvxEjJRYsV_7gbN0kh7eiTwD8eesd_M6o,21109
+risk/annotations/__init__.py,sha256=vUpVvMRE5if01Ic8QY6M2Ae3EFGJHdugEe9PdEkAW4Y,138
+risk/annotations/annotations.py,sha256=t4aLwROCFHcqk8g-viuwkFG--HqVpVN_2yVVcjhg6wI,10534
+risk/annotations/io.py,sha256=TMicRACfY8bNtmbvVrxHoh8zkOVLOIhZwWrpxUlR28Q,7988
+risk/log/__init__.py,sha256=xuLImfxFlKpnVhzi_gDYlr2_c9cLkrw2c_3iEsXb1as,107
+risk/log/console.py,sha256=im9DRExwf6wHlcn9fewoDcKIpo3vPcorZIaNAl-0csY,355
+risk/log/params.py,sha256=Tbb-sovFTptGBqPDKafUA8KOpby4zFObutAT_Iti1hE,6302
+risk/neighborhoods/__init__.py,sha256=tKKEg4lsbqFukpgYlUGxU_v_9FOqK7V0uvM9T2QzoL0,206
+risk/neighborhoods/community.py,sha256=eL2IGT-8sbiJIyfyb_FGngev7pEMxw7tZb8YzbzOYw8,6512
+risk/neighborhoods/domains.py,sha256=HwuChmZH0RGD9eQOvk2-ezQDJRUHHn93vhVgHb-kX6I,10192
+risk/neighborhoods/neighborhoods.py,sha256=SqYJaT49rUj77ts0XsPXb9cURM11aGh2Teks0nBH_4s,13939
+risk/network/__init__.py,sha256=iEPeJdZfqp0toxtbElryB8jbz9_t_k4QQ3iDvKE8C_0,126
+risk/network/geometry.py,sha256=H1yGVVqgbfpzBzJwEheDLfvGLSA284jGQQTn612L4Vc,6759
+risk/network/graph.py,sha256=m3bFWU5528OEm246LPG5XP3l_30vaBiJv4AO4iq0pSA,11552
+risk/network/io.py,sha256=otiRG6uT6HLgbbJql7X2wjYxab8OFJSgRoWJlcDoyu4,20291
+risk/network/plot.py,sha256=yGmuQXcju2cWUcyJJALtNmIPPCFS2yusULJXka8263I,40080
+risk/stats/__init__.py,sha256=e-BE_Dr_jgiK6hKM-T-tlG4yvHnId8e5qjnM0pdwNVc,230
+risk/stats/fisher_exact.py,sha256=-bPwzu76-ob0HzrTV20mXUTot7v-MLuqFaAoab-QxPg,4966
+risk/stats/hypergeom.py,sha256=lrIFdhCWRjvM4apYw1MlOKqT_IY5OjtCwrjdtJdt6Tg,4954
+risk/stats/stats.py,sha256=kvShov-94W6ffgDUTb522vB9hDJQSyTsYif_UIaFfSM,7059
+risk/stats/permutation/__init__.py,sha256=neJp7FENC-zg_CGOXqv-iIvz1r5XUKI9Ruxhmq7kDOI,105
+risk/stats/permutation/permutation.py,sha256=qLWdwxEY6nmkYPxpM8HLDcd2mbqYv9Qr7CKtJvhLqIM,9220
+risk/stats/permutation/test_functions.py,sha256=HuDIM-V1jkkfE1rlaIqrWWBSKZt3dQ1f-YEDjWpnLSE,2343
+risk_network-0.0.4.dist-info/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+risk_network-0.0.4.dist-info/METADATA,sha256=3LgOrdx1WOC-0VC1ShUQo3EfGecyxBNy3dg1DDbrSfM,43234
+risk_network-0.0.4.dist-info/WHEEL,sha256=UvcQYKBHoFqaQd6LKyqHw9fxEolWLQnlzP0h_LgJAfI,91
+risk_network-0.0.4.dist-info/top_level.txt,sha256=NX7C2PFKTvC1JhVKv14DFlFAIFnKc6Lpsu1ZfxvQwVw,5
+risk_network-0.0.4.dist-info/RECORD,,

{risk_network-0.0.3b3.dist-info → risk_network-0.0.4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (72.2.0)
+Generator: setuptools (74.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

risk_network-0.0.3b3.dist-info/RECORD

@@ -1,26 +0,0 @@
-risk/__init__.py,sha256=RJu5X2UMuCRnZae_KH4Fc7_o_P4sSfTDEBowiVZ2Go4,122
-risk/constants.py,sha256=AICk3x5qRQhls_ijTb4VdbdxU6mZ1aLGbAjLEdBwfJI,550
-risk/risk.py,sha256=cWpYogZ-vma4ZZjewVNRMzb2TqHv8YABuzP2brXpOqo,16399
-risk/annotations/__init__.py,sha256=vUpVvMRE5if01Ic8QY6M2Ae3EFGJHdugEe9PdEkAW4Y,138
-risk/annotations/annotations.py,sha256=gZ9gihK_eTWaX3eByh08xr97FX4-XKe6MBwCCjasEDU,10368
-risk/annotations/io.py,sha256=ozi7aFn3_geB6G0kt7Ya1qVhNOqP6rB0YISjriSZyNw,7989
-risk/log/__init__.py,sha256=xuLImfxFlKpnVhzi_gDYlr2_c9cLkrw2c_3iEsXb1as,107
-risk/log/console.py,sha256=im9DRExwf6wHlcn9fewoDcKIpo3vPcorZIaNAl-0csY,355
-risk/log/params.py,sha256=Tbb-sovFTptGBqPDKafUA8KOpby4zFObutAT_Iti1hE,6302
-risk/neighborhoods/__init__.py,sha256=tKKEg4lsbqFukpgYlUGxU_v_9FOqK7V0uvM9T2QzoL0,206
-risk/neighborhoods/community.py,sha256=eL2IGT-8sbiJIyfyb_FGngev7pEMxw7tZb8YzbzOYw8,6512
-risk/neighborhoods/domains.py,sha256=HwuChmZH0RGD9eQOvk2-ezQDJRUHHn93vhVgHb-kX6I,10192
-risk/neighborhoods/neighborhoods.py,sha256=zGtxVIs0_Bg0wt1By6d77_lqW0PGXpOtQxeCEtyZFzA,13475
-risk/network/__init__.py,sha256=iEPeJdZfqp0toxtbElryB8jbz9_t_k4QQ3iDvKE8C_0,126
-risk/network/geometry.py,sha256=euBMOVvxpj-0WZam40IbHdsT7E4WXpTwSxuGbmAGTDg,6757
-risk/network/graph.py,sha256=a7gM1d2jHqscFVwn1GZaJWb3oZOFraNsQ2RxC4osaV4,11528
-risk/network/io.py,sha256=KmdrsDZe-ZT4O59NYZM_nQd8Ew9qpbzQcqWS_PaE7eA,12559
-risk/network/plot.py,sha256=fy21X677xqJPFkn564Jegxy05C9x0pJXovd5fm3NZ4Q,34554
-risk/stats/__init__.py,sha256=4s9gdJo5B1G_cQc0iMoeIBt5OrQNXkdtNXkAMFQkLxc,103
-risk/stats/permutation.py,sha256=xgaZbaxo57t_FzPlpcb2nsq8oCzc_wj-zAm-xj3P2dA,3404
-risk/stats/stats.py,sha256=_3Fj5H8Nml4cExvLg7Mt_i1HCLAJJcJSDiiSzr3uFlo,15798
-risk_network-0.0.3b3.dist-info/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
-risk_network-0.0.3b3.dist-info/METADATA,sha256=4zGYMG1NL48Udn8jYkT8VCYDEEAuN5ycXBpvmxvdHtw,43256
-risk_network-0.0.3b3.dist-info/WHEEL,sha256=HiCZjzuy6Dw0hdX5R3LCFPDmFS4BWl8H-8W39XfmgX4,91
-risk_network-0.0.3b3.dist-info/top_level.txt,sha256=NX7C2PFKTvC1JhVKv14DFlFAIFnKc6Lpsu1ZfxvQwVw,5
-risk_network-0.0.3b3.dist-info/RECORD,,