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

risk/stats/api.py

@@ -0,0 +1,202 @@
+"""
+risk/stats/api
+~~~~~~~~~~~~~~
+"""
+
+from typing import Any, Dict
+
+from scipy.sparse import csr_matrix
+
+from ..log import log_header, logger, params
+from ._stats import (
+    compute_binom_test,
+    compute_chi2_test,
+    compute_hypergeom_test,
+    compute_permutation_test,
+)
+
+
+class StatsAPI:
+    """
+    Handles the loading of statistical results and annotation significance for clusters.
+
+    The StatsAPI class provides methods to load cluster results from statistical tests.
+    """
+
+    def run_binom(
+        self,
+        annotation: Dict[str, Any],
+        clusters: csr_matrix,
+        null_distribution: str = "network",
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """
+        Compute cluster significance using the binomial test.
+
+        Args:
+            annotation (Dict[str, Any]): The annotation associated with the network.
+            clusters (csr_matrix): The cluster assignments for the network.
+            null_distribution (str, optional): Type of null distribution ('network' or 'annotation').
+
+        Returns:
+            Dict[str, Any]: The computed significance of clusters based on the specified statistical test.
+        """
+        log_header("Running binomial test")
+        # Compute cluster significance using the binomial test
+        return self._run_statistical_test(
+            annotation=annotation,
+            clusters=clusters,
+            null_distribution=null_distribution,
+            statistical_test_key="binom",
+            statistical_test_function=compute_binom_test,
+            **kwargs,
+        )
+
+    def run_chi2(
+        self,
+        annotation: Dict[str, Any],
+        clusters: csr_matrix,
+        null_distribution: str = "network",
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """
+        Compute cluster significance using the chi-squared test.
+
+        Args:
+            annotation (Dict[str, Any]): The annotation associated with the network.
+            clusters (csr_matrix): The cluster assignments for the network.
+            null_distribution (str, optional): Type of null distribution ('network' or 'annotation'). Defaults to "network".
+
+        Returns:
+            Dict[str, Any]: The computed significance of clusters based on the specified statistical test.
+        """
+        log_header("Running chi-squared test")
+        # Compute cluster significance using the chi-squared test
+        return self._run_statistical_test(
+            annotation=annotation,
+            clusters=clusters,
+            null_distribution=null_distribution,
+            statistical_test_key="chi2",
+            statistical_test_function=compute_chi2_test,
+            **kwargs,
+        )
+
+    def run_hypergeom(
+        self,
+        annotation: Dict[str, Any],
+        clusters: csr_matrix,
+        null_distribution: str = "network",
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """
+        Compute cluster significance using the hypergeometric test.
+
+        Args:
+            annotation (Dict[str, Any]): The annotation associated with the network.
+            clusters (csr_matrix): The cluster matrix to use.
+            null_distribution (str, optional): Type of null distribution ('network' or 'annotation'). Defaults to "network".
+
+        Returns:
+            Dict[str, Any]: The computed significance of clusters based on the specified statistical test.
+        """
+        log_header("Running hypergeometric test")
+        # Compute cluster significance using the hypergeometric test
+        return self._run_statistical_test(
+            annotation=annotation,
+            clusters=clusters,
+            null_distribution=null_distribution,
+            statistical_test_key="hypergeom",
+            statistical_test_function=compute_hypergeom_test,
+            **kwargs,
+        )
+
+    def run_permutation(
+        self,
+        annotation: Dict[str, Any],
+        clusters: csr_matrix,
+        score_metric: str = "sum",
+        null_distribution: str = "network",
+        num_permutations: int = 1000,
+        random_seed: int = 888,
+        max_workers: int = 1,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """
+        Compute cluster significance using the permutation test.
+
+        Args:
+            annotation (Dict[str, Any]): The annotation associated with the network.
+            clusters (csr_matrix): The cluster matrix to use.
+            score_metric (str, optional): Scoring metric for cluster significance. Defaults to "sum".
+            null_distribution (str, optional): Type of null distribution ('network' or 'annotation'). Defaults to "network".
+            num_permutations (int, optional): Number of permutations for significance testing. Defaults to 1000.
+            random_seed (int, optional): Seed for random number generation. Defaults to 888.
+            max_workers (int, optional): Maximum number of workers for parallel computation. Defaults to 1.
+
+        Returns:
+            Dict[str, Any]: The computed significance of clusters based on the specified statistical test.
+        """
+        log_header("Running permutation test")
+        # Log and display permutation test settings, which is unique to this test
+        logger.debug(f"Cluster scoring metric: '{score_metric}'")
+        logger.debug(f"Number of permutations: {num_permutations}")
+        logger.debug(f"Maximum workers: {max_workers}")
+        # Compute cluster significance using the permutation test
+        return self._run_statistical_test(
+            annotation=annotation,
+            clusters=clusters,
+            null_distribution=null_distribution,
+            random_seed=random_seed,
+            statistical_test_key="permutation",
+            statistical_test_function=compute_permutation_test,
+            score_metric=score_metric,
+            num_permutations=num_permutations,
+            max_workers=max_workers,
+            **kwargs,
+        )
+
+    def _run_statistical_test(
+        self,
+        annotation: Dict[str, Any],
+        clusters: csr_matrix,
+        null_distribution: str = "network",
+        statistical_test_key: str = "hypergeom",
+        statistical_test_function: Any = compute_hypergeom_test,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """
+        Run the specified statistical test to compute cluster significance.
+
+        Args:
+            annotation (Dict[str, Any]): Annotation data associated with the network.
+            clusters (csr_matrix): The cluster matrix to analyze.
+            null_distribution (str, optional): The type of null distribution to use ('network' or 'annotation').
+                Defaults to "network".
+            random_seed (int, optional): Seed for random number generation to ensure reproducibility. Defaults to 888.
+            statistical_test_key (str, optional): Key or name of the statistical test to be applied (e.g., "hypergeom", "binom").
+                Used for logging and debugging. Defaults to "hypergeom".
+            statistical_test_function (Any, optional): The function implementing the statistical test.
+                It should accept clusters, annotation, null distribution, and additional kwargs.
+                Defaults to `compute_hypergeom_test`.
+            **kwargs: Additional parameters to be passed to the statistical test function.
+
+        Returns:
+            Dict[str, Any]: A dictionary containing the computed significance values for clusters.
+        """
+        # Log null distribution type
+        logger.debug(f"Null distribution: '{null_distribution}'")
+        # Log cluster analysis parameters
+        params.log_stats(
+            statistical_test_function=statistical_test_key,
+            null_distribution=null_distribution,
+            **kwargs,
+        )
+        # Apply statistical test function to compute cluster significance
+        cluster_significance = statistical_test_function(
+            clusters=clusters,
+            annotation=annotation["matrix"],
+            null_distribution=null_distribution,
+            **kwargs,
+        )
+        # Return the computed cluster significance
+        return cluster_significance

{risk_network-0.0.16b0.dist-info → risk_network-0.0.16b2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: risk-network
-Version: 0.0.16b0
+Version: 0.0.16b2
 Summary: A Python package for scalable network analysis and high-quality visualization.
 Author-email: Ira Horecka <ira89@icloud.com>
 License: GPL-3.0-or-later
@@ -44,7 +44,7 @@ Dynamic: license-file
 ![Python](https://img.shields.io/badge/python-3.8%2B-yellow)
 [![pypiv](https://img.shields.io/pypi/v/risk-network.svg)](https://pypi.python.org/pypi/risk-network)
 ![License](https://img.shields.io/badge/license-GPLv3-purple)
-[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.17257418.svg)](https://doi.org/10.5281/zenodo.17257418)
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.17257417.svg)](https://doi.org/10.5281/zenodo.17257417)
 ![Tests](https://github.com/riskportal/risk/actions/workflows/ci.yml/badge.svg)
 
 **RISK** (Regional Inference of Significant Kinships) is a next-generation tool for biological network annotation and visualization. It integrates community detection algorithms, rigorous overrepresentation analysis, and a modular framework for diverse network types. RISK identifies biologically coherent relationships within networks and generates publication-ready visualizations, making it a useful tool for biological and interdisciplinary network analysis.

risk_network-0.0.16b2.dist-info/RECORD

@@ -0,0 +1,43 @@
+risk/__init__.py,sha256=8kw8nQa4l3_e5whBhKyspNfK6gv9ACvnrFRffg7RO40,142
+risk/risk.py,sha256=EHq4jfsx1TssuzkfYd8joaogW0heS0SuM38BWj4CX0E,1063
+risk/annotation/__init__.py,sha256=1F_P_JVQD7ai4bWNjL5dIHTR6SuaFIfnD-MC7wZW0vY,162
+risk/annotation/_nltk_setup.py,sha256=YUlB7bqiHELn8rb5tE5o7_FiXyirnxWL3Vzm47HWtiM,3581
+risk/annotation/annotation.py,sha256=FVYFJoIFUzjhQCba44ocXz65u5Kwr_b0h431ewb_QZc,14980
+risk/annotation/io.py,sha256=_bA-sRDh4ynvgNVCz60AChzh_f22Oxv1AkVnQK-LTPw,12451
+risk/cluster/__init__.py,sha256=vP7ZTKRogKtfMZt7HquJes6TZqQvufIvIeIYbM_bwAE,161
+risk/cluster/_community.py,sha256=wgcoUiFL8tJZTmfnUA2_0LkK_pOFtNCC_d1vBX6ENL4,17665
+risk/cluster/api.py,sha256=d5IT-th4uVotGrt-sctqs3EsWjgvSi4ncQrdB1ghp-c,9337
+risk/cluster/cluster.py,sha256=sWPWBlfy3bZoPBh6LSHc54sZrXMSf6AA9vBVu_z0TmA,21469
+risk/cluster/label.py,sha256=TtN1gbfoDITTc2KWBz8rC8HLr2CZzuhnZU2EClh3dNs,16811
+risk/log/__init__.py,sha256=wEJ0hXt8yyIAS-IGGL7Kd8xoPD_beVWQwhF-buxW6J4,203
+risk/log/console.py,sha256=x1sFpOqKzPVoBHr9sDJJYAbFqQmRUV2HPKBvEn9_AX4,4649
+risk/log/parameters.py,sha256=bKQKYs4cRXnIlEboys8pVjs23NBgMtQWRSg1lGgFUR0,6103
+risk/network/__init__.py,sha256=ZdJRKDXc9DOCIFzDYOsnqmnHvFbODNjaJ8XmeNby93M,124
+risk/network/io.py,sha256=909YYj1h9TKW-VpcdYSya3i1V-hOLXvjU795Y5v6roA,28337
+risk/network/graph/__init__.py,sha256=sU46_opsN9ep9jh6fVoBYRzbohjm6_Nx1IVYqv0sMj4,98
+risk/network/graph/_stats.py,sha256=Q2LPu6vzW-lpDCOLtdBna9tCfuCJ4jxjRjvtb3SD9os,7355
+risk/network/graph/_summary.py,sha256=wCSPXHtA6wfjJwRRuD9RzherNOB8RGQzq1weDa-sHBY,10188
+risk/network/graph/api.py,sha256=E8wjC_RvaHTmdQyD5aGmlSOFtjCrVHpkbqcca570ajQ,8456
+risk/network/graph/graph.py,sha256=Ztw6-rcr4cgQgW1uujbU4y_RHYJRzT_oNOtsgmYCf9s,12475
+risk/network/plotter/__init__.py,sha256=gw2fV1atXlxC5ckST2TnBV3yhVYfQSFadPYBBTiDatk,79
+risk/network/plotter/_canvas.py,sha256=fQEcBCQEI4vwj6sAHgULYMdMuWyqeRrVYp7NxHkyXng,13591
+risk/network/plotter/_contour.py,sha256=8QshMFxZXZmZRzfru5a3Bpf5pGL-ElukegVMvculgFM,15551
+risk/network/plotter/_labels.py,sha256=JZ6KOy_kTz-m_qkedKJ181kppjhk09Z63zlyRv18lnw,46909
+risk/network/plotter/_network.py,sha256=IiK1mnByoTvjc7xmuRHfewjC1t8TR8ZIvDxgITSU5Fk,14306
+risk/network/plotter/_plotter.py,sha256=6OTGz1md5v_1iKGru__2QeV3-gUULLJscyLPWPOBCGo,6004
+risk/network/plotter/api.py,sha256=LIrXZJBdTCnh6ntFHEl5vbQs35f4cytqixizxzUQqvU,1686
+risk/network/plotter/_utils/__init__.py,sha256=F2W_R_lhtTDap3xJ25qN-C3Ba1fb0NYkDBiR8vB-4Eo,205
+risk/network/plotter/_utils/colors.py,sha256=CKmZ-Ki1oh40nNGBHE4PTirJ8dF0Y4yReTF6VzzQlrA,19170
+risk/network/plotter/_utils/layout.py,sha256=UQQHT-A-iHQxKEzFla_8fvnjBJTc_zsm2-ZJpvLLbOk,3627
+risk/stats/__init__.py,sha256=Mb8h-1Z3upFS0zrlFVbyfO5afLkVaZXfqZpOs4lj_lg,57
+risk/stats/api.py,sha256=1U-cABIZzVQjmTF7M09QaRZfCLI82C8OzSXOSuM37XI,8075
+risk/stats/_stats/__init__.py,sha256=yMGqINN7Z4A2V4ln5f6lhdV-5GRfV5ABm-m-mni4YNQ,197
+risk/stats/_stats/tests.py,sha256=mTCwu6CnZjU_qURmKKc8Dd37Gar8xukttIm2qXhrCY0,7279
+risk/stats/_stats/permutation/__init__.py,sha256=BDELJoCtaz0Byc4V6f7chtfYqkG4l_trM30kgzNxluM,134
+risk/stats/_stats/permutation/_test_functions.py,sha256=qeHsljh_gVG1EqFPzYPvLG_G3HnoXtKwsmowVXmEKnI,2970
+risk/stats/_stats/permutation/permutation.py,sha256=aglSO8NiP0hzTdcZKIQy1ZwaTJaXPBPBULTB8JG_02E,10377
+risk_network-0.0.16b2.dist-info/licenses/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+risk_network-0.0.16b2.dist-info/METADATA,sha256=7usyb0e7b7qPUqaxIYp-UT2zrasH5Ur4N6E96jqA7aY,5390
+risk_network-0.0.16b2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+risk_network-0.0.16b2.dist-info/top_level.txt,sha256=NX7C2PFKTvC1JhVKv14DFlFAIFnKc6Lpsu1ZfxvQwVw,5
+risk_network-0.0.16b2.dist-info/RECORD,,

risk/_neighborhoods/__init__.py

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

risk/_neighborhoods/_api.py

@@ -1,354 +0,0 @@
-"""
-risk/_neighborhoods/_api
-~~~~~~~~~~~~~~~~~~~~~~~~
-"""
-
-import copy
-from typing import Any, Dict, List, Tuple, Union
-
-import networkx as nx
-import numpy as np
-from scipy.sparse import csr_matrix
-
-from .._log import log_header, logger, params
-from ._neighborhoods import get_network_neighborhoods
-from ._stats import (
-    compute_binom_test,
-    compute_chi2_test,
-    compute_hypergeom_test,
-    compute_permutation_test,
-)
-
-
-class NeighborhoodsAPI:
-    """
-    Handles the loading of statistical results and annotation significance for neighborhoods.
-
-    The NeighborhoodsAPI class provides methods to load neighborhood results from statistical tests.
-    """
-
-    def load_neighborhoods_binom(
-        self,
-        network: nx.Graph,
-        annotation: Dict[str, Any],
-        distance_metric: Union[str, List, Tuple, np.ndarray] = "louvain",
-        louvain_resolution: float = 0.1,
-        leiden_resolution: float = 1.0,
-        fraction_shortest_edges: Union[float, List, Tuple, np.ndarray] = 0.5,
-        null_distribution: str = "network",
-        random_seed: int = 888,
-    ) -> Dict[str, Any]:
-        """
-        Load significant neighborhoods for the network using the binomial test.
-
-        Args:
-            network (nx.Graph): The network graph.
-            annotation (Dict[str, Any]): The annotation 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'.
-            louvain_resolution (float, optional): Resolution parameter for Louvain clustering. Defaults to 0.1.
-            leiden_resolution (float, optional): Resolution parameter for Leiden clustering. Defaults to 1.0.
-            fraction_shortest_edges (float, List, Tuple, or np.ndarray, optional): Shortest edge rank fraction threshold(s) for creating subgraphs.
-                Can be a single float for one threshold or a list/tuple of floats corresponding to multiple thresholds.
-                Defaults to 0.5.
-            null_distribution (str, optional): Type of null distribution ('network' or 'annotation'). Defaults to "network".
-            random_seed (int, optional): Seed for random number generation. Defaults to 888.
-
-        Returns:
-            Dict[str, Any]: Computed significance of neighborhoods.
-        """
-        log_header("Running binomial test")
-        # Compute neighborhood significance using the binomial test
-        return self._load_neighborhoods_by_statistical_test(
-            network=network,
-            annotation=annotation,
-            distance_metric=distance_metric,
-            louvain_resolution=louvain_resolution,
-            leiden_resolution=leiden_resolution,
-            fraction_shortest_edges=fraction_shortest_edges,
-            null_distribution=null_distribution,
-            random_seed=random_seed,
-            statistical_test_key="binom",
-            statistical_test_function=compute_binom_test,
-        )
-
-    def load_neighborhoods_chi2(
-        self,
-        network: nx.Graph,
-        annotation: Dict[str, Any],
-        distance_metric: Union[str, List, Tuple, np.ndarray] = "louvain",
-        louvain_resolution: float = 0.1,
-        leiden_resolution: float = 1.0,
-        fraction_shortest_edges: Union[float, List, Tuple, np.ndarray] = 0.5,
-        null_distribution: str = "network",
-        random_seed: int = 888,
-    ) -> Dict[str, Any]:
-        """
-        Load significant neighborhoods for the network using the chi-squared test.
-
-        Args:
-            network (nx.Graph): The network graph.
-            annotation (Dict[str, Any]): The annotation 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'.
-            louvain_resolution (float, optional): Resolution parameter for Louvain clustering. Defaults to 0.1.
-            leiden_resolution (float, optional): Resolution parameter for Leiden clustering. Defaults to 1.0.
-            fraction_shortest_edges (float, List, Tuple, or np.ndarray, optional): Shortest edge rank fraction threshold(s) for creating subgraphs.
-                Can be a single float for one threshold or a list/tuple of floats corresponding to multiple thresholds.
-                Defaults to 0.5.
-            null_distribution (str, optional): Type of null distribution ('network' or 'annotation'). Defaults to "network".
-            random_seed (int, optional): Seed for random number generation. Defaults to 888.
-
-        Returns:
-            Dict[str, Any]: Computed significance of neighborhoods.
-        """
-        log_header("Running chi-squared test")
-        # Compute neighborhood significance using the chi-squared test
-        return self._load_neighborhoods_by_statistical_test(
-            network=network,
-            annotation=annotation,
-            distance_metric=distance_metric,
-            louvain_resolution=louvain_resolution,
-            leiden_resolution=leiden_resolution,
-            fraction_shortest_edges=fraction_shortest_edges,
-            null_distribution=null_distribution,
-            random_seed=random_seed,
-            statistical_test_key="chi2",
-            statistical_test_function=compute_chi2_test,
-        )
-
-    def load_neighborhoods_hypergeom(
-        self,
-        network: nx.Graph,
-        annotation: Dict[str, Any],
-        distance_metric: Union[str, List, Tuple, np.ndarray] = "louvain",
-        louvain_resolution: float = 0.1,
-        leiden_resolution: float = 1.0,
-        fraction_shortest_edges: Union[float, List, Tuple, np.ndarray] = 0.5,
-        null_distribution: str = "network",
-        random_seed: int = 888,
-    ) -> Dict[str, Any]:
-        """
-        Load significant neighborhoods for the network using the hypergeometric test.
-
-        Args:
-            network (nx.Graph): The network graph.
-            annotation (Dict[str, Any]): The annotation 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'.
-            louvain_resolution (float, optional): Resolution parameter for Louvain clustering. Defaults to 0.1.
-            leiden_resolution (float, optional): Resolution parameter for Leiden clustering. Defaults to 1.0.
-            fraction_shortest_edges (float, List, Tuple, or np.ndarray, optional): Shortest edge rank fraction threshold(s) for creating subgraphs.
-                Can be a single float for one threshold or a list/tuple of floats corresponding to multiple thresholds.
-                Defaults to 0.5.
-            null_distribution (str, optional): Type of null distribution ('network' or 'annotation'). Defaults to "network".
-            random_seed (int, optional): Seed for random number generation. Defaults to 888.
-
-        Returns:
-            Dict[str, Any]: Computed significance of neighborhoods.
-        """
-        log_header("Running hypergeometric test")
-        # Compute neighborhood significance using the hypergeometric test
-        return self._load_neighborhoods_by_statistical_test(
-            network=network,
-            annotation=annotation,
-            distance_metric=distance_metric,
-            louvain_resolution=louvain_resolution,
-            leiden_resolution=leiden_resolution,
-            fraction_shortest_edges=fraction_shortest_edges,
-            null_distribution=null_distribution,
-            random_seed=random_seed,
-            statistical_test_key="hypergeom",
-            statistical_test_function=compute_hypergeom_test,
-        )
-
-    def load_neighborhoods_permutation(
-        self,
-        network: nx.Graph,
-        annotation: Dict[str, Any],
-        distance_metric: Union[str, List, Tuple, np.ndarray] = "louvain",
-        louvain_resolution: float = 0.1,
-        leiden_resolution: float = 1.0,
-        fraction_shortest_edges: Union[float, List, Tuple, np.ndarray] = 0.5,
-        score_metric: str = "sum",
-        null_distribution: str = "network",
-        num_permutations: int = 1000,
-        random_seed: int = 888,
-        max_workers: int = 1,
-    ) -> Dict[str, Any]:
-        """
-        Load significant neighborhoods for the network using the permutation test.
-
-        Args:
-            network (nx.Graph): The network graph.
-            annotation (Dict[str, Any]): The annotation 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'.
-            louvain_resolution (float, optional): Resolution parameter for Louvain clustering. Defaults to 0.1.
-            leiden_resolution (float, optional): Resolution parameter for Leiden clustering. Defaults to 1.0.
-            fraction_shortest_edges (float, List, Tuple, or np.ndarray, optional): Shortest edge rank fraction threshold(s) for creating subgraphs.
-                Can be a single float for one threshold or a list/tuple of floats corresponding to multiple thresholds.
-                Defaults to 0.5.
-            score_metric (str, optional): Scoring metric for neighborhood significance. Defaults to "sum".
-            null_distribution (str, optional): Type of null distribution ('network' or 'annotation'). Defaults to "network".
-            num_permutations (int, optional): Number of permutations for significance testing. Defaults to 1000.
-            random_seed (int, optional): Seed for random number generation. Defaults to 888.
-            max_workers (int, optional): Maximum number of workers for parallel computation. Defaults to 1.
-
-        Returns:
-            Dict[str, Any]: Computed significance of neighborhoods.
-        """
-        log_header("Running permutation test")
-        # Log and display permutation test settings, which is unique to this test
-        logger.debug(f"Neighborhood scoring metric: '{score_metric}'")
-        logger.debug(f"Number of permutations: {num_permutations}")
-        logger.debug(f"Maximum workers: {max_workers}")
-        # Compute neighborhood significance using the permutation test
-        return self._load_neighborhoods_by_statistical_test(
-            network=network,
-            annotation=annotation,
-            distance_metric=distance_metric,
-            louvain_resolution=louvain_resolution,
-            leiden_resolution=leiden_resolution,
-            fraction_shortest_edges=fraction_shortest_edges,
-            null_distribution=null_distribution,
-            random_seed=random_seed,
-            statistical_test_key="permutation",
-            statistical_test_function=compute_permutation_test,
-            score_metric=score_metric,
-            num_permutations=num_permutations,
-            max_workers=max_workers,
-        )
-
-    def _load_neighborhoods_by_statistical_test(
-        self,
-        network: nx.Graph,
-        annotation: Dict[str, Any],
-        distance_metric: Union[str, List, Tuple, np.ndarray] = "louvain",
-        louvain_resolution: float = 0.1,
-        leiden_resolution: float = 1.0,
-        fraction_shortest_edges: Union[float, List, Tuple, np.ndarray] = 0.5,
-        null_distribution: str = "network",
-        random_seed: int = 888,
-        statistical_test_key: str = "hypergeom",
-        statistical_test_function: Any = compute_hypergeom_test,
-        **kwargs,
-    ):
-        """
-        Load and compute significant neighborhoods for the network using a specified statistical test.
-
-        Args:
-            network (nx.Graph): The input network graph.
-            annotation (Dict[str, Any]): Annotation data associated with the network, including a "matrix" key with annotation values.
-            distance_metric (Union[str, List, Tuple, np.ndarray], optional): The distance metric or clustering method to define neighborhoods.
-                Can be a string specifying one method (e.g., 'louvain', 'leiden') or a collection of methods.
-                Defaults to "louvain".
-            louvain_resolution (float, optional): Resolution parameter for Louvain clustering. Defaults to 0.1.
-            leiden_resolution (float, optional): Resolution parameter for Leiden clustering. Defaults to 1.0.
-            fraction_shortest_edges (Union[float, List, Tuple, np.ndarray], optional): Fraction of shortest edges to consider for creating subgraphs.
-                Can be a single value or a collection of thresholds for flexibility. Defaults to 0.5.
-            null_distribution (str, optional): The type of null distribution to use ('network' or 'annotation').
-                Defaults to "network".
-            random_seed (int, optional): Seed for random number generation to ensure reproducibility. Defaults to 888.
-            statistical_test_key (str, optional): Key or name of the statistical test to be applied (e.g., "hypergeom", "binom").
-                Used for logging and debugging. Defaults to "hypergeom".
-            statistical_test_function (Any, optional): The function implementing the statistical test.
-                It should accept neighborhoods, annotation, null distribution, and additional kwargs.
-                Defaults to `compute_hypergeom_test`.
-            **kwargs: Additional parameters to be passed to the statistical test function.
-
-        Returns:
-            Dict[str, Any]: A dictionary containing the computed significance values for neighborhoods.
-        """
-        # Log null distribution type
-        logger.debug(f"Null distribution: '{null_distribution}'")
-        # Log neighborhood analysis parameters
-        params.log_neighborhoods(
-            distance_metric=distance_metric,
-            louvain_resolution=louvain_resolution,
-            leiden_resolution=leiden_resolution,
-            fraction_shortest_edges=fraction_shortest_edges,
-            statistical_test_function=statistical_test_key,
-            null_distribution=null_distribution,
-            random_seed=random_seed,
-            **kwargs,
-        )
-
-        # Make a copy of the network to avoid modifying the original
-        network = copy.copy(network)
-        # Load neighborhoods based on the network and distance metric
-        neighborhoods = self._load_neighborhoods(
-            network,
-            distance_metric,
-            louvain_resolution=louvain_resolution,
-            leiden_resolution=leiden_resolution,
-            fraction_shortest_edges=fraction_shortest_edges,
-            random_seed=random_seed,
-        )
-        # Apply statistical test function to compute neighborhood significance
-        neighborhood_significance = statistical_test_function(
-            neighborhoods=neighborhoods,
-            annotation=annotation["matrix"],
-            null_distribution=null_distribution,
-            **kwargs,
-        )
-
-        # Return the computed neighborhood significance
-        return neighborhood_significance
-
-    def _load_neighborhoods(
-        self,
-        network: nx.Graph,
-        distance_metric: Union[str, List, Tuple, np.ndarray] = "louvain",
-        louvain_resolution: float = 0.1,
-        leiden_resolution: float = 1.0,
-        fraction_shortest_edges: Union[float, List, Tuple, np.ndarray] = 0.5,
-        random_seed: int = 888,
-    ) -> csr_matrix:
-        """
-        Load significant neighborhoods for the network.
-
-        Args:
-            network (nx.Graph): The network graph.
-            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'.
-            louvain_resolution (float, optional): Resolution parameter for Louvain clustering. Defaults to 0.1.
-            leiden_resolution (float, optional): Resolution parameter for Leiden clustering. Defaults to 1.0.
-            fraction_shortest_edges (float, List, Tuple, or np.ndarray, optional): Shortest edge rank fraction threshold(s) for creating subgraphs.
-                Can be a single float for one threshold or a list/tuple of floats corresponding to multiple thresholds.
-                Defaults to 0.5.
-            random_seed (int, optional): Seed for random number generation. Defaults to 888.
-
-        Returns:
-            csr_matrix: Sparse neighborhood matrix calculated based on the selected distance metric.
-        """
-        # Display the chosen distance metric
-        if distance_metric == "louvain":
-            for_print_distance_metric = f"louvain (resolution={louvain_resolution})"
-        elif distance_metric == "leiden":
-            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
-        neighborhoods = get_network_neighborhoods(
-            network,
-            distance_metric,
-            fraction_shortest_edges,
-            louvain_resolution=louvain_resolution,
-            leiden_resolution=leiden_resolution,
-            random_seed=random_seed,
-        )
-
-        # Return the sparse neighborhood matrix
-        return neighborhoods

risk/_neighborhoods/_stats/__init__.py

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

risk/_neighborhoods/_stats/_permutation/__init__.py

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