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

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/__init__.py

@@ -3,4 +3,4 @@ risk/stats/permutation
 ~~~~~~~~~~~~~~~~~~~~~~
 """
 
-from .permutation import compute_permutation_test
+from risk.stats.permutation.permutation import compute_permutation_test

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

@@ -0,0 +1,68 @@
+"""
+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: 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.
+
+    Args:
+        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.
+    """
+    # Total number of nodes in the network
+    total_node_count = neighborhoods.shape[1]
+
+    # Compute sums
+    if null_distribution == "network":
+        background_population = total_node_count
+        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":
+        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'."
+        )
+
+    # 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
+
+    # Standard deviation under the null
+    std_dev = np.sqrt(
+        expected
+        * (1 - annotation_sums / background_population)
+        * (1 - neighborhood_sums / background_population)
+    )
+    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
+
+    return {"depletion_pvals": depletion_pvals, "enrichment_pvals": enrichment_pvals}

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: risk-network
-Version: 0.0.9b23
+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.plotter import NetworkPlotter

risk/network/plot/plotter.py

@@ -1,143 +0,0 @@
-"""
-risk/network/plot/plotter
-~~~~~~~~~~~~~~~~~~~~~~~~~
-"""
-
-from typing import List, Tuple, Union
-
-import matplotlib.pyplot as plt
-import numpy as np
-
-from risk.log import params
-from risk.network.graph 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.network import Network
-from risk.network.plot.utils.colors import to_rgba
-from risk.network.plot.utils.layout import calculate_bounding_box
-
-
-class NetworkPlotter(Canvas, Network, Contour, Labels):
-    """A class for visualizing network graphs with customizable options.
-
-    The NetworkPlotter class uses a NetworkGraph object and provides methods to plot the network with
-    flexible node and edge properties. It also supports plotting labels, contours, drawing the network's
-    perimeter, and adjusting background colors.
-    """
-
-    def __init__(
-        self,
-        graph: NetworkGraph,
-        figsize: Tuple = (10, 10),
-        background_color: Union[str, List, Tuple, np.ndarray] = "white",
-        background_alpha: Union[float, None] = 1.0,
-        pad: float = 0.3,
-    ) -> None:
-        """Initialize the NetworkPlotter with a NetworkGraph object and plotting parameters.
-
-        Args:
-            graph (NetworkGraph): The network data and attributes to be visualized.
-            figsize (Tuple, optional): Size of the figure in inches (width, height). Defaults to (10, 10).
-            background_color (str, List, Tuple, np.ndarray, optional): Background color of the plot. Defaults to "white".
-            background_alpha (float, None, optional): Transparency level of the background color. If provided, it overrides
-                any existing alpha values found in background_color. Defaults to 1.0.
-            pad (float, optional): Padding value to adjust the axis limits. Defaults to 0.3.
-        """
-        self.graph = graph
-        # Initialize the plot with the specified parameters
-        self.ax = self._initialize_plot(
-            graph=graph,
-            figsize=figsize,
-            background_color=background_color,
-            background_alpha=background_alpha,
-            pad=pad,
-        )
-        super().__init__(graph=graph, ax=self.ax)
-
-    def _initialize_plot(
-        self,
-        graph: NetworkGraph,
-        figsize: Tuple,
-        background_color: Union[str, List, Tuple, np.ndarray],
-        background_alpha: Union[float, None],
-        pad: float,
-    ) -> plt.Axes:
-        """Set up the plot with figure size and background color.
-
-        Args:
-            graph (NetworkGraph): The network data and attributes to be visualized.
-            figsize (Tuple): Size of the figure in inches (width, height).
-            background_color (str, List, Tuple, or np.ndarray): Background color of the plot. Can be a single color or an array of colors.
-            background_alpha (float, None, optional): Transparency level of the background color. If provided, it overrides any existing
-                alpha values found in `background_color`.
-            pad (float, optional): Padding value to adjust the axis limits.
-
-        Returns:
-            plt.Axes: The axis object for the plot.
-        """
-        # Log the plotter settings
-        params.log_plotter(
-            figsize=figsize,
-            background_color=background_color,
-            background_alpha=background_alpha,
-            pad=pad,
-        )
-
-        # Extract node coordinates from the network graph
-        node_coordinates = graph.node_coordinates
-        # Calculate the center and radius of the bounding box around the network
-        center, radius = calculate_bounding_box(node_coordinates)
-
-        # Create a new figure and axis for plotting
-        fig, ax = plt.subplots(figsize=figsize)
-        fig.tight_layout()  # Adjust subplot parameters to give specified padding
-        # Set axis limits based on the calculated bounding box and radius
-        ax.set_xlim([center[0] - radius - pad, center[0] + radius + pad])
-        ax.set_ylim([center[1] - radius - pad, center[1] + radius + pad])
-        ax.set_aspect("equal")  # Ensure the aspect ratio is equal
-
-        # Set the background color of the plot
-        # Convert color to RGBA using the to_rgba helper function
-        fig.patch.set_facecolor(
-            to_rgba(color=background_color, alpha=background_alpha, num_repeats=1)
-        )  # num_repeats=1 for single color
-        ax.invert_yaxis()  # Invert the y-axis to match typical image coordinates
-        # Remove axis spines for a cleaner look
-        for spine in ax.spines.values():
-            spine.set_visible(False)
-
-        # Hide axis ticks and labels
-        ax.set_xticks([])
-        ax.set_yticks([])
-        ax.patch.set_visible(False)  # Hide the axis background
-
-        return ax
-
-    @staticmethod
-    def savefig(*args, pad_inches: float = 0.5, dpi: int = 100, **kwargs) -> None:
-        """Save the current plot to a file with additional export options.
-
-        Args:
-            *args: Positional arguments passed to `plt.savefig`.
-            pad_inches (float, optional): Padding around the figure when saving. Defaults to 0.5.
-            dpi (int, optional): Dots per inch (DPI) for the exported image. Defaults to 300.
-            **kwargs: Keyword arguments passed to `plt.savefig`, such as filename and format.
-        """
-        # Ensure user-provided kwargs take precedence
-        kwargs.setdefault("dpi", dpi)
-        kwargs.setdefault("pad_inches", pad_inches)
-        # Ensure the plot is saved with tight bounding box if not specified
-        kwargs.setdefault("bbox_inches", "tight")
-        # Call plt.savefig with combined arguments
-        plt.savefig(*args, **kwargs)
-
-    @staticmethod
-    def show(*args, **kwargs) -> None:
-        """Display the current plot.
-
-        Args:
-            *args: Positional arguments passed to `plt.show`.
-            **kwargs: Keyword arguments passed to `plt.show`.
-        """
-        plt.show(*args, **kwargs)