risk-network 0.0.8b19__tar.gz → 0.0.8b20__tar.gz

{risk_network-0.0.8b19 → risk_network-0.0.8b20}/PKG-INFO

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

{risk_network-0.0.8b19 → risk_network-0.0.8b20}/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.20"

{risk_network-0.0.8b19 → risk_network-0.0.8b20}/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_network-0.0.8b19 → risk_network-0.0.8b20}/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_network-0.0.8b19 → risk_network-0.0.8b20}/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_network-0.0.8b19 → risk_network-0.0.8b20}/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_network-0.0.8b19 → risk_network-0.0.8b20}/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-0.0.8b19 → risk_network-0.0.8b20}/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-0.0.8b19 → risk_network-0.0.8b20}/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-0.0.8b19 → risk_network-0.0.8b20}/risk/network/plot/contour.py

@@ -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-0.0.8b19 → risk_network-0.0.8b20}/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.
 
@@ -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-0.0.8b19 → risk_network-0.0.8b20}/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-0.0.8b19 → risk_network-0.0.8b20}/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.

{risk_network-0.0.8b19 → risk_network-0.0.8b20}/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_network-0.0.8b19 → risk_network-0.0.8b20}/risk/risk.py

@@ -68,7 +68,7 @@ class RISK(NetworkIO, AnnotationsIO):
 
         Args:
             network (nx.Graph): The network graph.
-            annotations (dict): The annotations associated with the network.
+            annotations (Dict[str, Any]): The annotations associated with the network.
             distance_metric (str, optional): Distance metric for neighborhood analysis. 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.
@@ -76,7 +76,7 @@ class RISK(NetworkIO, AnnotationsIO):
             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
@@ -121,7 +121,7 @@ class RISK(NetworkIO, AnnotationsIO):
 
         Args:
             network (nx.Graph): The network graph.
-            annotations (dict): The annotations associated with the network.
+            annotations (Dict[str, Any]): The annotations associated with the network.
             distance_metric (str, optional): Distance metric for neighborhood analysis. 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.
@@ -129,7 +129,7 @@ class RISK(NetworkIO, AnnotationsIO):
             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
@@ -177,7 +177,7 @@ class RISK(NetworkIO, AnnotationsIO):
 
         Args:
             network (nx.Graph): The network graph.
-            annotations (dict): The annotations associated with the network.
+            annotations (Dict[str, Any]): The annotations associated with the network.
             distance_metric (str, optional): Distance metric for neighborhood analysis. 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.
@@ -188,7 +188,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 +253,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.
@@ -395,9 +395,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 +441,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 +474,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_network-0.0.8b19 → risk_network-0.0.8b20}/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_network-0.0.8b19 → risk_network-0.0.8b20}/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_network-0.0.8b19 → risk_network-0.0.8b20}/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_network-0.0.8b19 → risk_network-0.0.8b20}/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 → risk_network-0.0.8b20}/risk_network.egg-info/PKG-INFO

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