risk-network 0.0.8b19__py3-none-any.whl → 0.0.8b21__py3-none-any.whl

risk/__init__.py

@@ -7,4 +7,4 @@ RISK: RISK Infers Spatial Kinships
 
 from risk.risk import RISK
 
-__version__ = "0.0.8-beta.19"
+__version__ = "0.0.8-beta.21"

risk/annotations/annotations.py

@@ -36,10 +36,11 @@ def load_annotations(network: nx.Graph, annotations_input: Dict[str, Any]) -> Di
     """Convert annotations input to a DataFrame and reindex based on the network's node labels.
 
     Args:
-        annotations_input (dict): A dictionary with annotations.
+        network (nx.Graph): The network graph.
+        annotations_input (Dict[str, Any]): A dictionary with annotations.
 
     Returns:
-        dict: A dictionary containing ordered nodes, ordered annotations, and the binary annotations matrix.
+        Dict[str, Any]: A dictionary containing ordered nodes, ordered annotations, and the binary annotations matrix.
     """
     # Flatten the dictionary to a list of tuples for easier DataFrame creation
     flattened_annotations = [
@@ -255,7 +256,7 @@ def _generate_coherent_description(words: List[str]) -> str:
     If there is only one unique entry, return it directly.
 
     Args:
-        words (list): A list of words or numerical string values.
+        words (List): A list of words or numerical string values.
 
     Returns:
         str: A coherent description formed by arranging the words in a logical sequence.

risk/annotations/io.py

@@ -33,7 +33,7 @@ class AnnotationsIO:
             filepath (str): Path to the JSON annotations file.
 
         Returns:
-            dict: A dictionary containing ordered nodes, ordered annotations, and the annotations matrix.
+            Dict[str, Any]: A dictionary containing ordered nodes, ordered annotations, and the annotations matrix.
         """
         filetype = "JSON"
         # Log the loading of the JSON file
@@ -158,10 +158,10 @@ class AnnotationsIO:
 
         Args:
             network (NetworkX graph): The network to which the annotations are related.
-            content (dict): The annotations dictionary to load.
+            content (Dict[str, Any]): The annotations dictionary to load.
 
         Returns:
-            dict: A dictionary containing ordered nodes, ordered annotations, and the annotations matrix.
+            Dict[str, Any]: A dictionary containing ordered nodes, ordered annotations, and the annotations matrix.
         """
         # Ensure the input content is a dictionary
         if not isinstance(content, dict):

risk/log/params.py

@@ -159,7 +159,7 @@ class Params:
         """Load and process various parameters, converting any np.ndarray values to lists.
 
         Returns:
-            dict: A dictionary containing the processed parameters.
+            Dict[str, Any]: A dictionary containing the processed parameters.
         """
         log_header("Loading parameters")
         return _convert_ndarray_to_list(
@@ -174,14 +174,14 @@ class Params:
         )
 
 
-def _convert_ndarray_to_list(d: Any) -> Any:
+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): The dictionary to process.
+        d (Dict[str, Any]): The dictionary to process.
 
     Returns:
-        dict: The processed dictionary with np.ndarray values converted to lists.
+        Dict[str, Any]: The processed dictionary with np.ndarray values converted to lists.
     """
     if isinstance(d, dict):
         # Recursively process each value in the dictionary

risk/neighborhoods/community.py

@@ -21,15 +21,20 @@ def calculate_greedy_modularity_neighborhoods(network: nx.Graph) -> np.ndarray:
     """
     # Detect communities using the Greedy Modularity method
     communities = greedy_modularity_communities(network)
-    # Create a mapping from node to community
-    community_dict = {node: idx for idx, community in enumerate(communities) for node in community}
     # Create a binary neighborhood matrix
-    neighborhoods = np.zeros((network.number_of_nodes(), network.number_of_nodes()), dtype=int)
+    n_nodes = network.number_of_nodes()
+    neighborhoods = np.zeros((n_nodes, n_nodes), dtype=int)
+    # Create a mapping from node to index in the matrix
     node_index = {node: i for i, node in enumerate(network.nodes())}
-    for node_i, community_i in community_dict.items():
-        for node_j, community_j in community_dict.items():
-            if community_i == community_j:
-                neighborhoods[node_index[node_i], node_index[node_j]] = 1
+    # Fill in the neighborhood matrix for nodes in the same community
+    for community in communities:
+        # Iterate through all pairs of nodes in the same community
+        for node_i in community:
+            idx_i = node_index[node_i]
+            for node_j in community:
+                idx_j = node_index[node_j]
+                # Set them as neighbors (1) in the binary matrix
+                neighborhoods[idx_i, idx_j] = 1
 
     return neighborhoods
 
@@ -43,22 +48,20 @@ def calculate_label_propagation_neighborhoods(network: nx.Graph) -> np.ndarray:
     Returns:
         np.ndarray: Binary neighborhood matrix on Label Propagation.
     """
-    # Apply Label Propagation
+    # Apply Label Propagation for community detection
     communities = nx.algorithms.community.label_propagation.label_propagation_communities(network)
-    # Create a mapping from node to community
-    community_dict = {}
-    for community_id, community in enumerate(communities):
-        for node in community:
-            community_dict[node] = community_id
-
     # Create a binary neighborhood matrix
     num_nodes = network.number_of_nodes()
     neighborhoods = np.zeros((num_nodes, num_nodes), dtype=int)
+    # Create a mapping from node to index in the matrix
+    node_index = {node: i for i, node in enumerate(network.nodes())}
     # Assign neighborhoods based on community labels
-    for node_i, community_i in community_dict.items():
-        for node_j, community_j in community_dict.items():
-            if community_i == community_j:
-                neighborhoods[node_i, node_j] = 1
+    for community in communities:
+        for node_i in community:
+            idx_i = node_index[node_i]
+            for node_j in community:
+                idx_j = node_index[node_j]
+                neighborhoods[idx_i, idx_j] = 1
 
     return neighborhoods
 
@@ -81,12 +84,22 @@ def calculate_louvain_neighborhoods(
         network, resolution=resolution, random_state=random_seed
     )
     # Create a binary neighborhood matrix
-    neighborhoods = np.zeros((network.number_of_nodes(), network.number_of_nodes()), dtype=int)
+    num_nodes = network.number_of_nodes()
+    neighborhoods = np.zeros((num_nodes, num_nodes), dtype=int)
+    # Create a mapping from node to index in the matrix
+    node_index = {node: i for i, node in enumerate(network.nodes())}
+    # Group nodes by community
+    community_groups = {}
+    for node, community in partition.items():
+        community_groups.setdefault(community, []).append(node)
+
     # Assign neighborhoods based on community partitions
-    for node_i, community_i in partition.items():
-        for node_j, community_j in partition.items():
-            if community_i == community_j:
-                neighborhoods[node_i, node_j] = 1
+    for community, nodes in community_groups.items():
+        for node_i in nodes:
+            idx_i = node_index[node_i]
+            for node_j in nodes:
+                idx_j = node_index[node_j]
+                neighborhoods[idx_i, idx_j] = 1
 
     return neighborhoods
 
@@ -102,24 +115,22 @@ def calculate_markov_clustering_neighborhoods(network: nx.Graph) -> np.ndarray:
     """
     # Convert the graph to an adjacency matrix
     adjacency_matrix = nx.to_numpy_array(network)
-    # Run Markov Clustering
-    result = mc.run_mcl(adjacency_matrix)  # Run MCL with default parameters
-    # Get clusters
+    # Run Markov Clustering (MCL)
+    result = mc.run_mcl(adjacency_matrix)  # MCL with default parameters
+    # Get clusters (communities) from MCL result
     clusters = mc.get_clusters(result)
-    # Create a community label for each node
-    community_dict = {}
-    for community_id, community in enumerate(clusters):
-        for node in community:
-            community_dict[node] = community_id
-
     # Create a binary neighborhood matrix
     num_nodes = network.number_of_nodes()
     neighborhoods = np.zeros((num_nodes, num_nodes), dtype=int)
-    # Assign neighborhoods based on community labels
-    for node_i, community_i in community_dict.items():
-        for node_j, community_j in community_dict.items():
-            if community_i == community_j:
-                neighborhoods[node_i, node_j] = 1
+    # Create a mapping from node to index in the matrix
+    node_index = {node: i for i, node in enumerate(network.nodes())}
+    # Assign neighborhoods based on MCL clusters
+    for cluster in clusters:
+        for node_i in cluster:
+            idx_i = node_index[node_i]
+            for node_j in cluster:
+                idx_j = node_index[node_j]
+                neighborhoods[idx_i, idx_j] = 1
 
     return neighborhoods
 
@@ -133,22 +144,20 @@ def calculate_spinglass_neighborhoods(network: nx.Graph) -> np.ndarray:
     Returns:
         np.ndarray: Binary neighborhood matrix on Spin Glass communities.
     """
-    # Use the asynchronous label propagation algorithm as a proxy for Spin Glass
+    # Apply Asynchronous Label Propagation (LPA)
     communities = asyn_lpa_communities(network)
-    # Create a community label for each node
-    community_dict = {}
-    for community_id, community in enumerate(communities):
-        for node in community:
-            community_dict[node] = community_id
-
     # Create a binary neighborhood matrix
     num_nodes = network.number_of_nodes()
     neighborhoods = np.zeros((num_nodes, num_nodes), dtype=int)
-    # Assign neighborhoods based on community labels
-    for node_i, community_i in community_dict.items():
-        for node_j, community_j in community_dict.items():
-            if community_i == community_j:
-                neighborhoods[node_i, node_j] = 1
+    # Create a mapping from node to index in the matrix
+    node_index = {node: i for i, node in enumerate(network.nodes())}
+    # Assign neighborhoods based on community labels from LPA
+    for community in communities:
+        for node_i in community:
+            idx_i = node_index[node_i]
+            for node_j in community:
+                idx_j = node_index[node_j]
+                neighborhoods[idx_i, idx_j] = 1
 
     return neighborhoods
 
@@ -162,21 +171,19 @@ def calculate_walktrap_neighborhoods(network: nx.Graph) -> np.ndarray:
     Returns:
         np.ndarray: Binary neighborhood matrix on Walktrap communities.
     """
-    # Use the asynchronous label propagation algorithm as a proxy for Walktrap
+    # Apply Asynchronous Label Propagation (LPA)
     communities = asyn_lpa_communities(network)
-    # Create a community label for each node
-    community_dict = {}
-    for community_id, community in enumerate(communities):
-        for node in community:
-            community_dict[node] = community_id
-
     # Create a binary neighborhood matrix
     num_nodes = network.number_of_nodes()
     neighborhoods = np.zeros((num_nodes, num_nodes), dtype=int)
-    # Assign neighborhoods based on community labels
-    for node_i, community_i in community_dict.items():
-        for node_j, community_j in community_dict.items():
-            if community_i == community_j:
-                neighborhoods[node_i, node_j] = 1
+    # Create a mapping from node to index in the matrix
+    node_index = {node: i for i, node in enumerate(network.nodes())}
+    # Assign neighborhoods based on community labels from LPA
+    for community in communities:
+        for node_i in community:
+            idx_i = node_index[node_i]
+            for node_j in community:
+                idx_j = node_index[node_j]
+                neighborhoods[idx_i, idx_j] = 1
 
     return neighborhoods

risk/neighborhoods/neighborhoods.py

@@ -5,7 +5,7 @@ risk/neighborhoods/neighborhoods
 
 import random
 import warnings
-from typing import Any, Dict, List, Tuple
+from typing import Any, Dict, List, Tuple, Union
 
 import networkx as nx
 import numpy as np
@@ -28,50 +28,82 @@ warnings.filterwarnings(action="ignore", category=DataConversionWarning)
 
 def get_network_neighborhoods(
     network: nx.Graph,
-    distance_metric: str = "louvain",
-    edge_length_threshold: float = 1.0,
+    distance_metric: Union[str, List, Tuple, np.ndarray] = "louvain",
+    edge_length_threshold: Union[float, List, Tuple, np.ndarray] = 1.0,
     louvain_resolution: float = 1.0,
     random_seed: int = 888,
 ) -> np.ndarray:
-    """Calculate the neighborhoods for each node in the network based on the specified distance metric.
+    """Calculate the combined neighborhoods for each node based on the specified community detection algorithm(s).
 
     Args:
         network (nx.Graph): The network graph.
-        distance_metric (str): The distance metric to use ('greedy_modularity', 'louvain', 'label_propagation',
-            'markov_clustering', 'walktrap', 'spinglass').
-        edge_length_threshold (float): The edge length threshold for the neighborhoods.
+        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', 'label_propagation',
+            'markov_clustering', 'walktrap', 'spinglass'). Defaults to 'louvain'.
+        edge_length_threshold (float, List, Tuple, or np.ndarray, optional): Edge length 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 1.0.
         louvain_resolution (float, optional): Resolution parameter for the Louvain method. Defaults to 1.0.
         random_seed (int, optional): Random seed for methods requiring random initialization. Defaults to 888.
 
     Returns:
-        np.ndarray: Neighborhood matrix calculated based on the selected distance metric.
+        np.ndarray: Summed neighborhood matrix from all selected algorithms.
     """
-    # Set random seed for reproducibility in all methods besides Louvain, which requires a separate seed
+    # Set random seed for reproducibility
     random.seed(random_seed)
     np.random.seed(random_seed)
 
-    # Create a subgraph based on the edge length percentile threshold
-    network = _create_percentile_limited_subgraph(
-        network, edge_length_percentile=edge_length_threshold
-    )
+    # Ensure distance_metric is a list/tuple for multi-algorithm handling
+    if isinstance(distance_metric, (str, np.ndarray)):
+        distance_metric = [distance_metric]
+    # Ensure edge_length_threshold is a list/tuple for multi-threshold handling
+    if isinstance(edge_length_threshold, (float, int)):
+        edge_length_threshold = [edge_length_threshold] * len(distance_metric)
+    # Check that the number of distance metrics matches the number of edge length thresholds
+    if len(distance_metric) != len(edge_length_threshold):
+        raise ValueError(
+            "The number of distance metrics must match the number of edge length thresholds."
+        )
 
-    if distance_metric == "louvain":
-        return calculate_louvain_neighborhoods(network, louvain_resolution, random_seed=random_seed)
-    if distance_metric == "greedy_modularity":
-        return calculate_greedy_modularity_neighborhoods(network)
-    if distance_metric == "label_propagation":
-        return calculate_label_propagation_neighborhoods(network)
-    if distance_metric == "markov_clustering":
-        return calculate_markov_clustering_neighborhoods(network)
-    if distance_metric == "walktrap":
-        return calculate_walktrap_neighborhoods(network)
-    if distance_metric == "spinglass":
-        return calculate_spinglass_neighborhoods(network)
-
-    raise ValueError(
-        "Incorrect distance metric specified. Please choose from 'greedy_modularity', 'louvain',"
-        "'label_propagation', 'markov_clustering', 'walktrap', 'spinglass'."
-    )
+    # Initialize combined neighborhood matrix
+    num_nodes = network.number_of_nodes()
+    combined_neighborhoods = np.zeros((num_nodes, num_nodes), dtype=int)
+
+    # Loop through each distance metric and corresponding edge length threshold
+    for metric, threshold in zip(distance_metric, edge_length_threshold):
+        # Create a subgraph based on the specific edge length threshold for this algorithm
+        subgraph = _create_percentile_limited_subgraph(network, edge_length_percentile=threshold)
+        # Call the appropriate neighborhood function based on the metric
+        if metric == "louvain":
+            neighborhoods = calculate_louvain_neighborhoods(
+                subgraph, louvain_resolution, random_seed=random_seed
+            )
+        elif metric == "greedy_modularity":
+            neighborhoods = calculate_greedy_modularity_neighborhoods(subgraph)
+        elif metric == "label_propagation":
+            neighborhoods = calculate_label_propagation_neighborhoods(subgraph)
+        elif metric == "markov_clustering":
+            neighborhoods = calculate_markov_clustering_neighborhoods(subgraph)
+        elif metric == "walktrap":
+            neighborhoods = calculate_walktrap_neighborhoods(subgraph)
+        elif metric == "spinglass":
+            neighborhoods = calculate_spinglass_neighborhoods(subgraph)
+        else:
+            raise ValueError(
+                "Incorrect distance metric specified. Please choose from 'greedy_modularity', 'louvain',"
+                "'label_propagation', 'markov_clustering', 'walktrap', 'spinglass'."
+            )
+
+        # Sum the neighborhood matrices
+        combined_neighborhoods += neighborhoods
+
+    # Ensure that the maximum value in each row is set to 1
+    # This ensures that for each row, only the strongest relationship (the maximum value) is retained,
+    # while all other values are reset to 0. This transformation simplifies the neighborhood matrix by
+    # focusing on the most significant connection per row.
+    combined_neighborhoods = _set_max_to_one(combined_neighborhoods)
+
+    return combined_neighborhoods
 
 
 def _create_percentile_limited_subgraph(G: nx.Graph, edge_length_percentile: float) -> nx.Graph:
@@ -110,6 +142,25 @@ def _create_percentile_limited_subgraph(G: nx.Graph, edge_length_percentile: flo
     return subgraph
 
 
+def _set_max_to_one(matrix: np.ndarray) -> np.ndarray:
+    """For each row in the input matrix, set the maximum value(s) to 1 and all other values to 0.
+
+    Args:
+        matrix (np.ndarray): A 2D numpy array representing the neighborhood matrix.
+
+    Returns:
+        np.ndarray: The modified matrix where only the maximum value(s) in each row is set to 1, and others are set to 0.
+    """
+    # Find the maximum value in each row (column-wise max operation)
+    max_values = np.max(matrix, axis=1, keepdims=True)
+    # Create a boolean mask where elements are True if they are the max value in their row
+    max_mask = matrix == max_values
+    # Set all elements to 0, and then set the maximum value positions to 1
+    matrix[:] = 0  # Set everything to 0
+    matrix[max_mask] = 1  # Set only the max values to 1
+    return matrix
+
+
 def process_neighborhoods(
     network: nx.Graph,
     neighborhoods: Dict[str, Any],
@@ -120,12 +171,12 @@ def process_neighborhoods(
 
     Args:
         network (nx.Graph): The network data structure used for imputing and pruning neighbors.
-        neighborhoods (dict): Dictionary containing 'enrichment_matrix', 'binary_enrichment_matrix', and 'significant_enrichment_matrix'.
+        neighborhoods (Dict[str, Any]): Dictionary containing 'enrichment_matrix', 'binary_enrichment_matrix', and 'significant_enrichment_matrix'.
         impute_depth (int, optional): Depth for imputing neighbors. Defaults to 0.
         prune_threshold (float, optional): Distance threshold for pruning neighbors. Defaults to 0.0.
 
     Returns:
-        dict: Processed neighborhoods data, including the updated matrices and enrichment counts.
+        Dict[str, Any]: Processed neighborhoods data, including the updated matrices and enrichment counts.
     """
     enrichment_matrix = neighborhoods["enrichment_matrix"]
     binary_enrichment_matrix = neighborhoods["binary_enrichment_matrix"]
@@ -408,7 +459,7 @@ def _calculate_threshold(median_distances: List, distance_threshold: float) -> f
     """Calculate the distance threshold based on the given median distances and a percentile threshold.
 
     Args:
-        median_distances (list): An array of median distances.
+        median_distances (List): An array of median distances.
         distance_threshold (float): A percentile threshold (0 to 1) used to determine the distance cutoff.
 
     Returns:

risk/network/geometry.py

@@ -68,6 +68,7 @@ def assign_edge_lengths(
             v_coords = np.append(v_coords, G_depth.nodes[v].get("z", 0))
 
         distance = compute_distance(u_coords, v_coords, is_sphere=compute_sphere)
+        # Assign edge lengths to the original graph
         if include_edge_weight:
             # Square root of the normalized weight is used to minimize the effect of large weights
             G.edges[u, v]["length"] = distance / np.sqrt(G.edges[u, v]["normalized_weight"] + 1e-6)

risk/network/graph.py

@@ -36,7 +36,7 @@ class NetworkGraph:
             top_annotations (pd.DataFrame): DataFrame containing annotations data for the network nodes.
             domains (pd.DataFrame): DataFrame containing domain data for the network nodes.
             trimmed_domains (pd.DataFrame): DataFrame containing trimmed domain data for the network nodes.
-            node_label_to_node_id_map (dict): A dictionary mapping node labels to their corresponding IDs.
+            node_label_to_node_id_map (Dict[str, Any]): A dictionary mapping node labels to their corresponding IDs.
             node_enrichment_sums (np.ndarray): Array containing the enrichment sums for the nodes.
         """
         self.top_annotations = top_annotations
@@ -60,14 +60,14 @@ class NetworkGraph:
         self.network = _unfold_sphere_to_plane(network)
         self.node_coordinates = _extract_node_coordinates(self.network)
 
-    def _create_domain_id_to_node_ids_map(self, domains: pd.DataFrame) -> Dict[str, Any]:
+    def _create_domain_id_to_node_ids_map(self, domains: pd.DataFrame) -> Dict[int, Any]:
         """Create a mapping from domains to the list of node IDs belonging to each domain.
 
         Args:
             domains (pd.DataFrame): DataFrame containing domain information, including the 'primary domain' for each node.
 
         Returns:
-            dict: A dictionary where keys are domain IDs and values are lists of node IDs belonging to each domain.
+            Dict[int, Any]: A dictionary where keys are domain IDs and values are lists of node IDs belonging to each domain.
         """
         cleaned_domains_matrix = domains.reset_index()[["index", "primary domain"]]
         node_to_domains_map = cleaned_domains_matrix.set_index("index")["primary domain"].to_dict()
@@ -79,14 +79,14 @@ class NetworkGraph:
 
     def _create_domain_id_to_domain_terms_map(
         self, trimmed_domains: pd.DataFrame
-    ) -> Dict[str, Any]:
+    ) -> Dict[int, Any]:
         """Create a mapping from domain IDs to their corresponding terms.
 
         Args:
             trimmed_domains (pd.DataFrame): DataFrame containing domain IDs and their corresponding labels.
 
         Returns:
-            dict: A dictionary mapping domain IDs to their corresponding terms.
+            Dict[int, Any]: A dictionary mapping domain IDs to their corresponding terms.
         """
         return dict(
             zip(
@@ -105,7 +105,7 @@ class NetworkGraph:
                 two columns are 'all domains' and 'primary domain', which are excluded from processing.
 
         Returns:
-            dict: A dictionary where the key is the node ID (index of the DataFrame), and the value is another dictionary
+            Dict[int, Dict]: A dictionary where the key is the node ID (index of the DataFrame), and the value is another dictionary
                 with 'domain' (a list of domain IDs with non-zero enrichment) and 'enrichment'
                 (a dict of domain IDs and their corresponding enrichment values).
         """
@@ -133,7 +133,7 @@ class NetworkGraph:
         """Create a map from domain IDs to node labels.
 
         Returns:
-            dict: A dictionary mapping domain IDs to the corresponding node labels.
+            Dict[int, List[str]]: A dictionary mapping domain IDs to the corresponding node labels.
         """
         domain_id_to_label_map = {}
         for domain_id, node_ids in self.domain_id_to_node_ids_map.items():

risk/network/io.py

@@ -491,7 +491,7 @@ class NetworkIO:
             if "x" not in attrs or "y" not in attrs:
                 if (
                     "pos" in attrs
-                    and isinstance(attrs["pos"], (List, Tuple, np.ndarray))
+                    and isinstance(attrs["pos"], (list, tuple, np.ndarray))
                     and len(attrs["pos"]) >= 2
                 ):
                     attrs["x"], attrs["y"] = attrs["pos"][

risk/network/plot/canvas.py

@@ -137,7 +137,7 @@ class Canvas:
             perimeter_linestyle=linestyle,
             perimeter_linewidth=linewidth,
             perimeter_color=(
-                "custom" if isinstance(color, (List, Tuple, np.ndarray)) else color
+                "custom" if isinstance(color, (list, tuple, np.ndarray)) else color
             ),  # np.ndarray usually indicates custom colors
             perimeter_outline_alpha=outline_alpha,
             perimeter_fill_alpha=fill_alpha,
@@ -210,7 +210,7 @@ class Canvas:
             perimeter_grid_size=grid_size,
             perimeter_linestyle=linestyle,
             perimeter_linewidth=linewidth,
-            perimeter_color=("custom" if isinstance(color, (List, Tuple, np.ndarray)) else color),
+            perimeter_color=("custom" if isinstance(color, (list, tuple, np.ndarray)) else color),
             perimeter_outline_alpha=outline_alpha,
             perimeter_fill_alpha=fill_alpha,
         )

risk/network/plot/contour.py

@@ -122,7 +122,7 @@ class Contour:
             ValueError: If no valid nodes are found in the network graph.
         """
         # Check if nodes is a list of lists or a flat list
-        if any(isinstance(item, (List, Tuple, np.ndarray)) for item in nodes):
+        if any(isinstance(item, (list, tuple, np.ndarray)) for item in nodes):
             # If it's a list of lists, iterate over sublists
             node_groups = nodes
             # Convert color to RGBA arrays to match the number of groups
@@ -181,7 +181,7 @@ class Contour:
         Args:
             ax (plt.Axes): The axis to draw the contour on.
             pos (np.ndarray): Array of node positions (x, y).
-            nodes (list): List of node indices to include in the contour.
+            nodes (List): List of node indices to include in the contour.
             levels (int, optional): Number of contour levels. Defaults to 5.
             bandwidth (float, optional): Bandwidth for the KDE. Controls smoothness. Defaults to 0.8.
             grid_size (int, optional): Grid resolution for the KDE. Higher values yield finer contours. Defaults to 250.

risk/network/plot/labels.py

@@ -86,7 +86,7 @@ class Labels:
             overlay_ids (bool, optional): Whether to overlay domain IDs in the center of the centroids. Defaults to False.
             ids_to_keep (List, Tuple, np.ndarray, or None, optional): IDs of domains that must be labeled. To discover domain IDs,
                 you can set `overlay_ids=True`. Defaults to None.
-            ids_to_replace (dict, optional): A dictionary mapping domain IDs to custom labels (strings). The labels should be
+            ids_to_replace (Dict, optional): A dictionary mapping domain IDs to custom labels (strings). The labels should be
                 space-separated words. If provided, the custom labels will replace the default domain terms. To discover domain IDs, you
                 can set `overlay_ids=True`. Defaults to None.
 
@@ -282,7 +282,7 @@ class Labels:
             arrow_tip_shrink (float, optional): Distance between the arrow tip and the centroid. Defaults to 0.0.
         """
         # Check if nodes is a list of lists or a flat list
-        if any(isinstance(item, (List, Tuple, np.ndarray)) for item in nodes):
+        if any(isinstance(item, (list, tuple, np.ndarray)) for item in nodes):
             # If it's a list of lists, iterate over sublists
             node_groups = nodes
             # Convert fontcolor and arrow_color to RGBA arrays to match the number of groups
@@ -347,7 +347,7 @@ class Labels:
         """Calculate the most centrally located node in .
 
         Args:
-            nodes (list): List of node labels to include in the subnetwork.
+            nodes (List): List of node labels to include in the subnetwork.
 
         Returns:
             tuple: A tuple containing the domain's central node coordinates.
@@ -382,18 +382,18 @@ class Labels:
         """Process the ids_to_keep, apply filtering, and store valid domain centroids and terms.
 
         Args:
-            domain_id_to_centroid_map (dict): Mapping of domain IDs to their centroids.
+            domain_id_to_centroid_map (Dict[str, np.ndarray]): Mapping of domain IDs to their centroids.
             ids_to_keep (List, Tuple, or np.ndarray, optional): IDs of domains that must be labeled.
-            ids_to_replace (dict, optional): A dictionary mapping domain IDs to custom labels. Defaults to None.
+            ids_to_replace (Dict[str, str], optional): A dictionary mapping domain IDs to custom labels. Defaults to None.
             words_to_omit (List, optional): List of words to omit from the labels. Defaults to None.
             max_labels (int, optional): Maximum number of labels allowed.
             min_label_lines (int): Minimum number of lines in a label.
             max_label_lines (int): Maximum number of lines in a label.
             min_chars_per_line (int): Minimum number of characters in a line to display.
             max_chars_per_line (int): Maximum number of characters in a line to display.
-            filtered_domain_centroids (dict): Dictionary to store filtered domain centroids (output).
-            filtered_domain_terms (dict): Dictionary to store filtered domain terms (output).
-            valid_indices (list): List to store valid indices (output).
+            filtered_domain_centroids (Dict[str, np.ndarray]): Dictionary to store filtered domain centroids (output).
+            filtered_domain_terms (Dict[str, str]): Dictionary to store filtered domain terms (output).
+            valid_indices (List): List to store valid indices (output).
 
         Note:
             The `filtered_domain_centroids`, `filtered_domain_terms`, and `valid_indices` are modified in-place.
@@ -448,18 +448,18 @@ class Labels:
         """Process remaining domains to fill in additional labels, respecting the remaining_labels limit.
 
         Args:
-            domain_id_to_centroid_map (dict): Mapping of domain IDs to their centroids.
+            domain_id_to_centroid_map (Dict[str, np.ndarray]): Mapping of domain IDs to their centroids.
             ids_to_keep (List, Tuple, or np.ndarray, optional): IDs of domains that must be labeled.
-            ids_to_replace (dict, optional): A dictionary mapping domain IDs to custom labels. Defaults to None.
+            ids_to_replace (Dict[str, str], optional): A dictionary mapping domain IDs to custom labels. Defaults to None.
             words_to_omit (List, optional): List of words to omit from the labels. Defaults to None.
             remaining_labels (int): The remaining number of labels that can be generated.
             min_label_lines (int): Minimum number of lines in a label.
             max_label_lines (int): Maximum number of lines in a label.
             min_chars_per_line (int): Minimum number of characters in a line to display.
             max_chars_per_line (int): Maximum number of characters in a line to display.
-            filtered_domain_centroids (dict): Dictionary to store filtered domain centroids (output).
-            filtered_domain_terms (dict): Dictionary to store filtered domain terms (output).
-            valid_indices (list): List to store valid indices (output).
+            filtered_domain_centroids (Dict[str, np.ndarray]): Dictionary to store filtered domain centroids (output).
+            filtered_domain_terms (Dict[str, str]): Dictionary to store filtered domain terms (output).
+            valid_indices (List): List to store valid indices (output).
 
         Note:
             The `filtered_domain_centroids`, `filtered_domain_terms`, and `valid_indices` are modified in-place.
@@ -551,9 +551,9 @@ class Labels:
         Args:
             domain (str): Domain ID to process.
             domain_centroid (np.ndarray): Centroid position of the domain.
-            domain_id_to_centroid_map (dict): Mapping of domain IDs to their centroids.
-            ids_to_replace (Union[Dict[str, str], None]): A dictionary mapping domain IDs to custom labels.
-            words_to_omit (Union[List[str], None]): List of words to omit from the labels.
+            domain_id_to_centroid_map (Dict[str, np.ndarray]): Mapping of domain IDs to their centroids.
+            ids_to_replace (Dict[str, str], None, optional): A dictionary mapping domain IDs to custom labels. Defaults to None.
+            words_to_omit (List[str], None, optional): List of words to omit from the labels. Defaults to None.
             min_label_lines (int): Minimum number of lines required in a label.
             max_label_lines (int): Maximum number of lines allowed in a label.
             min_chars_per_line (int): Minimum number of characters allowed per line.
@@ -606,7 +606,7 @@ class Labels:
 
         Args:
             domain (str): The domain being processed.
-            ids_to_replace (dict, optional): Dictionary mapping domain IDs to custom labels.
+            ids_to_replace (Dict[str, str], optional): Dictionary mapping domain IDs to custom labels.
             words_to_omit (List, optional): List of words to omit from the labels.
             max_label_lines (int): Maximum number of lines in a label.
             min_chars_per_line (int): Minimum number of characters in a line to display.
@@ -740,13 +740,13 @@ def _calculate_best_label_positions(
     """Calculate and optimize label positions for clarity.
 
     Args:
-        filtered_domain_centroids (dict): Centroids of the filtered domains.
+        filtered_domain_centroids (Dict[str, Any]): Centroids of the filtered domains.
         center (np.ndarray): The center coordinates for label positioning.
         radius (float): The radius for positioning labels around the center.
         offset (float): The offset distance from the radius for positioning labels.
 
     Returns:
-        dict: Optimized positions for labels.
+        Dict[str, Any]: Optimized positions for labels.
     """
     num_domains = len(filtered_domain_centroids)
     # Calculate equidistant positions around the center for initial label placement
@@ -791,11 +791,11 @@ def _optimize_label_positions(
     """Optimize label positions around the perimeter to minimize total distance to centroids.
 
     Args:
-        best_label_positions (dict): Initial positions of labels around the perimeter.
-        domain_centroids (dict): Centroid positions of the domains.
+        best_label_positions (Dict[str, Any]): Initial positions of labels around the perimeter.
+        domain_centroids (Dict[str, Any]): Centroid positions of the domains.
 
     Returns:
-        dict: Optimized label positions.
+        Dict[str, Any]: Optimized label positions.
     """
     while True:
         improvement = False  # Start each iteration assuming no improvement
@@ -827,8 +827,8 @@ def _calculate_total_distance(
     """Calculate the total distance from label positions to their domain centroids.
 
     Args:
-        label_positions (dict): Positions of labels around the perimeter.
-        domain_centroids (dict): Centroid positions of the domains.
+        label_positions (Dict[str, Any]): Positions of labels around the perimeter.
+        domain_centroids (Dict[str, Any]): Centroid positions of the domains.
 
     Returns:
         float: The total distance from labels to centroids.
@@ -851,10 +851,10 @@ def _swap_and_evaluate(
     """Swap two labels and evaluate the total distance after the swap.
 
     Args:
-        label_positions (dict): Positions of labels around the perimeter.
+        label_positions (Dict[str, Any]): Positions of labels around the perimeter.
         i (int): Index of the first label to swap.
         j (int): Index of the second label to swap.
-        domain_centroids (dict): Centroid positions of the domains.
+        domain_centroids (Dict[str, Any]): Centroid positions of the domains.
 
     Returns:
         float: The total distance after swapping the two labels.

risk/network/plot/network.py

@@ -141,7 +141,7 @@ class Network:
             ValueError: If no valid nodes are found in the network graph.
         """
         # Flatten nested lists of nodes, if necessary
-        if any(isinstance(item, (List, Tuple, np.ndarray)) for item in nodes):
+        if any(isinstance(item, (list, tuple, np.ndarray)) for item in nodes):
             nodes = [node for sublist in nodes for node in sublist]
 
         # Filter to get node IDs and their coordinates

risk/network/plot/plotter.py

@@ -67,7 +67,7 @@ class NetworkPlotter(Canvas, Network, Contour, Labels):
 
         Args:
             graph (NetworkGraph): The network data and attributes to be visualized.
-            figsize (tuple): Size of the figure in inches (width, height).
+            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`.

risk/network/plot/utils/color.py

@@ -124,7 +124,7 @@ def _get_domain_colors(
     cmap: str = "gist_rainbow",
     color: Union[str, List, Tuple, np.ndarray, None] = None,
     random_seed: int = 888,
-) -> Dict[str, Any]:
+) -> Dict[int, Any]:
     """Get colors for each domain.
 
     Args:
@@ -135,7 +135,7 @@ def _get_domain_colors(
         random_seed (int, optional): Seed for random number generation. Defaults to 888.
 
     Returns:
-        dict: A dictionary mapping domain keys to their corresponding RGBA colors.
+        Dict[int, Any]: A dictionary mapping domain keys to their corresponding RGBA colors.
     """
     # Get colors for each domain based on node positions
     domain_colors = _get_colors(
@@ -215,7 +215,7 @@ def _get_colors(
 
     Args:
         network (NetworkX graph): The graph representing the network.
-        domain_id_to_node_ids_map (dict): Mapping from domain IDs to lists of node IDs.
+        domain_id_to_node_ids_map (Dict[int, Any]): Mapping from domain IDs to lists of node IDs.
         cmap (str, optional): The name of the colormap to use. Defaults to "gist_rainbow".
         color (str, List, Tuple, np.ndarray, or None, optional): A specific color or array of colors to use for the domains.
             If None, the colormap will be used. Defaults to None.
@@ -377,7 +377,7 @@ def to_rgba(
         if isinstance(c, str):
             # Convert color names or hex values (e.g., 'red', '#FF5733') to RGBA
             rgba = np.array(mcolors.to_rgba(c))
-        elif isinstance(c, (List, Tuple, np.ndarray)) and len(c) in [3, 4]:
+        elif isinstance(c, (list, tuple, np.ndarray)) and len(c) in [3, 4]:
             # Convert RGB (3) or RGBA (4) values to RGBA format
             rgba = np.array(mcolors.to_rgba(c))
         else:
@@ -396,8 +396,8 @@ def to_rgba(
     # Handle a single color (string or RGB/RGBA list/tuple)
     if (
         isinstance(color, str)
-        or isinstance(color, (List, Tuple, np.ndarray))
-        and not any(isinstance(c, (str, List, Tuple, np.ndarray)) for c in color)
+        or isinstance(color, (list, tuple, np.ndarray))
+        and not any(isinstance(c, (str, list, tuple, np.ndarray)) for c in color)
     ):
         rgba_color = convert_to_rgba(color)
         if num_repeats:
@@ -407,7 +407,7 @@ def to_rgba(
         return np.array([rgba_color])  # Return a single color wrapped in a numpy array
 
     # Handle a list/array of colors
-    elif isinstance(color, (List, Tuple, np.ndarray)):
+    elif isinstance(color, (list, tuple, np.ndarray)):
         rgba_colors = np.array(
             [convert_to_rgba(c) for c in color]
         )  # Convert each color in the list to RGBA

risk/network/plot/utils/layout.py

@@ -35,7 +35,7 @@ def calculate_centroids(network, domain_id_to_node_ids_map):
 
     Args:
         network (NetworkX graph): The graph representing the network.
-        domain_id_to_node_ids_map (dict): Mapping from domain IDs to lists of node IDs.
+        domain_id_to_node_ids_map (Dict[int, Any]): Mapping from domain IDs to lists of node IDs.
 
     Returns:
         List[Tuple[float, float]]: List of centroids (x, y) for each domain.

risk/risk.py

@@ -3,7 +3,7 @@ risk/risk
 ~~~~~~~~~
 """
 
-from typing import Any, Dict, Tuple, Union
+from typing import Any, Dict, List, Tuple, Union
 
 import networkx as nx
 import numpy as np
@@ -58,9 +58,9 @@ class RISK(NetworkIO, AnnotationsIO):
         self,
         network: nx.Graph,
         annotations: Dict[str, Any],
-        distance_metric: str = "louvain",
+        distance_metric: Union[str, List, Tuple, np.ndarray] = "louvain",
         louvain_resolution: float = 0.1,
-        edge_length_threshold: float = 0.5,
+        edge_length_threshold: Union[float, List, Tuple, np.ndarray] = 0.5,
         null_distribution: str = "network",
         random_seed: int = 888,
     ) -> Dict[str, Any]:
@@ -68,15 +68,19 @@ class RISK(NetworkIO, AnnotationsIO):
 
         Args:
             network (nx.Graph): The network graph.
-            annotations (dict): The annotations associated with the network.
-            distance_metric (str, optional): Distance metric for neighborhood analysis. Defaults to "louvain".
+            annotations (Dict[str, Any]): The annotations associated with the network.
+            distance_metric (str, List, Tuple, or np.ndarray, optional): The distance metric(s) to use. Can be a string for one
+                metric or a list/tuple/ndarray of metrics ('greedy_modularity', 'louvain', 'label_propagation',
+                'markov_clustering', 'walktrap', 'spinglass'). Defaults to 'louvain'.
             louvain_resolution (float, optional): Resolution parameter for Louvain clustering. Defaults to 0.1.
-            edge_length_threshold (float, optional): Edge length threshold for neighborhood analysis. Defaults to 0.5.
+            edge_length_threshold (float, List, Tuple, or np.ndarray, optional): Edge length 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 'annotations'). Defaults to "network".
             random_seed (int, optional): Seed for random number generation. Defaults to 888.
 
         Returns:
-            dict: Computed significance of neighborhoods.
+            Dict[str, Any]: Computed significance of neighborhoods.
         """
         log_header("Running hypergeometric test")
         # Log neighborhood analysis parameters
@@ -111,9 +115,9 @@ class RISK(NetworkIO, AnnotationsIO):
         self,
         network: nx.Graph,
         annotations: Dict[str, Any],
-        distance_metric: str = "louvain",
+        distance_metric: Union[str, List, Tuple, np.ndarray] = "louvain",
         louvain_resolution: float = 0.1,
-        edge_length_threshold: float = 0.5,
+        edge_length_threshold: Union[float, List, Tuple, np.ndarray] = 0.5,
         null_distribution: str = "network",
         random_seed: int = 888,
     ) -> Dict[str, Any]:
@@ -121,15 +125,19 @@ class RISK(NetworkIO, AnnotationsIO):
 
         Args:
             network (nx.Graph): The network graph.
-            annotations (dict): The annotations associated with the network.
-            distance_metric (str, optional): Distance metric for neighborhood analysis. Defaults to "louvain".
+            annotations (Dict[str, Any]): The annotations associated with the network.
+            distance_metric (str, List, Tuple, or np.ndarray, optional): The distance metric(s) to use. Can be a string for one
+                metric or a list/tuple/ndarray of metrics ('greedy_modularity', 'louvain', 'label_propagation',
+                'markov_clustering', 'walktrap', 'spinglass'). Defaults to 'louvain'.
             louvain_resolution (float, optional): Resolution parameter for Louvain clustering. Defaults to 0.1.
-            edge_length_threshold (float, optional): Edge length threshold for neighborhood analysis. Defaults to 0.5.
+            edge_length_threshold (float, List, Tuple, or np.ndarray, optional): Edge length 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 'annotations'). Defaults to "network".
             random_seed (int, optional): Seed for random number generation. Defaults to 888.
 
         Returns:
-            dict: Computed significance of neighborhoods.
+            Dict[str, Any]: Computed significance of neighborhoods.
         """
         log_header("Running Poisson test")
         # Log neighborhood analysis parameters
@@ -164,9 +172,9 @@ class RISK(NetworkIO, AnnotationsIO):
         self,
         network: nx.Graph,
         annotations: Dict[str, Any],
-        distance_metric: str = "louvain",
+        distance_metric: Union[str, List, Tuple, np.ndarray] = "louvain",
         louvain_resolution: float = 0.1,
-        edge_length_threshold: float = 0.5,
+        edge_length_threshold: Union[float, List, Tuple, np.ndarray] = 0.5,
         score_metric: str = "sum",
         null_distribution: str = "network",
         num_permutations: int = 1000,
@@ -177,10 +185,14 @@ class RISK(NetworkIO, AnnotationsIO):
 
         Args:
             network (nx.Graph): The network graph.
-            annotations (dict): The annotations associated with the network.
-            distance_metric (str, optional): Distance metric for neighborhood analysis. Defaults to "louvain".
+            annotations (Dict[str, Any]): The annotations associated with the network.
+            distance_metric (str, List, Tuple, or np.ndarray, optional): The distance metric(s) to use. Can be a string for one
+                metric or a list/tuple/ndarray of metrics ('greedy_modularity', 'louvain', 'label_propagation',
+                'markov_clustering', 'walktrap', 'spinglass'). Defaults to 'louvain'.
             louvain_resolution (float, optional): Resolution parameter for Louvain clustering. Defaults to 0.1.
-            edge_length_threshold (float, optional): Edge length threshold for neighborhood analysis. Defaults to 0.5.
+            edge_length_threshold (float, List, Tuple, or np.ndarray, optional): Edge length 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 'annotations'). Defaults to "network".
             num_permutations (int, optional): Number of permutations for significance testing. Defaults to 1000.
@@ -188,7 +200,7 @@ class RISK(NetworkIO, AnnotationsIO):
             max_workers (int, optional): Maximum number of workers for parallel computation. Defaults to 1.
 
         Returns:
-            dict: Computed significance of neighborhoods.
+            Dict[str, Any]: Computed significance of neighborhoods.
         """
         log_header("Running permutation test")
         # Log neighborhood analysis parameters
@@ -253,7 +265,7 @@ class RISK(NetworkIO, AnnotationsIO):
         Args:
             network (nx.Graph): The network graph.
             annotations (pd.DataFrame): DataFrame containing annotation data for the network.
-            neighborhoods (dict): Neighborhood enrichment data.
+            neighborhoods (Dict[str, Any]): Neighborhood enrichment data.
             tail (str, optional): Type of significance tail ("right", "left", "both"). Defaults to "right".
             pval_cutoff (float, optional): p-value cutoff for significance. Defaults to 0.01.
             fdr_cutoff (float, optional): FDR cutoff for significance. Defaults to 0.9999.
@@ -353,7 +365,7 @@ class RISK(NetworkIO, AnnotationsIO):
     def load_plotter(
         self,
         graph: NetworkGraph,
-        figsize: Tuple = (10, 10),
+        figsize: Union[List, Tuple, np.ndarray] = (10, 10),
         background_color: str = "white",
         background_alpha: Union[float, None] = 1.0,
         pad: float = 0.3,
@@ -362,7 +374,7 @@ class RISK(NetworkIO, AnnotationsIO):
 
         Args:
             graph (NetworkGraph): The graph to plot.
-            figsize (Tuple, optional): Size of the figure. Defaults to (10, 10).
+            figsize (List, Tuple, or np.ndarray, optional): Size of the plot. Defaults to (10, 10)., optional): Size of the figure. Defaults to (10, 10).
             background_color (str, 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.
@@ -385,9 +397,9 @@ class RISK(NetworkIO, AnnotationsIO):
     def _load_neighborhoods(
         self,
         network: nx.Graph,
-        distance_metric: str = "louvain",
+        distance_metric: Union[str, List, Tuple, np.ndarray] = "louvain",
         louvain_resolution: float = 0.1,
-        edge_length_threshold: float = 0.5,
+        edge_length_threshold: Union[float, List, Tuple, np.ndarray] = 0.5,
         random_seed: int = 888,
     ) -> np.ndarray:
         """Load significant neighborhoods for the network.
@@ -395,9 +407,13 @@ class RISK(NetworkIO, AnnotationsIO):
         Args:
             network (nx.Graph): The network graph.
             annotations (pd.DataFrame): The matrix of annotations associated with the network.
-            distance_metric (str, optional): Distance metric for neighborhood analysis. Defaults to "louvain".
+            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', 'label_propagation',
+                'markov_clustering', 'walktrap', 'spinglass'). Defaults to 'louvain'.
             louvain_resolution (float, optional): Resolution parameter for Louvain clustering. Defaults to 0.1.
-            edge_length_threshold (float, optional): Edge length threshold for neighborhood analysis. Defaults to 0.5.
+            edge_length_threshold (float, List, Tuple, or np.ndarray, optional): Edge length 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:
@@ -437,13 +453,13 @@ class RISK(NetworkIO, AnnotationsIO):
 
         Args:
             network (nx.Graph): The network graph.
-            annotations (dict): Annotations data for the network.
-            neighborhoods (dict): Neighborhood enrichment data.
+            annotations (Dict[str, Any]): Annotations data for the network.
+            neighborhoods (Dict[str, Any]): Neighborhood enrichment data.
             min_cluster_size (int, optional): Minimum size for clusters. Defaults to 5.
             max_cluster_size (int, optional): Maximum size for clusters. Defaults to 1000.
 
         Returns:
-            dict: Top annotations identified within the network.
+            Dict[str, Any]: Top annotations identified within the network.
         """
         # Extract necessary data from annotations and neighborhoods
         ordered_annotations = annotations["ordered_annotations"]
@@ -470,7 +486,7 @@ class RISK(NetworkIO, AnnotationsIO):
         """Define domains in the network based on enrichment data.
 
         Args:
-            neighborhoods (dict): Enrichment data for neighborhoods.
+            neighborhoods (Dict[str, Any]): Enrichment data for neighborhoods.
             top_annotations (pd.DataFrame): Enrichment matrix for top annotations.
             linkage_criterion (str): Clustering criterion for defining domains.
             linkage_method (str): Clustering method to use.

risk/stats/hypergeom.py

@@ -20,7 +20,7 @@ def compute_hypergeom_test(
         null_distribution (str, optional): Type of null distribution ('network' or 'annotations'). Defaults to "network".
 
     Returns:
-        dict: Dictionary containing depletion and enrichment p-values.
+        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]

risk/stats/permutation/permutation.py

@@ -35,7 +35,7 @@ def compute_permutation_test(
         max_workers (int, optional): Number of workers for multiprocessing. Defaults to 1.
 
     Returns:
-        dict: Dictionary containing depletion and enrichment p-values.
+        Dict[str, Any]: 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)

risk/stats/poisson.py

@@ -3,7 +3,7 @@ risk/stats/poisson
 ~~~~~~~~~~~~~~~~~~
 """
 
-from typing import Dict, Any
+from typing import Any, Dict
 
 import numpy as np
 from scipy.stats import poisson
@@ -20,7 +20,7 @@ def compute_poisson_test(
         null_distribution (str, optional): Type of null distribution ('network' or 'annotations'). Defaults to "network".
 
     Returns:
-        dict: Dictionary containing depletion and enrichment p-values.
+        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

risk/stats/stats.py

@@ -3,7 +3,7 @@ risk/stats/stats
 ~~~~~~~~~~~~~~~~
 """
 
-from typing import Union
+from typing import Any, Dict, Union
 
 import numpy as np
 from statsmodels.stats.multitest import fdrcorrection
@@ -15,7 +15,7 @@ def calculate_significance_matrices(
     tail: str = "right",
     pval_cutoff: float = 0.05,
     fdr_cutoff: float = 0.05,
-) -> dict:
+) -> Dict[str, Any]:
     """Calculate significance matrices based on p-values and specified tail.
 
     Args:
@@ -26,8 +26,8 @@ def calculate_significance_matrices(
         fdr_cutoff (float, optional): Cutoff for FDR significance if applied. Defaults to 0.05.
 
     Returns:
-        dict: Dictionary containing the enrichment matrix, binary significance matrix,
-              and the matrix of significant enrichment values.
+        Dict[str, Any]: Dictionary containing the enrichment matrix, binary significance matrix,
+            and the matrix of significant enrichment values.
     """
     if fdr_cutoff < 1.0:
         # Apply FDR correction to depletion p-values

{risk_network-0.0.8b19.dist-info → risk_network-0.0.8b21.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: risk-network
-Version: 0.0.8b19
+Version: 0.0.8b21
 Summary: A Python package for biological network analysis
 Author: Ira Horecka
 Author-email: Ira Horecka <ira89@icloud.com>

risk_network-0.0.8b21.dist-info/RECORD

@@ -0,0 +1,37 @@
+risk/__init__.py,sha256=rwU6NXlpU-Cu31fRh5iXEwcYq9jIr2prM7bv_iAaksI,113
+risk/constants.py,sha256=XInRaH78Slnw_sWgAsBFbUHkyA0h0jL0DKGuQNbOvjM,550
+risk/risk.py,sha256=8J2cvtXYy99PCoOHEYNXt0vcYrcHqxi2O1VvYQNNPt4,23217
+risk/annotations/__init__.py,sha256=vUpVvMRE5if01Ic8QY6M2Ae3EFGJHdugEe9PdEkAW4Y,138
+risk/annotations/annotations.py,sha256=KHGeF5vBDmX711nA08DfhxI9z7Z1Oaeo91ueWhM6vs8,11370
+risk/annotations/io.py,sha256=powWzeimVdE0WCwlBCXyu5otMyZZHQujC0DS3m5DC0c,9505
+risk/log/__init__.py,sha256=aDUz5LMFQsz0UlsQI2EdXtiBKRLfml1UMeZKC7QQIGU,134
+risk/log/config.py,sha256=m8pzj-hN4vI_2JdJUfyOoSvzT8_lhoIfBt27sKbnOes,4535
+risk/log/params.py,sha256=rvyg86RnkHwotST7x42RgsiYfq2HB-9BZxp6KkT_04o,6415
+risk/neighborhoods/__init__.py,sha256=tKKEg4lsbqFukpgYlUGxU_v_9FOqK7V0uvM9T2QzoL0,206
+risk/neighborhoods/community.py,sha256=MAgIblbuisEPwVU6mFZd4Yd9NUKlaHK99suw51r1Is0,7065
+risk/neighborhoods/domains.py,sha256=DbhUFsvbr8wuvrNr7a0PaAJO-cdv6U3-T4CXB4-j5Qw,10930
+risk/neighborhoods/neighborhoods.py,sha256=OPGNfeGQR533vWjger7f34ZPSgw9250LQXcTEIAhQvg,21165
+risk/network/__init__.py,sha256=iEPeJdZfqp0toxtbElryB8jbz9_t_k4QQ3iDvKE8C_0,126
+risk/network/geometry.py,sha256=Y3Brp0XYWoBL2VHJX7I-gW5x-q7lGiEMqr2kqtutgkQ,6811
+risk/network/graph.py,sha256=-91JL84LYbdWohzybKFQ3NdWnervxP-wwbpaUOdRVLE,8576
+risk/network/io.py,sha256=u0PPcKjp6Xze--7eDOlvalYkjQ9S2sjiC-ac2476PUI,22942
+risk/network/plot/__init__.py,sha256=MfmaXJgAZJgXZ2wrhK8pXwzETlcMaLChhWXKAozniAo,98
+risk/network/plot/canvas.py,sha256=P8XzcesrbxjLcrT40hf15QgLTvearER2Yid3QefQF20,10778
+risk/network/plot/contour.py,sha256=vo1BeXrMKW-EipLB-9pB5AMfzmiJJduo2H_xgWUoDYo,15027
+risk/network/plot/labels.py,sha256=wdIi5UfAGVeZ1UM6AAuOQ0I4dBqQqzVe1euGCdiv91o,45115
+risk/network/plot/network.py,sha256=U-3oYxq-QTZolc72khmesS85pNlep6L40kIT-qZVljE,13615
+risk/network/plot/plotter.py,sha256=iTPMiTnTTatM_-q1Ox_bjt5Pvv-Lo8gceiYB6TVzDcw,5770
+risk/network/plot/utils/color.py,sha256=WSs1ge2oZ8yXwyVk2QqBF-avRd0aYT-sYZr9cxxAn7M,19626
+risk/network/plot/utils/layout.py,sha256=5DpRLvabgnPWwVJ-J3W6oFBBvbjCrudvvW4HDOzzoTo,1960
+risk/stats/__init__.py,sha256=WcgoETQ-hS0LQqKRsAMIPtP15xZ-4eul6VUBuUx4Wzc,220
+risk/stats/hypergeom.py,sha256=oc39f02ViB1vQ-uaDrxG_tzAT6dxQBRjc88EK2EGn78,2282
+risk/stats/poisson.py,sha256=polLgwS08MTCNzupYdmMUoEUYrJOjAbcYtYwjlfeE5Y,1803
+risk/stats/stats.py,sha256=07yMULKlCurK62x674SHKJavZtz9ge2K2ZsHix_z_pw,7088
+risk/stats/permutation/__init__.py,sha256=neJp7FENC-zg_CGOXqv-iIvz1r5XUKI9Ruxhmq7kDOI,105
+risk/stats/permutation/permutation.py,sha256=meBNSrbRa9P8WJ54n485l0H7VQJlMSfHqdN4aCKYCtQ,10105
+risk/stats/permutation/test_functions.py,sha256=lftOude6hee0pyR80HlBD32522JkDoN5hrKQ9VEbuoY,2345
+risk_network-0.0.8b21.dist-info/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+risk_network-0.0.8b21.dist-info/METADATA,sha256=WAMLlJBw45mKR3apG1PxGAQfMOm9flaJxsz_h_rwnGs,47498
+risk_network-0.0.8b21.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
+risk_network-0.0.8b21.dist-info/top_level.txt,sha256=NX7C2PFKTvC1JhVKv14DFlFAIFnKc6Lpsu1ZfxvQwVw,5
+risk_network-0.0.8b21.dist-info/RECORD,,

risk_network-0.0.8b19.dist-info/RECORD

@@ -1,37 +0,0 @@
-risk/__init__.py,sha256=jShwk2Z-jTDhGp_Y0GZIkJ1BoZFHOBTRGSKtBnS4Re0,113
-risk/constants.py,sha256=XInRaH78Slnw_sWgAsBFbUHkyA0h0jL0DKGuQNbOvjM,550
-risk/risk.py,sha256=FQp5269IsCh-flmSWIpV7sBmvbGHjlrSy89SkImkxCE,21231
-risk/annotations/__init__.py,sha256=vUpVvMRE5if01Ic8QY6M2Ae3EFGJHdugEe9PdEkAW4Y,138
-risk/annotations/annotations.py,sha256=7ilzXxrlHqN75J3q8WeHz0n79D-jAtUQx5czvC9wfIM,11303
-risk/annotations/io.py,sha256=TTXVJQgUGAlKpnGBcx7Dow146IGyozA03nSbl3S7M5M,9475
-risk/log/__init__.py,sha256=aDUz5LMFQsz0UlsQI2EdXtiBKRLfml1UMeZKC7QQIGU,134
-risk/log/config.py,sha256=m8pzj-hN4vI_2JdJUfyOoSvzT8_lhoIfBt27sKbnOes,4535
-risk/log/params.py,sha256=lgwhtO_pQWLd2_Cpu0T7BMwH5NiA4GFW0aP6d1_rJTE,6363
-risk/neighborhoods/__init__.py,sha256=tKKEg4lsbqFukpgYlUGxU_v_9FOqK7V0uvM9T2QzoL0,206
-risk/neighborhoods/community.py,sha256=stYYBXeZlGLMV-k8ckQeIqThT6v9y-S3hETobAo9590,6817
-risk/neighborhoods/domains.py,sha256=DbhUFsvbr8wuvrNr7a0PaAJO-cdv6U3-T4CXB4-j5Qw,10930
-risk/neighborhoods/neighborhoods.py,sha256=M-wL4xB_BUTlSZg90swygO5NdrZ6hFUFqs6jsiZaqHk,18260
-risk/network/__init__.py,sha256=iEPeJdZfqp0toxtbElryB8jbz9_t_k4QQ3iDvKE8C_0,126
-risk/network/geometry.py,sha256=H1yGVVqgbfpzBzJwEheDLfvGLSA284jGQQTn612L4Vc,6759
-risk/network/graph.py,sha256=X63SNlWIov3oz0aMBMZfbHdmckbLqakZli5HP2Y5OdU,8519
-risk/network/io.py,sha256=w_9fUcZUVXAPRKGhLBc7xhIJs8l83szHiBQTdaNN0gk,22942
-risk/network/plot/__init__.py,sha256=MfmaXJgAZJgXZ2wrhK8pXwzETlcMaLChhWXKAozniAo,98
-risk/network/plot/canvas.py,sha256=hdrmGd2TCuii8wn6jDQfyJTI5YXDNGYFLiU4TyqAYbE,10778
-risk/network/plot/contour.py,sha256=ecmqNpyq512Koa14OGa58Z7EP_oUOxYfS4CuU1P9ras,15027
-risk/network/plot/labels.py,sha256=hoW6AL1dAUUt2WhWOEDu-Q28L_ojf13NkuxeqfHtqWc,44848
-risk/network/plot/network.py,sha256=nfTmQxx1YwS3taXwq8WSCfu6nfKFOyxj7T5605qLXVM,13615
-risk/network/plot/plotter.py,sha256=6534tKpOb2ZXn1imu_CDM_BkLaThi50eaRsJQyjsm84,5770
-risk/network/plot/utils/color.py,sha256=Y_AUIoj_zKzChz_aC-WoYqiZ5P4qil3k7lmm4MHDaPY,19606
-risk/network/plot/utils/layout.py,sha256=znssSqe2VZzzSz47hLZtTuXwMTpHR9b8lkQPL0BX7OA,1950
-risk/stats/__init__.py,sha256=WcgoETQ-hS0LQqKRsAMIPtP15xZ-4eul6VUBuUx4Wzc,220
-risk/stats/hypergeom.py,sha256=o6Qnj31gCAKxr2uQirXrbv7XvdDJGEq69MFW-ubx_hA,2272
-risk/stats/poisson.py,sha256=8x9hB4DCukq4gNIlIKO-c_jYG1-BTwTX53oLauFyfj8,1793
-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=D84Rcpt6iTQniK0PfQGcw9bLcHbMt9p-ARcurUnIXZQ,10095
-risk/stats/permutation/test_functions.py,sha256=lftOude6hee0pyR80HlBD32522JkDoN5hrKQ9VEbuoY,2345
-risk_network-0.0.8b19.dist-info/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
-risk_network-0.0.8b19.dist-info/METADATA,sha256=zRIBsg3MXtdrk10GQ2Byns8YWleTkv0taFT67hCrBl4,47498
-risk_network-0.0.8b19.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
-risk_network-0.0.8b19.dist-info/top_level.txt,sha256=NX7C2PFKTvC1JhVKv14DFlFAIFnKc6Lpsu1ZfxvQwVw,5
-risk_network-0.0.8b19.dist-info/RECORD,,