risk-network 0.0.11__py3-none-any.whl → 0.0.12b1__py3-none-any.whl

risk/__init__.py

@@ -7,4 +7,4 @@ RISK: Regional Inference of Significant Kinships
 
 from risk.risk import RISK
 
-__version__ = "0.0.11"
+__version__ = "0.0.12-beta.1"

risk/annotations/__init__.py

@@ -3,5 +3,8 @@ risk/annotations
 ~~~~~~~~~~~~~~~~
 """
 
-from risk.annotations.annotations import define_top_annotations, get_weighted_description
+from risk.annotations.annotations import (
+    define_top_annotations,
+    get_weighted_description,
+)
 from risk.annotations.io import AnnotationsIO

risk/annotations/io.py

@@ -10,7 +10,7 @@ import networkx as nx
 import pandas as pd
 
 from risk.annotations.annotations import load_annotations
-from risk.log import params, logger, log_header
+from risk.log import log_header, logger, params
 
 
 class AnnotationsIO:
@@ -20,9 +20,6 @@ class AnnotationsIO:
     and to export parameter data to various formats like JSON, CSV, and text files.
     """
 
-    def __init__(self):
-        pass
-
     def load_json_annotation(
         self, network: nx.Graph, filepath: str, min_nodes_per_term: int = 2
     ) -> Dict[str, Any]:
@@ -42,7 +39,7 @@ class AnnotationsIO:
         params.log_annotations(
             filetype=filetype, filepath=filepath, min_nodes_per_term=min_nodes_per_term
         )
-        _log_loading(filetype, filepath=filepath)
+        self._log_loading(filetype, filepath=filepath)
 
         # Load the JSON file into a dictionary
         with open(filepath, "r", encoding="utf-8") as file:
@@ -81,7 +78,7 @@ class AnnotationsIO:
         params.log_annotations(
             filetype=filetype, filepath=filepath, min_nodes_per_term=min_nodes_per_term
         )
-        _log_loading(filetype, filepath=filepath)
+        self._log_loading(filetype, filepath=filepath)
 
         # Load the specified sheet from the Excel file
         annotation = pd.read_excel(filepath, sheet_name=sheet_name)
@@ -123,10 +120,10 @@ class AnnotationsIO:
         params.log_annotations(
             filetype=filetype, filepath=filepath, min_nodes_per_term=min_nodes_per_term
         )
-        _log_loading(filetype, filepath=filepath)
+        self._log_loading(filetype, filepath=filepath)
 
         # Load the CSV file into a dictionary
-        annotations_input = _load_matrix_file(
+        annotations_input = self._load_matrix_file(
             filepath, label_colname, nodes_colname, delimiter=",", nodes_delimiter=nodes_delimiter
         )
 
@@ -161,10 +158,10 @@ class AnnotationsIO:
         params.log_annotations(
             filetype=filetype, filepath=filepath, min_nodes_per_term=min_nodes_per_term
         )
-        _log_loading(filetype, filepath=filepath)
+        self._log_loading(filetype, filepath=filepath)
 
         # Load the TSV file into a dictionary
-        annotations_input = _load_matrix_file(
+        annotations_input = self._load_matrix_file(
             filepath, label_colname, nodes_colname, delimiter="\t", nodes_delimiter=nodes_delimiter
         )
 
@@ -183,6 +180,9 @@ class AnnotationsIO:
 
         Returns:
             Dict[str, Any]: A dictionary containing ordered nodes, ordered annotations, and the annotations matrix.
+
+        Raises:
+            TypeError: If the content is not a dictionary.
         """
         # Ensure the input content is a dictionary
         if not isinstance(content, dict):
@@ -193,48 +193,49 @@ class AnnotationsIO:
         filetype = "Dictionary"
         # Log the loading of the annotations from the dictionary
         params.log_annotations(filepath="In-memory dictionary", filetype=filetype)
-        _log_loading(filetype, "In-memory dictionary")
+        self._log_loading(filetype, "In-memory dictionary")
 
         # Load the annotations as a dictionary from the provided dictionary
         return load_annotations(network, content, min_nodes_per_term)
 
+    def _load_matrix_file(
+        self,
+        filepath: str,
+        label_colname: str,
+        nodes_colname: str,
+        delimiter: str = ",",
+        nodes_delimiter: str = ";",
+    ) -> Dict[str, Any]:
+        """Load annotations from a CSV or TSV file and convert them to a dictionary.
 
-def _load_matrix_file(
-    filepath: str,
-    label_colname: str,
-    nodes_colname: str,
-    delimiter: str = ",",
-    nodes_delimiter: str = ";",
-) -> Dict[str, Any]:
-    """Load annotations from a CSV or TSV file and convert them to a dictionary.
-
-    Args:
-        filepath (str): Path to the annotation file.
-        label_colname (str): Name of the column containing the labels (e.g., GO terms).
-        nodes_colname (str): Name of the column containing the nodes associated with each label.
-        delimiter (str, optional): Delimiter used to separate columns in the file (default is ',').
-        nodes_delimiter (str, optional): Delimiter used to separate multiple nodes within the nodes column (default is ';').
-
-    Returns:
-        Dict[str, Any]: A dictionary where each label is paired with its respective list of nodes.
-    """
-    # Load the CSV or TSV file into a DataFrame
-    annotation = pd.read_csv(filepath, delimiter=delimiter)
-    # Split the nodes column by the nodes_delimiter to handle multiple nodes per label
-    annotation[nodes_colname] = annotation[nodes_colname].apply(lambda x: x.split(nodes_delimiter))
-    # Create a dictionary pairing labels with their corresponding list of nodes
-    label_node_dict = annotation.set_index(label_colname)[nodes_colname].to_dict()
-    return label_node_dict
+        Args:
+            filepath (str): Path to the annotation file.
+            label_colname (str): Name of the column containing the labels (e.g., GO terms).
+            nodes_colname (str): Name of the column containing the nodes associated with each label.
+            delimiter (str, optional): Delimiter used to separate columns in the file (default is ',').
+            nodes_delimiter (str, optional): Delimiter used to separate multiple nodes within the nodes column (default is ';').
 
+        Returns:
+            Dict[str, Any]: A dictionary where each label is paired with its respective list of nodes.
+        """
+        # Load the CSV or TSV file into a DataFrame
+        annotation = pd.read_csv(filepath, delimiter=delimiter)
+        # Split the nodes column by the nodes_delimiter to handle multiple nodes per label
+        annotation[nodes_colname] = annotation[nodes_colname].apply(
+            lambda x: x.split(nodes_delimiter)
+        )
+        # Create a dictionary pairing labels with their corresponding list of nodes
+        label_node_dict = annotation.set_index(label_colname)[nodes_colname].to_dict()
+        return label_node_dict
 
-def _log_loading(filetype: str, filepath: str = "") -> None:
-    """Log information about the network file being loaded.
+    def _log_loading(self, filetype: str, filepath: str = "") -> None:
+        """Log information about the network file being loaded.
 
-    Args:
-        filetype (str): The type of the file being loaded (e.g., 'Cytoscape').
-        filepath (str, optional): The path to the file being loaded.
-    """
-    log_header("Loading annotations")
-    logger.debug(f"Filetype: {filetype}")
-    if filepath:
-        logger.debug(f"Filepath: {filepath}")
+        Args:
+            filetype (str): The type of the file being loaded (e.g., 'Cytoscape').
+            filepath (str, optional): The path to the file being loaded.
+        """
+        log_header("Loading annotations")
+        logger.debug(f"Filetype: {filetype}")
+        if filepath:
+            logger.debug(f"Filepath: {filepath}")

risk/annotations/nltk_setup.py

@@ -8,7 +8,8 @@ import zipfile
 from typing import List, Tuple
 
 import nltk
-from nltk.data import find, path as nltk_data_path
+from nltk.data import find
+from nltk.data import path as nltk_data_path
 
 from risk.log import logger
 

risk/log/__init__.py

@@ -3,7 +3,7 @@ risk/log
 ~~~~~~~~
 """
 
-from risk.log.console import logger, log_header, set_global_verbosity
+from risk.log.console import log_header, logger, set_global_verbosity
 from risk.log.parameters import Params
 
 # Initialize the global parameters logger

risk/log/parameters.py

@@ -11,7 +11,7 @@ from typing import Any, Dict
 
 import numpy as np
 
-from risk.log.console import logger, log_header
+from risk.log.console import log_header, logger
 
 # Suppress all warnings - this is to resolve warnings from multiprocessing
 warnings.filterwarnings("ignore")
@@ -137,7 +137,7 @@ class Params:
             Dict[str, Any]: A dictionary containing the processed parameters.
         """
         log_header("Loading parameters")
-        return _convert_ndarray_to_list(
+        return self._convert_ndarray_to_list(
             {
                 "annotations": self.annotations,
                 "datetime": self.datetime,
@@ -148,25 +148,24 @@ class Params:
             }
         )
 
+    def _convert_ndarray_to_list(self, d: Dict[str, Any]) -> Dict[str, Any]:
+        """Recursively convert all np.ndarray values in the dictionary to lists.
 
-def _convert_ndarray_to_list(d: Dict[str, Any]) -> Dict[str, Any]:
-    """Recursively convert all np.ndarray values in the dictionary to lists.
-
-    Args:
-        d (Dict[str, Any]): The dictionary to process.
+        Args:
+            d (Dict[str, Any]): The dictionary to process.
 
-    Returns:
-        Dict[str, Any]: The processed dictionary with np.ndarray values converted to lists.
-    """
-    if isinstance(d, dict):
-        # Recursively process each value in the dictionary
-        return {k: _convert_ndarray_to_list(v) for k, v in d.items()}
-    if isinstance(d, list):
-        # Recursively process each item in the list
-        return [_convert_ndarray_to_list(v) for v in d]
-    if isinstance(d, np.ndarray):
-        # Convert numpy arrays to lists
-        return d.tolist()
-
-    # Return the value unchanged if it's not a dict, List, or ndarray
-    return d
+        Returns:
+            Dict[str, Any]: The processed dictionary with np.ndarray values converted to lists.
+        """
+        if isinstance(d, dict):
+            # Recursively process each value in the dictionary
+            return {k: self._convert_ndarray_to_list(v) for k, v in d.items()}
+        if isinstance(d, list):
+            # Recursively process each item in the list
+            return [self._convert_ndarray_to_list(v) for v in d]
+        if isinstance(d, np.ndarray):
+            # Convert numpy arrays to lists
+            return d.tolist()
+
+        # Return the value unchanged if it's not a dict, List, or ndarray
+        return d

risk/neighborhoods/__init__.py

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

risk/neighborhoods/api.py

@@ -10,9 +10,9 @@ import networkx as nx
 import numpy as np
 from scipy.sparse import csr_matrix
 
-from risk.log import logger, log_header, params
+from risk.log import log_header, logger, params
 from risk.neighborhoods.neighborhoods import get_network_neighborhoods
-from risk.stats import (
+from risk.neighborhoods.stats import (
     compute_binom_test,
     compute_chi2_test,
     compute_hypergeom_test,

risk/neighborhoods/community.py

@@ -8,7 +8,7 @@ import igraph as ig
 import markov_clustering as mc
 import networkx as nx
 import numpy as np
-from leidenalg import find_partition, RBConfigurationVertexPartition
+from leidenalg import RBConfigurationVertexPartition, find_partition
 from networkx.algorithms.community import greedy_modularity_communities
 from scipy.sparse import csr_matrix
 
@@ -27,6 +27,10 @@ def calculate_greedy_modularity_neighborhoods(
 
     Returns:
         csr_matrix: A binary neighborhood matrix (CSR) where nodes in the same community have 1, and others have 0.
+
+    Raises:
+        ValueError: If the subgraph has no edges after filtering.
+        Warning: If the resulting subgraph has no edges after filtering.
     """
     # Create a subgraph with the shortest edges based on the rank fraction
     subnetwork = _create_percentile_limited_subgraph(
@@ -67,6 +71,10 @@ def calculate_label_propagation_neighborhoods(
 
     Returns:
         csr_matrix: A binary neighborhood matrix (CSR) on Label Propagation.
+
+    Raises:
+        ValueError: If the subgraph has no edges after filtering.
+        Warning: If the resulting subgraph has no edges after filtering.
     """
     # Create a subgraph with the shortest edges based on the rank fraction
     subnetwork = _create_percentile_limited_subgraph(
@@ -115,6 +123,10 @@ def calculate_leiden_neighborhoods(
 
     Returns:
         csr_matrix: A binary neighborhood matrix (CSR) where nodes in the same community have 1, and others have 0.
+
+    Raises:
+        ValueError: If the subgraph has no edges after filtering.
+        Warning: If the resulting subgraph has no edges after filtering.
     """
     # Create a subgraph with the shortest edges based on the rank fraction
     subnetwork = _create_percentile_limited_subgraph(
@@ -167,6 +179,10 @@ def calculate_louvain_neighborhoods(
 
     Returns:
         csr_matrix: A binary neighborhood matrix in CSR format.
+
+    Raises:
+        ValueError: If the subgraph has no edges after filtering.
+        Warning: If the resulting subgraph has no edges after filtering.
     """
     # Create a subgraph with the shortest edges based on the rank fraction
     subnetwork = _create_percentile_limited_subgraph(
@@ -215,9 +231,10 @@ def calculate_markov_clustering_neighborhoods(
     Returns:
         csr_matrix: A binary neighborhood matrix (CSR) on Markov Clustering.
 
-    Warning:
-        This function temporarily converts the adjacency matrix to a dense format, which may lead to
-        high memory consumption for large graphs.
+    Raises:
+        ValueError: If the subgraph has no edges after filtering.
+        RuntimeError: If MCL fails to run.
+        Warning: If the resulting subgraph has no edges after filtering.
     """
     # Create a subgraph with the shortest edges based on the rank fraction
     subnetwork = _create_percentile_limited_subgraph(
@@ -283,6 +300,10 @@ def calculate_spinglass_neighborhoods(
 
     Returns:
         csr_matrix: A binary neighborhood matrix (CSR) based on Spinglass communities.
+
+    Raises:
+        ValueError: If the subgraph has no edges after filtering.
+        Warning: If the resulting subgraph has no edges after filtering.
     """
     # Create a subgraph with the shortest edges based on the rank fraction
     subnetwork = _create_percentile_limited_subgraph(
@@ -343,6 +364,10 @@ def calculate_walktrap_neighborhoods(
 
     Returns:
         csr_matrix: A binary neighborhood matrix (CSR) on Walktrap communities.
+
+    Raises:
+        ValueError: If the subgraph has no edges after filtering.
+        Warning: If the resulting subgraph has no edges after filtering.
     """
     # Create a subgraph with the shortest edges based on the rank fraction
     subnetwork = _create_percentile_limited_subgraph(
@@ -384,6 +409,10 @@ def _create_percentile_limited_subgraph(G: nx.Graph, fraction_shortest_edges: fl
     Returns:
         nx.Graph: A subgraph with nodes and edges where the edges are within the shortest
         specified rank fraction.
+
+    Raises:
+        ValueError: If no edges with 'length' attributes are found in the graph.
+        Warning: If the resulting subgraph has no edges after filtering.
     """
     # Step 1: Extract edges with their lengths
     edges_with_length = [(u, v, d) for u, v, d in G.edges(data=True) if "length" in d]

risk/neighborhoods/domains.py

@@ -9,19 +9,18 @@ from typing import Tuple, Union
 import numpy as np
 import pandas as pd
 from numpy.linalg import LinAlgError
-from scipy.cluster.hierarchy import linkage, fcluster
+from scipy.cluster.hierarchy import fcluster, linkage
 from sklearn.metrics import silhouette_score
 from tqdm import tqdm
 
 from risk.annotations import get_weighted_description
 from risk.log import logger
 
-
 # Define constants for clustering
 # fmt: off
 LINKAGE_METHODS = {"single", "complete", "average", "weighted", "centroid", "median", "ward"}
 LINKAGE_METRICS = {
-    "braycurtis","canberra", "chebyshev", "cityblock", "correlation", "cosine", "dice", "euclidean",
+    "braycurtis", "canberra", "chebyshev", "cityblock", "correlation", "cosine", "dice", "euclidean",
     "hamming", "jaccard", "jensenshannon", "kulczynski1", "mahalanobis", "matching", "minkowski",
     "rogerstanimoto", "russellrao", "seuclidean", "sokalmichener", "sokalsneath", "sqeuclidean", "yule",
 }
@@ -49,6 +48,9 @@ def define_domains(
 
     Returns:
         pd.DataFrame: DataFrame with the primary domain for each node.
+
+    Raises:
+        ValueError: If the clustering criterion is set to "off" or if an error occurs during clustering.
     """
     try:
         if linkage_criterion == "off":
@@ -242,7 +244,7 @@ def _optimize_silhouette_across_linkage_and_metrics(
     # Evaluating optimal linkage method and metric
     for method, metric in tqdm(
         product(linkage_methods, linkage_metrics),
-        desc="Evaluating optimal linkage method and metric",
+        desc="Evaluating linkage methods and metrics",
         total=total_combinations,
         bar_format="{l_bar}{bar}| {n_fmt}/{total_fmt} [{elapsed}<{remaining}]",
     ):

risk/neighborhoods/neighborhoods.py

@@ -13,6 +13,7 @@ from scipy.sparse import csr_matrix
 from sklearn.exceptions import DataConversionWarning
 from sklearn.metrics.pairwise import cosine_similarity
 
+from risk.log import logger
 from risk.neighborhoods.community import (
     calculate_greedy_modularity_neighborhoods,
     calculate_label_propagation_neighborhoods,
@@ -22,7 +23,6 @@ from risk.neighborhoods.community import (
     calculate_spinglass_neighborhoods,
     calculate_walktrap_neighborhoods,
 )
-from risk.log import logger
 
 # Suppress DataConversionWarning
 warnings.filterwarnings(action="ignore", category=DataConversionWarning)
@@ -48,6 +48,9 @@ def get_network_neighborhoods(
 
     Returns:
         csr_matrix: The combined neighborhood matrix.
+
+    Raises:
+        ValueError: If the number of distance metrics does not match the number of edge length thresholds.
     """
     # Set random seed for reproducibility
     random.seed(random_seed)
@@ -490,6 +493,9 @@ def _calculate_threshold(median_distances: List, distance_threshold: float) -> f
 
     Returns:
         float: The calculated distance threshold value.
+
+    Raises:
+        ValueError: If no significant annotations are found in the median distances.
     """
     # Sort the median distances
     sorted_distances = np.sort(median_distances)

risk/neighborhoods/stats/__init__.py

@@ -0,0 +1,13 @@
+"""
+risk/neighborhoods/stats
+~~~~~~~~~~~~~~~~~~~~~~~~
+"""
+
+from risk.neighborhoods.stats.permutation import compute_permutation_test
+from risk.neighborhoods.stats.tests import (
+    compute_binom_test,
+    compute_chi2_test,
+    compute_hypergeom_test,
+    compute_poisson_test,
+    compute_zscore_test,
+)

risk/neighborhoods/stats/permutation/__init__.py

@@ -0,0 +1,6 @@
+"""
+risk/neighborhoods/stats/permutation
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+"""
+
+from risk.neighborhoods.stats.permutation.permutation import compute_permutation_test

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

@@ -1,9 +1,9 @@
 """
-risk/stats/permutation/permutation
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+risk/neighborhoods/stats/permutation/permutation
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
-from multiprocessing import get_context, Manager
+from multiprocessing import Manager, get_context
 from multiprocessing.managers import ValueProxy
 from typing import Any, Callable, Dict, List, Tuple, Union
 
@@ -12,7 +12,7 @@ from scipy.sparse import csr_matrix
 from threadpoolctl import threadpool_limits
 from tqdm import tqdm
 
-from risk.stats.permutation.test_functions import DISPATCH_TEST_FUNCTIONS
+from risk.neighborhoods.stats.permutation.test_functions import DISPATCH_TEST_FUNCTIONS
 
 
 def compute_permutation_test(
@@ -88,6 +88,9 @@ def _run_permutation_test(
 
     Returns:
         tuple: Depletion and enrichment counts.
+
+    Raises:
+        ValueError: If an invalid null_distribution value is provided.
     """
     # Initialize the RNG for reproducibility
     rng = np.random.default_rng(seed=random_seed)

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

@@ -1,6 +1,6 @@
 """
-risk/stats/permutation/test_functions
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+risk/neighborhoods/stats/permutation/test_functions
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
 import numpy as np

risk/{stats/stat_tests.py → neighborhoods/stats/tests.py}

@@ -1,17 +1,13 @@
 """
-risk/stats/stat_tests
-~~~~~~~~~~~~~~~~~~~~~
+risk/neighborhoods/stats/tests
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
 from typing import Any, Dict
 
 import numpy as np
 from scipy.sparse import csr_matrix
-from scipy.stats import binom
-from scipy.stats import chi2
-from scipy.stats import hypergeom
-from scipy.stats import norm
-from scipy.stats import poisson
+from scipy.stats import binom, chi2, hypergeom, norm, poisson
 
 
 def compute_binom_test(
@@ -28,6 +24,9 @@ def compute_binom_test(
 
     Returns:
         Dict[str, Any]: Dictionary containing depletion and enrichment p-values.
+
+    Raises:
+        ValueError: If an invalid null_distribution value is provided.
     """
     # Get the total number of nodes in the network
     total_nodes = neighborhoods.shape[1]
@@ -70,6 +69,9 @@ def compute_chi2_test(
 
     Returns:
         Dict[str, Any]: Dictionary containing depletion and enrichment p-values.
+
+    Raises:
+        ValueError: If an invalid null_distribution value is provided.
     """
     # Total number of nodes in the network
     total_node_count = neighborhoods.shape[0]
@@ -120,8 +122,7 @@ def compute_hypergeom_test(
     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 (csr_matrix): Sparse binary matrix representing neighborhoods.
@@ -130,6 +131,9 @@ def compute_hypergeom_test(
 
     Returns:
         Dict[str, Any]: Dictionary containing depletion and enrichment p-values.
+
+    Raises:
+        ValueError: If an invalid null_distribution value is provided.
     """
     # Get the total number of nodes in the network
     total_nodes = neighborhoods.shape[1]
@@ -174,8 +178,7 @@ def compute_poisson_test(
     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 (csr_matrix): Sparse binary matrix representing neighborhoods.
@@ -184,6 +187,9 @@ def compute_poisson_test(
 
     Returns:
         Dict[str, Any]: Dictionary containing depletion and enrichment p-values.
+
+    Raises:
+        ValueError: If an invalid null_distribution value is provided.
     """
     # Matrix multiplication to get the number of annotated nodes in each neighborhood
     annotated_in_neighborhood = neighborhoods @ annotations  # Sparse result
@@ -214,8 +220,7 @@ def compute_zscore_test(
     annotations: csr_matrix,
     null_distribution: str = "network",
 ) -> Dict[str, Any]:
-    """
-    Compute z-score test for enrichment and depletion in neighborhoods with selectable null distribution.
+    """Compute z-score test for enrichment and depletion in neighborhoods with selectable null distribution.
 
     Args:
         neighborhoods (csr_matrix): Sparse binary matrix representing neighborhoods.
@@ -224,6 +229,9 @@ def compute_zscore_test(
 
     Returns:
         Dict[str, Any]: Dictionary containing depletion and enrichment p-values.
+
+    Raises:
+        ValueError: If an invalid null_distribution value is provided.
     """
     # Total number of nodes in the network
     total_node_count = neighborhoods.shape[1]

risk/network/__init__.py

@@ -2,5 +2,3 @@
 risk/network
 ~~~~~~~~~~~~
 """
-
-from risk.network.io import NetworkIO

risk/network/graph/__init__.py

@@ -2,5 +2,3 @@
 risk/network/graph
 ~~~~~~~~~~~~~~~~~~
 """
-
-from risk.network.graph.api import GraphAPI

risk/network/graph/api.py

@@ -10,14 +10,14 @@ import networkx as nx
 import pandas as pd
 
 from risk.annotations import define_top_annotations
-from risk.log import logger, log_header, params
+from risk.log import log_header, logger, params
 from risk.neighborhoods import (
     define_domains,
     process_neighborhoods,
     trim_domains,
 )
 from risk.network.graph.graph import Graph
-from risk.stats import calculate_significance_matrices
+from risk.network.graph.stats import calculate_significance_matrices
 
 
 class GraphAPI: