risk-network 0.0.8b20__py3-none-any.whl → 0.0.8b22__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.20"
+__version__ = "0.0.8-beta.22"

risk/annotations/__init__.py

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

risk/annotations/annotations.py

@@ -30,6 +30,8 @@ def _setup_nltk():
 
 # Ensure you have the necessary NLTK data
 _setup_nltk()
+# Initialize English stopwords
+stop_words = set(stopwords.words("english"))
 
 
 def load_annotations(network: nx.Graph, annotations_input: Dict[str, Any]) -> Dict[str, Any]:
@@ -47,11 +49,11 @@ def load_annotations(network: nx.Graph, annotations_input: Dict[str, Any]) -> Di
         (node, annotation) for annotation, nodes in annotations_input.items() for node in nodes
     ]
     # Create a DataFrame from the flattened list
-    annotations = pd.DataFrame(flattened_annotations, columns=["Node", "Annotations"])
-    annotations["Is Member"] = 1
+    annotations = pd.DataFrame(flattened_annotations, columns=["node", "annotations"])
+    annotations["is_member"] = 1
     # Pivot to create a binary matrix with nodes as rows and annotations as columns
     annotations_pivot = annotations.pivot_table(
-        index="Node", columns="Annotations", values="Is Member", fill_value=0, dropna=False
+        index="node", columns="annotations", values="is_member", fill_value=0, dropna=False
     )
     # Reindex the annotations matrix based on the node labels from the network
     node_label_order = list(nx.get_node_attributes(network, "label").values())
@@ -81,7 +83,8 @@ def define_top_annotations(
     network: nx.Graph,
     ordered_annotation_labels: List[str],
     neighborhood_enrichment_sums: List[int],
-    binary_enrichment_matrix: np.ndarray,
+    significant_enrichment_matrix: np.ndarray,
+    significant_binary_enrichment_matrix: np.ndarray,
     min_cluster_size: int = 5,
     max_cluster_size: int = 1000,
 ) -> pd.DataFrame:
@@ -91,42 +94,52 @@ def define_top_annotations(
         network (NetworkX graph): The network graph.
         ordered_annotation_labels (list of str): List of ordered annotation labels.
         neighborhood_enrichment_sums (list of int): List of neighborhood enrichment sums.
-        binary_enrichment_matrix (np.ndarray): Binary enrichment matrix below alpha threshold.
+        significant_enrichment_matrix (np.ndarray): Enrichment matrix below alpha threshold.
+        significant_binary_enrichment_matrix (np.ndarray): Binary enrichment matrix below alpha threshold.
         min_cluster_size (int, optional): Minimum cluster size. Defaults to 5.
         max_cluster_size (int, optional): Maximum cluster size. Defaults to 1000.
 
     Returns:
         pd.DataFrame: DataFrame with top annotations and their properties.
     """
-    # Create DataFrame to store annotations and their neighborhood enrichment sums
+    # Sum the columns of the significant enrichment matrix (positive floating point values)
+    significant_enrichment_scores = significant_enrichment_matrix.sum(axis=0)
+    # Create DataFrame to store annotations, their neighborhood enrichment sums, and enrichment scores
     annotations_enrichment_matrix = pd.DataFrame(
         {
             "id": range(len(ordered_annotation_labels)),
-            "words": ordered_annotation_labels,
-            "neighborhood enrichment sums": neighborhood_enrichment_sums,
+            "full_terms": ordered_annotation_labels,
+            "significant_neighborhood_enrichment_sums": neighborhood_enrichment_sums,
+            "significant_enrichment_score": significant_enrichment_scores,
         }
     )
-    annotations_enrichment_matrix["top attributes"] = False
-    # Apply size constraints to identify potential top attributes
+    annotations_enrichment_matrix["significant_annotations"] = False
+    # Apply size constraints to identify potential significant annotations
     annotations_enrichment_matrix.loc[
-        (annotations_enrichment_matrix["neighborhood enrichment sums"] >= min_cluster_size)
-        & (annotations_enrichment_matrix["neighborhood enrichment sums"] <= max_cluster_size),
-        "top attributes",
+        (
+            annotations_enrichment_matrix["significant_neighborhood_enrichment_sums"]
+            >= min_cluster_size
+        )
+        & (
+            annotations_enrichment_matrix["significant_neighborhood_enrichment_sums"]
+            <= max_cluster_size
+        ),
+        "significant_annotations",
     ] = True
     # Initialize columns for connected components analysis
-    annotations_enrichment_matrix["num connected components"] = 0
-    annotations_enrichment_matrix["size connected components"] = None
-    annotations_enrichment_matrix["size connected components"] = annotations_enrichment_matrix[
-        "size connected components"
+    annotations_enrichment_matrix["num_connected_components"] = 0
+    annotations_enrichment_matrix["size_connected_components"] = None
+    annotations_enrichment_matrix["size_connected_components"] = annotations_enrichment_matrix[
+        "size_connected_components"
     ].astype(object)
-    annotations_enrichment_matrix["num large connected components"] = 0
+    annotations_enrichment_matrix["num_large_connected_components"] = 0
 
     for attribute in annotations_enrichment_matrix.index.values[
-        annotations_enrichment_matrix["top attributes"]
+        annotations_enrichment_matrix["significant_annotations"]
     ]:
         # Identify enriched neighborhoods based on the binary enrichment matrix
         enriched_neighborhoods = list(
-            compress(list(network), binary_enrichment_matrix[:, attribute])
+            compress(list(network), significant_binary_enrichment_matrix[:, attribute])
         )
         enriched_network = nx.subgraph(network, enriched_neighborhoods)
         # Analyze connected components within the enriched subnetwork
@@ -145,55 +158,67 @@ def define_top_annotations(
         num_large_connected_components = len(filtered_size_connected_components)
 
         # Assign the number of connected components
-        annotations_enrichment_matrix.loc[attribute, "num connected components"] = (
+        annotations_enrichment_matrix.loc[attribute, "num_connected_components"] = (
             num_connected_components
         )
         # Filter out attributes with more than one connected component
         annotations_enrichment_matrix.loc[
-            annotations_enrichment_matrix["num connected components"] > 1, "top attributes"
+            annotations_enrichment_matrix["num_connected_components"] > 1, "significant_annotations"
         ] = False
         # Assign the number of large connected components
-        annotations_enrichment_matrix.loc[attribute, "num large connected components"] = (
+        annotations_enrichment_matrix.loc[attribute, "num_large_connected_components"] = (
             num_large_connected_components
         )
         # Assign the size of connected components, ensuring it is always a list
-        annotations_enrichment_matrix.at[attribute, "size connected components"] = (
+        annotations_enrichment_matrix.at[attribute, "size_connected_components"] = (
             filtered_size_connected_components.tolist()
         )
 
     return annotations_enrichment_matrix
 
 
-def get_description(words_column: pd.Series) -> str:
-    """Process input Series to identify and return the top frequent, significant words,
-    filtering based on stopwords and gracefully handling numerical strings.
+def get_weighted_description(words_column: pd.Series, scores_column: pd.Series) -> str:
+    """Generate a weighted description from words and their corresponding scores,
+    with support for stopwords filtering and improved weighting logic.
 
     Args:
         words_column (pd.Series): A pandas Series containing strings to process.
+        scores_column (pd.Series): A pandas Series containing enrichment scores to weigh the terms.
 
     Returns:
-        str: A coherent description formed from the most frequent and significant words.
+        str: A coherent description formed from the most frequent and significant words, weighed by enrichment scores.
     """
-    # Concatenate all rows into a single string and tokenize into words
-    all_words = words_column.str.cat(sep=" ")
-    tokens = word_tokenize(all_words)
+    # Handle case where all scores are the same
+    if scores_column.max() == scores_column.min():
+        normalized_scores = pd.Series([1] * len(scores_column))
+    else:
+        # Normalize the enrichment scores to be between 0 and 1
+        normalized_scores = (scores_column - scores_column.min()) / (
+            scores_column.max() - scores_column.min()
+        )
 
+    # Combine words and normalized scores to create weighted words
+    weighted_words = []
+    for word, score in zip(words_column, normalized_scores):
+        word = str(word)
+        if word not in stop_words:  # Skip stopwords
+            weight = max(1, int((0 if pd.isna(score) else score) * 10))
+            weighted_words.extend([word] * weight)
+
+    # Tokenize the weighted words
+    tokens = word_tokenize(" ".join(weighted_words))
     # Separate numeric tokens
     numeric_tokens = [token for token in tokens if token.replace(".", "", 1).isdigit()]
-    # If there's only one unique numeric value, return it directly as a string
     unique_numeric_values = set(numeric_tokens)
     if len(unique_numeric_values) == 1:
         return f"{list(unique_numeric_values)[0]}"
 
-    # Ensure that all values in 'words' are strings and include both alphabetic and numeric tokens
-    words = [
-        str(word)  # Convert to string to ensure consistent processing
-        for word in tokens
-        if word.isalpha()
-        or word.replace(".", "", 1).isdigit()  # Keep alphabetic words and numeric strings
-    ]
+    # Filter alphabetic and numeric tokens
+    words = [word for word in tokens if word.isalpha() or word.replace(".", "", 1).isdigit()]
+    # Apply word similarity filtering to remove redundant terms
+    simplified_words = _simplify_word_list(words)
     # Generate a coherent description from the processed words
-    description = _generate_coherent_description(words)
+    description = _generate_coherent_description(simplified_words)
 
     return description
 

risk/neighborhoods/domains.py

@@ -13,7 +13,7 @@ import pandas as pd
 from scipy.cluster.hierarchy import linkage, fcluster
 from sklearn.metrics import silhouette_score
 
-from risk.annotations import get_description
+from risk.annotations import get_weighted_description
 from risk.constants import GROUP_LINKAGE_METHODS, GROUP_DISTANCE_METRICS
 from risk.log import logger
 
@@ -40,7 +40,7 @@ def define_domains(
     """
     try:
         # Transpose the matrix to cluster annotations
-        m = significant_neighborhoods_enrichment[:, top_annotations["top attributes"]].T
+        m = significant_neighborhoods_enrichment[:, top_annotations["significant_annotations"]].T
         best_linkage, best_metric, best_threshold = _optimize_silhouette_across_linkage_and_metrics(
             m, linkage_criterion, linkage_method, linkage_metric
         )
@@ -55,7 +55,7 @@ def define_domains(
         # Assign domains to the annotations matrix
         domains = fcluster(Z, max_d_optimal, criterion=linkage_criterion)
         top_annotations["domain"] = 0
-        top_annotations.loc[top_annotations["top attributes"], "domain"] = domains
+        top_annotations.loc[top_annotations["significant_annotations"], "domain"] = domains
     except ValueError:
         # If a ValueError is encountered, handle it by assigning unique domains
         n_rows = len(top_annotations)
@@ -77,11 +77,11 @@ def define_domains(
     t_idxmax[t_max == 0] = 0
 
     # Assign all domains where the score is greater than 0
-    node_to_domain["all domains"] = node_to_domain.loc[:, 1:].apply(
+    node_to_domain["all_domains"] = node_to_domain.loc[:, 1:].apply(
         lambda row: list(row[row > 0].index), axis=1
     )
     # Assign primary domain
-    node_to_domain["primary domain"] = t_idxmax
+    node_to_domain["primary_domain"] = t_idxmax
 
     return node_to_domain
 
@@ -107,7 +107,7 @@ def trim_domains_and_top_annotations(
             - A DataFrame with domain labels (pd.DataFrame)
     """
     # Identify domains to remove based on size criteria
-    domain_counts = domains["primary domain"].value_counts()
+    domain_counts = domains["primary_domain"].value_counts()
     to_remove = set(
         domain_counts[(domain_counts < min_cluster_size) | (domain_counts > max_cluster_size)].index
     )
@@ -117,32 +117,51 @@ def trim_domains_and_top_annotations(
     invalid_domain_ids = {0, invalid_domain_id}
     # Mark domains to be removed
     top_annotations["domain"].replace(to_remove, invalid_domain_id, inplace=True)
-    domains.loc[domains["primary domain"].isin(to_remove), ["primary domain"]] = invalid_domain_id
+    domains.loc[domains["primary_domain"].isin(to_remove), ["primary_domain"]] = invalid_domain_id
 
     # Normalize "num enriched neighborhoods" by percentile for each domain and scale to 0-10
     top_annotations["normalized_value"] = top_annotations.groupby("domain")[
-        "neighborhood enrichment sums"
+        "significant_neighborhood_enrichment_sums"
     ].transform(lambda x: (x.rank(pct=True) * 10).apply(np.ceil).astype(int))
-    # Multiply 'words' column by normalized values
-    top_annotations["words"] = top_annotations.apply(
-        lambda row: " ".join([str(row["words"])] * row["normalized_value"]), axis=1
+    # Modify the lambda function to pass both full_terms and significant_enrichment_score
+    top_annotations["combined_terms"] = top_annotations.apply(
+        lambda row: " ".join([str(row["full_terms"])] * row["normalized_value"]), axis=1
     )
 
-    # Generate domain labels
-    domain_labels = top_annotations.groupby("domain")["words"].apply(get_description).reset_index()
+    # Perform the groupby operation while retaining the other columns and adding the weighting with enrichment scores
+    domain_labels = (
+        top_annotations.groupby("domain")
+        .agg(
+            full_terms=("full_terms", lambda x: list(x)),
+            enrichment_scores=("significant_enrichment_score", lambda x: list(x)),
+        )
+        .reset_index()
+    )
+    domain_labels["combined_terms"] = domain_labels.apply(
+        lambda row: get_weighted_description(
+            pd.Series(row["full_terms"]), pd.Series(row["enrichment_scores"])
+        ),
+        axis=1,
+    )
+
+    # Rename the columns as necessary
     trimmed_domains_matrix = domain_labels.rename(
-        columns={"domain": "id", "words": "label"}
+        columns={
+            "domain": "id",
+            "combined_terms": "normalized_description",
+            "full_terms": "full_descriptions",
+            "enrichment_scores": "enrichment_scores",
+        }
     ).set_index("id")
 
     # Remove invalid domains
     valid_annotations = top_annotations[~top_annotations["domain"].isin(invalid_domain_ids)].drop(
         columns=["normalized_value"]
     )
-    valid_domains = domains[~domains["primary domain"].isin(invalid_domain_ids)]
+    valid_domains = domains[~domains["primary_domain"].isin(invalid_domain_ids)]
     valid_trimmed_domains_matrix = trimmed_domains_matrix[
         ~trimmed_domains_matrix.index.isin(invalid_domain_ids)
     ]
-
     return valid_annotations, valid_domains, valid_trimmed_domains_matrix
 
 

risk/neighborhoods/neighborhoods.py

@@ -171,7 +171,7 @@ def process_neighborhoods(
 
     Args:
         network (nx.Graph): The network data structure used for imputing and pruning neighbors.
-        neighborhoods (Dict[str, Any]): Dictionary containing 'enrichment_matrix', 'binary_enrichment_matrix', and 'significant_enrichment_matrix'.
+        neighborhoods (Dict[str, Any]): Dictionary containing 'enrichment_matrix', 'significant_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.
 
@@ -179,18 +179,18 @@ def process_neighborhoods(
         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"]
+    significant_binary_enrichment_matrix = neighborhoods["significant_binary_enrichment_matrix"]
     significant_enrichment_matrix = neighborhoods["significant_enrichment_matrix"]
     logger.debug(f"Imputation depth: {impute_depth}")
     if impute_depth:
         (
             enrichment_matrix,
-            binary_enrichment_matrix,
+            significant_binary_enrichment_matrix,
             significant_enrichment_matrix,
         ) = _impute_neighbors(
             network,
             enrichment_matrix,
-            binary_enrichment_matrix,
+            significant_binary_enrichment_matrix,
             max_depth=impute_depth,
         )
 
@@ -198,20 +198,20 @@ def process_neighborhoods(
     if prune_threshold:
         (
             enrichment_matrix,
-            binary_enrichment_matrix,
+            significant_binary_enrichment_matrix,
             significant_enrichment_matrix,
         ) = _prune_neighbors(
             network,
             enrichment_matrix,
-            binary_enrichment_matrix,
+            significant_binary_enrichment_matrix,
             distance_threshold=prune_threshold,
         )
 
-    neighborhood_enrichment_counts = np.sum(binary_enrichment_matrix, axis=0)
+    neighborhood_enrichment_counts = np.sum(significant_binary_enrichment_matrix, axis=0)
     node_enrichment_sums = np.sum(enrichment_matrix, axis=1)
     return {
         "enrichment_matrix": enrichment_matrix,
-        "binary_enrichment_matrix": binary_enrichment_matrix,
+        "significant_binary_enrichment_matrix": significant_binary_enrichment_matrix,
         "significant_enrichment_matrix": significant_enrichment_matrix,
         "neighborhood_enrichment_counts": neighborhood_enrichment_counts,
         "node_enrichment_sums": node_enrichment_sums,
@@ -221,7 +221,7 @@ def process_neighborhoods(
 def _impute_neighbors(
     network: nx.Graph,
     enrichment_matrix: np.ndarray,
-    binary_enrichment_matrix: np.ndarray,
+    significant_binary_enrichment_matrix: np.ndarray,
     max_depth: int = 3,
 ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
     """Impute rows with sums of zero in the enrichment matrix based on the closest non-zero neighbors in the network graph.
@@ -229,7 +229,7 @@ def _impute_neighbors(
     Args:
         network (nx.Graph): The network graph with nodes having IDs matching the matrix indices.
         enrichment_matrix (np.ndarray): The enrichment matrix with rows to be imputed.
-        binary_enrichment_matrix (np.ndarray): The alpha threshold matrix to be imputed similarly.
+        significant_binary_enrichment_matrix (np.ndarray): The alpha threshold matrix to be imputed similarly.
         max_depth (int): Maximum depth of nodes to traverse for imputing values.
 
     Returns:
@@ -239,19 +239,21 @@ def _impute_neighbors(
             - np.ndarray: The significant enrichment matrix with non-significant entries set to zero.
     """
     # Calculate the distance threshold value based on the shortest distances
-    enrichment_matrix, binary_enrichment_matrix = _impute_neighbors_with_similarity(
-        network, enrichment_matrix, binary_enrichment_matrix, max_depth=max_depth
+    enrichment_matrix, significant_binary_enrichment_matrix = _impute_neighbors_with_similarity(
+        network, enrichment_matrix, significant_binary_enrichment_matrix, max_depth=max_depth
     )
     # Create a matrix where non-significant entries are set to zero
-    significant_enrichment_matrix = np.where(binary_enrichment_matrix == 1, enrichment_matrix, 0)
+    significant_enrichment_matrix = np.where(
+        significant_binary_enrichment_matrix == 1, enrichment_matrix, 0
+    )
 
-    return enrichment_matrix, binary_enrichment_matrix, significant_enrichment_matrix
+    return enrichment_matrix, significant_binary_enrichment_matrix, significant_enrichment_matrix
 
 
 def _impute_neighbors_with_similarity(
     network: nx.Graph,
     enrichment_matrix: np.ndarray,
-    binary_enrichment_matrix: np.ndarray,
+    significant_binary_enrichment_matrix: np.ndarray,
     max_depth: int = 3,
 ) -> Tuple[np.ndarray, np.ndarray]:
     """Impute non-enriched nodes based on the closest enriched neighbors' profiles and their similarity.
@@ -259,7 +261,7 @@ def _impute_neighbors_with_similarity(
     Args:
         network (nx.Graph): The network graph with nodes having IDs matching the matrix indices.
         enrichment_matrix (np.ndarray): The enrichment matrix with rows to be imputed.
-        binary_enrichment_matrix (np.ndarray): The alpha threshold matrix to be imputed similarly.
+        significant_binary_enrichment_matrix (np.ndarray): The alpha threshold matrix to be imputed similarly.
         max_depth (int): Maximum depth of nodes to traverse for imputing values.
 
     Returns:
@@ -268,27 +270,31 @@ def _impute_neighbors_with_similarity(
             - The imputed alpha threshold matrix.
     """
     depth = 1
-    rows_to_impute = np.where(binary_enrichment_matrix.sum(axis=1) == 0)[0]
+    rows_to_impute = np.where(significant_binary_enrichment_matrix.sum(axis=1) == 0)[0]
     while len(rows_to_impute) and depth <= max_depth:
         # Iterate over all enriched nodes
-        for row_index in range(binary_enrichment_matrix.shape[0]):
-            if binary_enrichment_matrix[row_index].sum() != 0:
-                enrichment_matrix, binary_enrichment_matrix = _process_node_imputation(
-                    row_index, network, enrichment_matrix, binary_enrichment_matrix, depth
+        for row_index in range(significant_binary_enrichment_matrix.shape[0]):
+            if significant_binary_enrichment_matrix[row_index].sum() != 0:
+                enrichment_matrix, significant_binary_enrichment_matrix = _process_node_imputation(
+                    row_index,
+                    network,
+                    enrichment_matrix,
+                    significant_binary_enrichment_matrix,
+                    depth,
                 )
 
         # Update rows to impute for the next iteration
-        rows_to_impute = np.where(binary_enrichment_matrix.sum(axis=1) == 0)[0]
+        rows_to_impute = np.where(significant_binary_enrichment_matrix.sum(axis=1) == 0)[0]
         depth += 1
 
-    return enrichment_matrix, binary_enrichment_matrix
+    return enrichment_matrix, significant_binary_enrichment_matrix
 
 
 def _process_node_imputation(
     row_index: int,
     network: nx.Graph,
     enrichment_matrix: np.ndarray,
-    binary_enrichment_matrix: np.ndarray,
+    significant_binary_enrichment_matrix: np.ndarray,
     depth: int,
 ) -> Tuple[np.ndarray, np.ndarray]:
     """Process the imputation for a single node based on its enriched neighbors.
@@ -297,7 +303,7 @@ def _process_node_imputation(
         row_index (int): The index of the enriched node being processed.
         network (nx.Graph): The network graph with nodes having IDs matching the matrix indices.
         enrichment_matrix (np.ndarray): The enrichment matrix with rows to be imputed.
-        binary_enrichment_matrix (np.ndarray): The alpha threshold matrix to be imputed similarly.
+        significant_binary_enrichment_matrix (np.ndarray): The alpha threshold matrix to be imputed similarly.
         depth (int): Current depth for traversal.
 
     Returns:
@@ -310,7 +316,7 @@ def _process_node_imputation(
         n
         for n in neighbors
         if n != row_index
-        and binary_enrichment_matrix[n].sum() != 0
+        and significant_binary_enrichment_matrix[n].sum() != 0
         and enrichment_matrix[n].sum() != 0
     ]
     # Filter non-enriched neighbors
@@ -318,7 +324,7 @@ def _process_node_imputation(
         n
         for n in neighbors
         if n != row_index
-        and binary_enrichment_matrix[n].sum() == 0
+        and significant_binary_enrichment_matrix[n].sum() == 0
         and enrichment_matrix[n].sum() == 0
     ]
     # If there are valid non-enriched neighbors
@@ -363,15 +369,17 @@ def _process_node_imputation(
             enrichment_matrix[most_similar_neighbor] = enrichment_matrix[row_index] / np.sqrt(
                 depth + 1
             )
-            binary_enrichment_matrix[most_similar_neighbor] = binary_enrichment_matrix[row_index]
+            significant_binary_enrichment_matrix[most_similar_neighbor] = (
+                significant_binary_enrichment_matrix[row_index]
+            )
 
-    return enrichment_matrix, binary_enrichment_matrix
+    return enrichment_matrix, significant_binary_enrichment_matrix
 
 
 def _prune_neighbors(
     network: nx.Graph,
     enrichment_matrix: np.ndarray,
-    binary_enrichment_matrix: np.ndarray,
+    significant_binary_enrichment_matrix: np.ndarray,
     distance_threshold: float = 0.9,
 ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
     """Remove outliers based on their rank for edge lengths.
@@ -379,7 +387,7 @@ def _prune_neighbors(
     Args:
         network (nx.Graph): The network graph with nodes having IDs matching the matrix indices.
         enrichment_matrix (np.ndarray): The enrichment matrix.
-        binary_enrichment_matrix (np.ndarray): The alpha threshold matrix.
+        significant_binary_enrichment_matrix (np.ndarray): The alpha threshold matrix.
         distance_threshold (float): Rank threshold (0 to 1) to determine outliers.
 
     Returns:
@@ -389,10 +397,12 @@ def _prune_neighbors(
             - np.ndarray: The significant enrichment matrix, where non-significant entries are set to zero.
     """
     # Identify indices with non-zero rows in the binary enrichment matrix
-    non_zero_indices = np.where(binary_enrichment_matrix.sum(axis=1) != 0)[0]
+    non_zero_indices = np.where(significant_binary_enrichment_matrix.sum(axis=1) != 0)[0]
     median_distances = []
     for node in non_zero_indices:
-        neighbors = [n for n in network.neighbors(node) if binary_enrichment_matrix[n].sum() != 0]
+        neighbors = [
+            n for n in network.neighbors(node) if significant_binary_enrichment_matrix[n].sum() != 0
+        ]
         if neighbors:
             median_distance = np.median(
                 [_get_euclidean_distance(node, n, network) for n in neighbors]
@@ -404,7 +414,9 @@ def _prune_neighbors(
     # Prune nodes that are outliers based on the distance threshold
     for row_index in non_zero_indices:
         neighbors = [
-            n for n in network.neighbors(row_index) if binary_enrichment_matrix[n].sum() != 0
+            n
+            for n in network.neighbors(row_index)
+            if significant_binary_enrichment_matrix[n].sum() != 0
         ]
         if neighbors:
             median_distance = np.median(
@@ -412,12 +424,14 @@ def _prune_neighbors(
             )
             if median_distance >= distance_threshold_value:
                 enrichment_matrix[row_index] = 0
-                binary_enrichment_matrix[row_index] = 0
+                significant_binary_enrichment_matrix[row_index] = 0
 
     # Create a matrix where non-significant entries are set to zero
-    significant_enrichment_matrix = np.where(binary_enrichment_matrix == 1, enrichment_matrix, 0)
+    significant_enrichment_matrix = np.where(
+        significant_binary_enrichment_matrix == 1, enrichment_matrix, 0
+    )
 
-    return enrichment_matrix, binary_enrichment_matrix, significant_enrichment_matrix
+    return enrichment_matrix, significant_binary_enrichment_matrix, significant_enrichment_matrix
 
 
 def _get_euclidean_distance(node1: Any, node2: Any, network: nx.Graph) -> float:

risk/network/graph.py

@@ -45,6 +45,10 @@ class NetworkGraph:
         self.domain_id_to_domain_terms_map = self._create_domain_id_to_domain_terms_map(
             trimmed_domains
         )
+        self.domain_id_to_domain_info_map = self._create_domain_id_to_domain_info_map(
+            trimmed_domains
+        )
+        self.trimmed_domains = trimmed_domains
         self.node_enrichment_sums = node_enrichment_sums
         self.node_id_to_domain_ids_and_enrichments_map = (
             self._create_node_id_to_domain_ids_and_enrichments(domains)
@@ -60,7 +64,8 @@ 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[int, Any]:
+    @staticmethod
+    def _create_domain_id_to_node_ids_map(domains: pd.DataFrame) -> Dict[int, Any]:
         """Create a mapping from domains to the list of node IDs belonging to each domain.
 
         Args:
@@ -69,17 +74,16 @@ class NetworkGraph:
         Returns:
             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()
+        cleaned_domains_matrix = domains.reset_index()[["index", "primary_domain"]]
+        node_to_domains_map = cleaned_domains_matrix.set_index("index")["primary_domain"].to_dict()
         domain_id_to_node_ids_map = defaultdict(list)
         for k, v in node_to_domains_map.items():
             domain_id_to_node_ids_map[v].append(k)
 
         return domain_id_to_node_ids_map
 
-    def _create_domain_id_to_domain_terms_map(
-        self, trimmed_domains: pd.DataFrame
-    ) -> Dict[int, Any]:
+    @staticmethod
+    def _create_domain_id_to_domain_terms_map(trimmed_domains: pd.DataFrame) -> Dict[int, Any]:
         """Create a mapping from domain IDs to their corresponding terms.
 
         Args:
@@ -91,13 +95,32 @@ class NetworkGraph:
         return dict(
             zip(
                 trimmed_domains.index,
-                trimmed_domains["label"],
+                trimmed_domains["normalized_description"],
             )
         )
 
-    def _create_node_id_to_domain_ids_and_enrichments(
-        self, domains: pd.DataFrame
-    ) -> Dict[int, Dict]:
+    @staticmethod
+    def _create_domain_id_to_domain_info_map(
+        trimmed_domains: pd.DataFrame,
+    ) -> Dict[int, Dict[str, Any]]:
+        """Create a mapping from domain IDs to their corresponding full description and enrichment score.
+
+        Args:
+            trimmed_domains (pd.DataFrame): DataFrame containing domain IDs, full descriptions, and enrichment scores.
+
+        Returns:
+            Dict[int, Dict[str, Any]]: A dictionary mapping domain IDs (int) to a dictionary with 'full_descriptions' and 'enrichment_scores'.
+        """
+        return {
+            int(id_): {
+                "full_descriptions": trimmed_domains.at[id_, "full_descriptions"],
+                "enrichment_scores": trimmed_domains.at[id_, "enrichment_scores"],
+            }
+            for id_ in trimmed_domains.index
+        }
+
+    @staticmethod
+    def _create_node_id_to_domain_ids_and_enrichments(domains: pd.DataFrame) -> Dict[int, Dict]:
         """Creates a dictionary mapping each node ID to its corresponding domain IDs and enrichment values.
 
         Args:

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,18 +137,12 @@ 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,
         )
 
-        # Convert color to RGBA using the to_rgba helper function - use outline_alpha for the perimeter
-        color = to_rgba(
-            color=color, alpha=outline_alpha, num_repeats=1
-        )  # num_repeats=1 for a single color
-        # Set the fill_alpha to 0 if not provided
-        fill_alpha = fill_alpha if fill_alpha is not None else 0.0
         # Extract node coordinates from the network graph
         node_coordinates = self.graph.node_coordinates
         # Calculate the center and radius of the bounding box around the network
@@ -156,20 +150,26 @@ class Canvas:
         # Scale the radius by the scale factor
         scaled_radius = radius * scale
 
+        # Convert color to RGBA using the to_rgba helper function - use outline_alpha for the perimeter
+        outline_color_rgba = to_rgba(
+            color=color, alpha=outline_alpha, num_repeats=1
+        )  # num_repeats=1 for a single color
+        fill_color_rgba = to_rgba(
+            color=color, alpha=fill_alpha, num_repeats=1
+        )  # num_repeats=1 for a single color
+
         # Draw a circle to represent the network perimeter
         circle = plt.Circle(
             center,
             scaled_radius,
             linestyle=linestyle,
             linewidth=linewidth,
-            color=color,
-            fill=fill_alpha > 0,  # Fill the circle if fill_alpha is greater than 0
+            color=outline_color_rgba,
         )
         # Set the transparency of the fill if applicable
-        if fill_alpha > 0:
-            circle.set_facecolor(
-                to_rgba(color=color, alpha=fill_alpha, num_repeats=1)
-            )  # num_repeats=1 for a single color
+        circle.set_facecolor(
+            to_rgba(color=fill_color_rgba, num_repeats=1)
+        )  # num_repeats=1 for a single color
 
         self.ax.add_artist(circle)
 
@@ -210,13 +210,13 @@ 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,
         )
 
         # Convert color to RGBA using outline_alpha for the line (outline)
-        outline_color = to_rgba(color=color, num_repeats=1)  # num_repeats=1 for a single color
+        outline_color_rgba = to_rgba(color=color, num_repeats=1)  # num_repeats=1 for a single color
         # Extract node coordinates from the network graph
         node_coordinates = self.graph.node_coordinates
         # Scale the node coordinates if needed
@@ -229,9 +229,8 @@ class Canvas:
             levels=levels,
             bandwidth=bandwidth,
             grid_size=grid_size,
-            color=outline_color,
+            color=outline_color_rgba,
             linestyle=linestyle,
             linewidth=linewidth,
-            alpha=outline_alpha,
             fill_alpha=fill_alpha,
         )

risk/network/plot/contour.py

@@ -68,13 +68,15 @@ class Contour:
         )
 
         # Ensure color is converted to RGBA with repetition matching the number of domains
-        color = to_rgba(
+        color_rgba = to_rgba(
             color=color, alpha=alpha, num_repeats=len(self.graph.domain_id_to_node_ids_map)
         )
         # Extract node coordinates from the network graph
         node_coordinates = self.graph.node_coordinates
         # Draw contours for each domain in the network
         for idx, (_, node_ids) in enumerate(self.graph.domain_id_to_node_ids_map.items()):
+            # Use the provided alpha value if it's not None, otherwise use the color's alpha
+            current_fill_alpha = fill_alpha if fill_alpha is not None else color_rgba[idx][3]
             if len(node_ids) > 1:
                 self._draw_kde_contour(
                     self.ax,
@@ -86,8 +88,7 @@ class Contour:
                     grid_size=grid_size,
                     linestyle=linestyle,
                     linewidth=linewidth,
-                    alpha=alpha,
-                    fill_alpha=fill_alpha,
+                    fill_alpha=current_fill_alpha,
                 )
 
     def plot_subcontour(
@@ -122,7 +123,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
@@ -148,6 +149,8 @@ class Contour:
 
             # Draw the KDE contour for the specified nodes
             node_coordinates = self.graph.node_coordinates
+            # Use the provided alpha value if it's not None, otherwise use the color's alpha
+            current_fill_alpha = fill_alpha if fill_alpha is not None else color_rgba[idx][3]
             self._draw_kde_contour(
                 self.ax,
                 node_coordinates,
@@ -158,8 +161,7 @@ class Contour:
                 grid_size=grid_size,
                 linestyle=linestyle,
                 linewidth=linewidth,
-                alpha=alpha,
-                fill_alpha=fill_alpha,
+                fill_alpha=current_fill_alpha,
             )
 
     def _draw_kde_contour(
@@ -173,7 +175,6 @@ class Contour:
         color: Union[str, np.ndarray] = "white",
         linestyle: str = "solid",
         linewidth: float = 1.5,
-        alpha: Union[float, None] = 1.0,
         fill_alpha: Union[float, None] = 0.2,
     ) -> None:
         """Draw a Kernel Density Estimate (KDE) contour plot for a set of nodes on a given axis.
@@ -188,8 +189,6 @@ class Contour:
             color (str or np.ndarray): Color for the contour. Can be a string or RGBA array. Defaults to "white".
             linestyle (str, optional): Line style for the contour. Defaults to "solid".
             linewidth (float, optional): Line width for the contour. Defaults to 1.5.
-            alpha (float, None, optional): Transparency level for the contour lines. If provided, it overrides any existing alpha
-                values found in color. Defaults to 1.0.
             fill_alpha (float, None, optional): Transparency level for the contour fill. If provided, it overrides any existing
                 alpha values found in color. Defaults to 0.2.
         """
@@ -245,6 +244,8 @@ class Contour:
         contour_colors = [color for _ in range(levels - 1)]
         # Plot the filled contours using fill_alpha for transparency
         if fill_alpha and fill_alpha > 0:
+            # Fill alpha works differently than alpha for contour lines
+            # Contour fill cannot be specified by RGBA, while contour lines can
             ax.contourf(
                 x,
                 y,
@@ -255,7 +256,7 @@ class Contour:
                 alpha=fill_alpha,
             )
 
-        # Plot the contour lines with the specified alpha for transparency
+        # Plot the contour lines with the specified RGBA alpha for transparency
         c = ax.contour(
             x,
             y,
@@ -264,7 +265,6 @@ class Contour:
             colors=contour_colors,
             linestyles=linestyle,
             linewidths=linewidth,
-            alpha=alpha,
         )
 
         # Set linewidth for the contour lines to 0 for levels other than the base level

risk/network/plot/labels.py

@@ -191,10 +191,10 @@ class Labels:
             filtered_domain_centroids, center, radius, offset
         )
         # Convert all domain colors to RGBA using the to_rgba helper function
-        fontcolor = to_rgba(
+        fontcolor_rgba = to_rgba(
             color=fontcolor, alpha=fontalpha, num_repeats=len(self.graph.domain_id_to_node_ids_map)
         )
-        arrow_color = to_rgba(
+        arrow_color_rgba = to_rgba(
             color=arrow_color,
             alpha=arrow_alpha,
             num_repeats=len(self.graph.domain_id_to_node_ids_map),
@@ -216,10 +216,10 @@ class Labels:
                 va="center",
                 fontsize=fontsize,
                 fontname=font,
-                color=fontcolor[idx],
+                color=fontcolor_rgba[idx],
                 arrowprops=dict(
                     arrowstyle=arrow_style,
-                    color=arrow_color[idx],
+                    color=arrow_color_rgba[idx],
                     linewidth=arrow_linewidth,
                     shrinkA=arrow_base_shrink,
                     shrinkB=arrow_tip_shrink,
@@ -238,8 +238,7 @@ class Labels:
                     va="center",
                     fontsize=fontsize,
                     fontname=font,
-                    color=fontcolor[idx],
-                    alpha=fontalpha,
+                    color=fontcolor_rgba[idx],
                 )
 
     def plot_sublabel(
@@ -282,7 +281,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

risk/network/plot/network.py

@@ -75,13 +75,13 @@ class Network:
 
         # Convert colors to RGBA using the to_rgba helper function
         # If node_colors was generated using get_annotated_node_colors, its alpha values will override node_alpha
-        node_color = to_rgba(
+        node_color_rgba = to_rgba(
             color=node_color, alpha=node_alpha, num_repeats=len(self.graph.network.nodes)
         )
-        node_edgecolor = to_rgba(
+        node_edgecolor_rgba = to_rgba(
             color=node_edgecolor, alpha=1.0, num_repeats=len(self.graph.network.nodes)
         )
-        edge_color = to_rgba(
+        edge_color_rgba = to_rgba(
             color=edge_color, alpha=edge_alpha, num_repeats=len(self.graph.network.edges)
         )
 
@@ -94,8 +94,8 @@ class Network:
             pos=node_coordinates,
             node_size=node_size,
             node_shape=node_shape,
-            node_color=node_color,
-            edgecolors=node_edgecolor,
+            node_color=node_color_rgba,
+            edgecolors=node_edgecolor_rgba,
             linewidths=node_edgewidth,
             ax=self.ax,
         )
@@ -104,7 +104,7 @@ class Network:
             self.graph.network,
             pos=node_coordinates,
             width=edge_width,
-            edge_color=edge_color,
+            edge_color=edge_color_rgba,
             ax=self.ax,
         )
 
@@ -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
@@ -162,9 +162,9 @@ class Network:
             ]
 
         # Convert colors to RGBA using the to_rgba helper function
-        node_color = to_rgba(color=node_color, alpha=node_alpha, num_repeats=len(node_ids))
-        node_edgecolor = to_rgba(color=node_edgecolor, alpha=1.0, num_repeats=len(node_ids))
-        edge_color = to_rgba(
+        node_color_rgba = to_rgba(color=node_color, alpha=node_alpha, num_repeats=len(node_ids))
+        node_edgecolor_rgba = to_rgba(color=node_edgecolor, alpha=1.0, num_repeats=len(node_ids))
+        edge_color_rgba = to_rgba(
             color=edge_color, alpha=edge_alpha, num_repeats=len(self.graph.network.edges)
         )
 
@@ -178,8 +178,8 @@ class Network:
             nodelist=node_ids,
             node_size=node_size,
             node_shape=node_shape,
-            node_color=node_color,
-            edgecolors=node_edgecolor,
+            node_color=node_color_rgba,
+            edgecolors=node_edgecolor_rgba,
             linewidths=node_edgewidth,
             ax=self.ax,
         )
@@ -189,7 +189,7 @@ class Network:
             subgraph,
             pos=node_coordinates,
             width=edge_width,
-            edge_color=edge_color,
+            edge_color=edge_color_rgba,
             ax=self.ax,
         )
 
@@ -244,7 +244,7 @@ class Network:
         # Apply the alpha value for enriched nodes
         network_colors[:, 3] = alpha  # Apply the alpha value to the enriched nodes' A channel
         # Convert the non-enriched color to RGBA using the to_rgba helper function
-        nonenriched_color = to_rgba(
+        nonenriched_color_rgba = to_rgba(
             color=nonenriched_color, alpha=nonenriched_alpha, num_repeats=1
         )  # num_repeats=1 for a single color
         # Adjust node colors: replace any nodes where all three RGB values are equal and less than 0.1
@@ -255,7 +255,7 @@ class Network:
                 & np.all(network_colors[:, :3] == network_colors[:, 0:1], axis=1)
             )[:, None],
             np.tile(
-                np.array(nonenriched_color), (network_colors.shape[0], 1)
+                np.array(nonenriched_color_rgba), (network_colors.shape[0], 1)
             ),  # Replace with the full RGBA non-enriched color
             network_colors,  # Keep the original colors where no match is found
         )

risk/network/plot/utils/color.py

@@ -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/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]:
@@ -69,9 +69,13 @@ class RISK(NetworkIO, AnnotationsIO):
         Args:
             network (nx.Graph): The network graph.
             annotations (Dict[str, Any]): The 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.
             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.
 
@@ -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]:
@@ -122,9 +126,13 @@ class RISK(NetworkIO, AnnotationsIO):
         Args:
             network (nx.Graph): The network graph.
             annotations (Dict[str, Any]): The 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.
             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.
 
@@ -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,
@@ -178,9 +186,13 @@ class RISK(NetworkIO, AnnotationsIO):
         Args:
             network (nx.Graph): The network graph.
             annotations (Dict[str, Any]): The 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.
             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.
@@ -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.
@@ -452,13 +464,15 @@ class RISK(NetworkIO, AnnotationsIO):
         # Extract necessary data from annotations and neighborhoods
         ordered_annotations = annotations["ordered_annotations"]
         neighborhood_enrichment_sums = neighborhoods["neighborhood_enrichment_counts"]
-        neighborhoods_binary_enrichment_matrix = neighborhoods["binary_enrichment_matrix"]
+        significant_enrichment_matrix = neighborhoods["significant_enrichment_matrix"]
+        significant_binary_enrichment_matrix = neighborhoods["significant_binary_enrichment_matrix"]
         # Call external function to define top annotations
         return define_top_annotations(
             network=network,
             ordered_annotation_labels=ordered_annotations,
             neighborhood_enrichment_sums=neighborhood_enrichment_sums,
-            binary_enrichment_matrix=neighborhoods_binary_enrichment_matrix,
+            significant_enrichment_matrix=significant_enrichment_matrix,
+            significant_binary_enrichment_matrix=significant_binary_enrichment_matrix,
             min_cluster_size=min_cluster_size,
             max_cluster_size=max_cluster_size,
         )

risk/stats/stats.py

@@ -62,7 +62,7 @@ def calculate_significance_matrices(
     log_enrichment_matrix = -np.log10(enrichment_matrix)
 
     # Select the appropriate significance matrices based on the specified tail
-    enrichment_matrix, binary_enrichment_matrix = _select_significance_matrices(
+    enrichment_matrix, significant_binary_enrichment_matrix = _select_significance_matrices(
         tail,
         log_depletion_matrix,
         depletion_alpha_threshold_matrix,
@@ -71,11 +71,13 @@ def calculate_significance_matrices(
     )
 
     # Filter the enrichment matrix using the binary significance matrix
-    significant_enrichment_matrix = np.where(binary_enrichment_matrix == 1, enrichment_matrix, 0)
+    significant_enrichment_matrix = np.where(
+        significant_binary_enrichment_matrix == 1, enrichment_matrix, 0
+    )
 
     return {
         "enrichment_matrix": enrichment_matrix,
-        "binary_enrichment_matrix": binary_enrichment_matrix,
+        "significant_binary_enrichment_matrix": significant_binary_enrichment_matrix,
         "significant_enrichment_matrix": significant_enrichment_matrix,
     }
 
@@ -127,10 +129,10 @@ def _select_significance_matrices(
 
     # Create a binary significance matrix where valid indices meet the alpha threshold
     valid_idxs = ~np.isnan(alpha_threshold_matrix)
-    binary_enrichment_matrix = np.zeros(alpha_threshold_matrix.shape)
-    binary_enrichment_matrix[valid_idxs] = alpha_threshold_matrix[valid_idxs]
+    significant_binary_enrichment_matrix = np.zeros(alpha_threshold_matrix.shape)
+    significant_binary_enrichment_matrix[valid_idxs] = alpha_threshold_matrix[valid_idxs]
 
-    return enrichment_matrix, binary_enrichment_matrix
+    return enrichment_matrix, significant_binary_enrichment_matrix
 
 
 def _compute_threshold_matrix(

{risk_network-0.0.8b20.dist-info → risk_network-0.0.8b22.dist-info}/METADATA

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

{risk_network-0.0.8b20.dist-info → risk_network-0.0.8b22.dist-info}/RECORD

@@ -1,37 +1,37 @@
-risk/__init__.py,sha256=MOWrmv2B-I1GTr0sgWTb-CLgeMWceWa6q2E6oeGC2CA,113
+risk/__init__.py,sha256=fz5ZBsLUlWdBQ5uJS0qBge1qwPNox0OYhi4OXkjQxwI,113
 risk/constants.py,sha256=XInRaH78Slnw_sWgAsBFbUHkyA0h0jL0DKGuQNbOvjM,550
-risk/risk.py,sha256=_ufeTLOAAT4QwrRysvDJOQeE0qMvpp3BSSayfFLhGJE,21720
-risk/annotations/__init__.py,sha256=vUpVvMRE5if01Ic8QY6M2Ae3EFGJHdugEe9PdEkAW4Y,138
-risk/annotations/annotations.py,sha256=KHGeF5vBDmX711nA08DfhxI9z7Z1Oaeo91ueWhM6vs8,11370
+risk/risk.py,sha256=rjV0hllegCX978QaUo175FworKxNXlhQEQaQAPjHqos,23397
+risk/annotations/__init__.py,sha256=kXgadEXaCh0z8OyhOhTj7c3qXGmWgOhaSZ4gSzSb59U,147
+risk/annotations/annotations.py,sha256=giLJht0tPtf4UdtH_d0kbCZQU5H5fZoupGDFKaNbC_Q,12700
 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/neighborhoods/domains.py,sha256=3iV0-nRLF2sL9_7epHY5b9AtTU-QQ84hOWO76VwFcrs,11685
+risk/neighborhoods/neighborhoods.py,sha256=cT9CCi1uQLn9Kv9Lxt8AN_4s63SKIlOZspvUZnx27nE,21832
 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=w_9fUcZUVXAPRKGhLBc7xhIJs8l83szHiBQTdaNN0gk,22942
+risk/network/graph.py,sha256=-tslu8nSbuBaqNGf6TQ8ON7C27v-BLH_37J2aC6Ke14,9602
+risk/network/io.py,sha256=u0PPcKjp6Xze--7eDOlvalYkjQ9S2sjiC-ac2476PUI,22942
 risk/network/plot/__init__.py,sha256=MfmaXJgAZJgXZ2wrhK8pXwzETlcMaLChhWXKAozniAo,98
-risk/network/plot/canvas.py,sha256=hdrmGd2TCuii8wn6jDQfyJTI5YXDNGYFLiU4TyqAYbE,10778
-risk/network/plot/contour.py,sha256=xxTf6iNSlpe2S8aalt2mzivmR0wuGUOh_F3-IL6UbEU,15027
-risk/network/plot/labels.py,sha256=bFsP9NA3Fp0GhX62ArRP9tSqPCgUthKE9aFe0imoPcI,45115
-risk/network/plot/network.py,sha256=nfTmQxx1YwS3taXwq8WSCfu6nfKFOyxj7T5605qLXVM,13615
+risk/network/plot/canvas.py,sha256=ZO6bHw1chIsUqtE7IkPKdgX4tFLA-T5OwN5SojqGSNU,10672
+risk/network/plot/contour.py,sha256=CwX4i3uE5HL0W4kfx34U7YyoTTqMxyb7xaXKRVoNLzY,15265
+risk/network/plot/labels.py,sha256=ozkqwhBOTHKJLaAz4dJopXuykAvssSZUer2W5V0x2jM,45103
+risk/network/plot/network.py,sha256=6RURL1OdBFyQ34qNcwM_uH3LSQGYZZ8tZT51dggH1a0,13685
 risk/network/plot/plotter.py,sha256=iTPMiTnTTatM_-q1Ox_bjt5Pvv-Lo8gceiYB6TVzDcw,5770
-risk/network/plot/utils/color.py,sha256=HtUaGnqJPVNbRyUhQMlBonfHc_2Ci8BtTI3y424p8Cs,19626
+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/stats.py,sha256=6iGi0-oN05mTmupg6X_VEBxEQvi2rujNhfPk4aLjwNI,7186
 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.8b20.dist-info/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
-risk_network-0.0.8b20.dist-info/METADATA,sha256=UnAgNaBf77W4-Vo5YGPJktwy5WQaEwWU2ByhSbyfEVg,47498
-risk_network-0.0.8b20.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
-risk_network-0.0.8b20.dist-info/top_level.txt,sha256=NX7C2PFKTvC1JhVKv14DFlFAIFnKc6Lpsu1ZfxvQwVw,5
-risk_network-0.0.8b20.dist-info/RECORD,,
+risk_network-0.0.8b22.dist-info/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+risk_network-0.0.8b22.dist-info/METADATA,sha256=9trSkrh2Od_B2qltA2n_uVcvX1kUlMy-QmLO4WThrds,47498
+risk_network-0.0.8b22.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
+risk_network-0.0.8b22.dist-info/top_level.txt,sha256=NX7C2PFKTvC1JhVKv14DFlFAIFnKc6Lpsu1ZfxvQwVw,5
+risk_network-0.0.8b22.dist-info/RECORD,,