risk-network 0.0.12b1__py3-none-any.whl → 0.0.12b3__py3-none-any.whl

risk/neighborhoods/stats/tests.py

@@ -12,15 +12,15 @@ from scipy.stats import binom, chi2, hypergeom, norm, poisson
 
 def compute_binom_test(
     neighborhoods: csr_matrix,
-    annotations: csr_matrix,
+    annotation: csr_matrix,
     null_distribution: str = "network",
 ) -> Dict[str, Any]:
     """Compute Binomial test for enrichment and depletion in neighborhoods with selectable null distribution.
 
     Args:
         neighborhoods (csr_matrix): Sparse binary matrix representing neighborhoods.
-        annotations (csr_matrix): Sparse binary matrix representing annotations.
-        null_distribution (str, optional): Type of null distribution ('network' or 'annotations'). Defaults to "network".
+        annotation (csr_matrix): Sparse binary matrix representing annotation.
+        null_distribution (str, optional): Type of null distribution ('network' or 'annotation'). Defaults to "network".
 
     Returns:
         Dict[str, Any]: Dictionary containing depletion and enrichment p-values.
@@ -33,19 +33,19 @@ def compute_binom_test(
 
     # Compute sums (remain sparse here)
     neighborhood_sizes = neighborhoods.sum(axis=1)  # Row sums
-    annotation_totals = annotations.sum(axis=0)  # Column sums
+    annotation_totals = annotation.sum(axis=0)  # Column sums
     # Compute probabilities (convert to dense)
     if null_distribution == "network":
         p_values = (annotation_totals / total_nodes).A.flatten()  # Dense 1D array
-    elif null_distribution == "annotations":
-        p_values = (annotation_totals / annotations.sum()).A.flatten()  # Dense 1D array
+    elif null_distribution == "annotation":
+        p_values = (annotation_totals / annotation.sum()).A.flatten()  # Dense 1D array
     else:
         raise ValueError(
-            "Invalid null_distribution value. Choose either 'network' or 'annotations'."
+            "Invalid null_distribution value. Choose either 'network' or 'annotation'."
         )
 
     # Observed counts (sparse matrix multiplication)
-    annotated_counts = neighborhoods @ annotations  # Sparse result
+    annotated_counts = neighborhoods @ annotation  # Sparse result
     annotated_counts_dense = annotated_counts.toarray()  # Convert for dense operations
 
     # Compute enrichment and depletion p-values
@@ -57,15 +57,15 @@ def compute_binom_test(
 
 def compute_chi2_test(
     neighborhoods: csr_matrix,
-    annotations: csr_matrix,
+    annotation: csr_matrix,
     null_distribution: str = "network",
 ) -> Dict[str, Any]:
     """Compute chi-squared test for enrichment and depletion in neighborhoods with selectable null distribution.
 
     Args:
         neighborhoods (csr_matrix): Sparse binary matrix representing neighborhoods.
-        annotations (csr_matrix): Sparse binary matrix representing annotations.
-        null_distribution (str, optional): Type of null distribution ('network' or 'annotations'). Defaults to "network".
+        annotation (csr_matrix): Sparse binary matrix representing annotation.
+        null_distribution (str, optional): Type of null distribution ('network' or 'annotation'). Defaults to "network".
 
     Returns:
         Dict[str, Any]: Dictionary containing depletion and enrichment p-values.
@@ -80,22 +80,22 @@ def compute_chi2_test(
         # Case 1: Use all nodes as the background
         background_population = total_node_count
         neighborhood_sums = neighborhoods.sum(axis=0)  # Column sums of neighborhoods
-        annotation_sums = annotations.sum(axis=0)  # Column sums of annotations
-    elif null_distribution == "annotations":
+        annotation_sums = annotation.sum(axis=0)  # Column sums of annotations
+    elif null_distribution == "annotation":
         # Case 2: Only consider nodes with at least one annotation
         annotated_nodes = (
-            np.ravel(annotations.sum(axis=1)) > 0
+            np.ravel(annotation.sum(axis=1)) > 0
         )  # Row-wise sum to filter nodes with annotations
         background_population = annotated_nodes.sum()  # Total number of annotated nodes
         neighborhood_sums = neighborhoods[annotated_nodes].sum(
             axis=0
         )  # Neighborhood sums for annotated nodes
-        annotation_sums = annotations[annotated_nodes].sum(
+        annotation_sums = annotation[annotated_nodes].sum(
             axis=0
         )  # Annotation sums for annotated nodes
     else:
         raise ValueError(
-            "Invalid null_distribution value. Choose either 'network' or 'annotations'."
+            "Invalid null_distribution value. Choose either 'network' or 'annotation'."
         )
 
     # Convert to dense arrays for downstream computations
@@ -103,7 +103,7 @@ def compute_chi2_test(
     annotation_sums = np.asarray(annotation_sums).reshape(1, -1)  # Ensure row vector shape
 
     # Observed values: number of annotated nodes in each neighborhood
-    observed = neighborhoods.T @ annotations  # Shape: (neighborhoods, annotations)
+    observed = neighborhoods.T @ annotation  # Shape: (neighborhoods, annotation)
     # Expected values under the null
     expected = (neighborhood_sums @ annotation_sums) / background_population
     # Chi-squared statistic: sum((observed - expected)^2 / expected)
@@ -119,15 +119,15 @@ def compute_chi2_test(
 
 def compute_hypergeom_test(
     neighborhoods: csr_matrix,
-    annotations: csr_matrix,
+    annotation: csr_matrix,
     null_distribution: str = "network",
 ) -> Dict[str, Any]:
     """Compute hypergeometric test for enrichment and depletion in neighborhoods with selectable null distribution.
 
     Args:
         neighborhoods (csr_matrix): Sparse binary matrix representing neighborhoods.
-        annotations (csr_matrix): Sparse binary matrix representing annotations.
-        null_distribution (str, optional): Type of null distribution ('network' or 'annotations'). Defaults to "network".
+        annotation (csr_matrix): Sparse binary matrix representing annotation.
+        null_distribution (str, optional): Type of null distribution ('network' or 'annotation'). Defaults to "network".
 
     Returns:
         Dict[str, Any]: Dictionary containing depletion and enrichment p-values.
@@ -140,22 +140,22 @@ def compute_hypergeom_test(
 
     # Compute sums
     neighborhood_sums = neighborhoods.sum(axis=0).A.flatten()  # Convert to dense array
-    annotation_sums = annotations.sum(axis=0).A.flatten()  # Convert to dense array
+    annotation_sums = annotation.sum(axis=0).A.flatten()  # Convert to dense array
 
     if null_distribution == "network":
         background_population = total_nodes
-    elif null_distribution == "annotations":
-        annotated_nodes = annotations.sum(axis=1).A.flatten() > 0  # Boolean mask
+    elif null_distribution == "annotation":
+        annotated_nodes = annotation.sum(axis=1).A.flatten() > 0  # Boolean mask
         background_population = annotated_nodes.sum()
         neighborhood_sums = neighborhoods[annotated_nodes].sum(axis=0).A.flatten()
-        annotation_sums = annotations[annotated_nodes].sum(axis=0).A.flatten()
+        annotation_sums = annotation[annotated_nodes].sum(axis=0).A.flatten()
     else:
         raise ValueError(
-            "Invalid null_distribution value. Choose either 'network' or 'annotations'."
+            "Invalid null_distribution value. Choose either 'network' or 'annotation'."
         )
 
     # Observed counts
-    annotated_in_neighborhood = neighborhoods.T @ annotations  # Sparse result
+    annotated_in_neighborhood = neighborhoods.T @ annotation  # Sparse result
     annotated_in_neighborhood = annotated_in_neighborhood.toarray()  # Convert to dense
     # Align shapes for broadcasting
     neighborhood_sums = neighborhood_sums.reshape(-1, 1)
@@ -175,15 +175,15 @@ def compute_hypergeom_test(
 
 def compute_poisson_test(
     neighborhoods: csr_matrix,
-    annotations: csr_matrix,
+    annotation: csr_matrix,
     null_distribution: str = "network",
 ) -> Dict[str, Any]:
     """Compute Poisson test for enrichment and depletion in neighborhoods with selectable null distribution.
 
     Args:
         neighborhoods (csr_matrix): Sparse binary matrix representing neighborhoods.
-        annotations (csr_matrix): Sparse binary matrix representing annotations.
-        null_distribution (str, optional): Type of null distribution ('network' or 'annotations'). Defaults to "network".
+        annotation (csr_matrix): Sparse binary matrix representing annotation.
+        null_distribution (str, optional): Type of null distribution ('network' or 'annotation'). Defaults to "network".
 
     Returns:
         Dict[str, Any]: Dictionary containing depletion and enrichment p-values.
@@ -192,7 +192,7 @@ def compute_poisson_test(
         ValueError: If an invalid null_distribution value is provided.
     """
     # Matrix multiplication to get the number of annotated nodes in each neighborhood
-    annotated_in_neighborhood = neighborhoods @ annotations  # Sparse result
+    annotated_in_neighborhood = neighborhoods @ annotation  # Sparse result
     # Convert annotated counts to dense for downstream calculations
     annotated_in_neighborhood_dense = annotated_in_neighborhood.toarray()
 
@@ -200,12 +200,12 @@ def compute_poisson_test(
     if null_distribution == "network":
         # Use the mean across neighborhoods (axis=1)
         lambda_expected = np.mean(annotated_in_neighborhood_dense, axis=1, keepdims=True)
-    elif null_distribution == "annotations":
+    elif null_distribution == "annotation":
         # Use the mean across annotations (axis=0)
         lambda_expected = np.mean(annotated_in_neighborhood_dense, axis=0, keepdims=True)
     else:
         raise ValueError(
-            "Invalid null_distribution value. Choose either 'network' or 'annotations'."
+            "Invalid null_distribution value. Choose either 'network' or 'annotation'."
         )
 
     # Compute p-values for enrichment and depletion using Poisson distribution
@@ -217,15 +217,15 @@ def compute_poisson_test(
 
 def compute_zscore_test(
     neighborhoods: csr_matrix,
-    annotations: csr_matrix,
+    annotation: csr_matrix,
     null_distribution: str = "network",
 ) -> Dict[str, Any]:
     """Compute z-score test for enrichment and depletion in neighborhoods with selectable null distribution.
 
     Args:
         neighborhoods (csr_matrix): Sparse binary matrix representing neighborhoods.
-        annotations (csr_matrix): Sparse binary matrix representing annotations.
-        null_distribution (str, optional): Type of null distribution ('network' or 'annotations'). Defaults to "network".
+        annotation (csr_matrix): Sparse binary matrix representing annotation.
+        null_distribution (str, optional): Type of null distribution ('network' or 'annotation'). Defaults to "network".
 
     Returns:
         Dict[str, Any]: Dictionary containing depletion and enrichment p-values.
@@ -240,19 +240,19 @@ def compute_zscore_test(
     if null_distribution == "network":
         background_population = total_node_count
         neighborhood_sums = neighborhoods.sum(axis=0).A.flatten()  # Dense column sums
-        annotation_sums = annotations.sum(axis=0).A.flatten()  # Dense row sums
-    elif null_distribution == "annotations":
-        annotated_nodes = annotations.sum(axis=1).A.flatten() > 0  # Dense boolean mask
+        annotation_sums = annotation.sum(axis=0).A.flatten()  # Dense row sums
+    elif null_distribution == "annotation":
+        annotated_nodes = annotation.sum(axis=1).A.flatten() > 0  # Dense boolean mask
         background_population = annotated_nodes.sum()
         neighborhood_sums = neighborhoods[annotated_nodes].sum(axis=0).A.flatten()
-        annotation_sums = annotations[annotated_nodes].sum(axis=0).A.flatten()
+        annotation_sums = annotation[annotated_nodes].sum(axis=0).A.flatten()
     else:
         raise ValueError(
-            "Invalid null_distribution value. Choose either 'network' or 'annotations'."
+            "Invalid null_distribution value. Choose either 'network' or 'annotation'."
         )
 
     # Observed values
-    observed = (neighborhoods.T @ annotations).toarray()  # Convert sparse result to dense
+    observed = (neighborhoods.T @ annotation).toarray()  # Convert sparse result to dense
     # Expected values under the null
     neighborhood_sums = neighborhood_sums.reshape(-1, 1)  # Ensure correct shape
     annotation_sums = annotation_sums.reshape(1, -1)  # Ensure correct shape

risk/network/graph/api.py

@@ -9,7 +9,7 @@ from typing import Any, Dict, Union
 import networkx as nx
 import pandas as pd
 
-from risk.annotations import define_top_annotations
+from risk.annotation import define_top_annotation
 from risk.log import log_header, logger, params
 from risk.neighborhoods import (
     define_domains,
@@ -26,13 +26,13 @@ class GraphAPI:
     The GraphAPI class provides methods to load and process network graphs, annotations, and neighborhoods.
     """
 
-    def __init__() -> None:
+    def __init__(self) -> None:
         pass
 
     def load_graph(
         self,
         network: nx.Graph,
-        annotations: Dict[str, Any],
+        annotation: Dict[str, Any],
         neighborhoods: Dict[str, Any],
         tail: str = "right",
         pval_cutoff: float = 0.01,
@@ -50,7 +50,7 @@ class GraphAPI:
 
         Args:
             network (nx.Graph): The network graph.
-            annotations (Dict[str, Any]): The annotations associated with the network.
+            annotation (Dict[str, Any]): The annotation associated with the network.
             neighborhoods (Dict[str, Any]): Neighborhood significance 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.
@@ -115,9 +115,9 @@ class GraphAPI:
         logger.debug(f"Min cluster size: {min_cluster_size}")
         logger.debug(f"Max cluster size: {max_cluster_size}")
         # Define top annotations based on processed neighborhoods
-        top_annotations = self._define_top_annotations(
+        top_annotation = self._define_top_annotation(
             network=network,
-            annotations=annotations,
+            annotation=annotation,
             neighborhoods=processed_neighborhoods,
             min_cluster_size=min_cluster_size,
             max_cluster_size=max_cluster_size,
@@ -130,7 +130,7 @@ class GraphAPI:
         ]
         # Define domains in the network using the specified clustering settings
         domains = define_domains(
-            top_annotations=top_annotations,
+            top_annotation=top_annotation,
             significant_neighborhoods_significance=significant_neighborhoods_significance,
             linkage_criterion=linkage_criterion,
             linkage_method=linkage_method,
@@ -140,20 +140,20 @@ class GraphAPI:
         # Trim domains and top annotations based on cluster size constraints
         domains, trimmed_domains = trim_domains(
             domains=domains,
-            top_annotations=top_annotations,
+            top_annotation=top_annotation,
             min_cluster_size=min_cluster_size,
             max_cluster_size=max_cluster_size,
         )
 
         # Prepare node mapping and significance sums for the final Graph object
-        ordered_nodes = annotations["ordered_nodes"]
+        ordered_nodes = annotation["ordered_nodes"]
         node_label_to_id = dict(zip(ordered_nodes, range(len(ordered_nodes))))
         node_significance_sums = processed_neighborhoods["node_significance_sums"]
 
         # Return the fully initialized Graph object
         return Graph(
             network=network,
-            annotations=annotations,
+            annotation=annotation,
             neighborhoods=neighborhoods,
             domains=domains,
             trimmed_domains=trimmed_domains,
@@ -161,10 +161,10 @@ class GraphAPI:
             node_significance_sums=node_significance_sums,
         )
 
-    def _define_top_annotations(
+    def _define_top_annotation(
         self,
         network: nx.Graph,
-        annotations: Dict[str, Any],
+        annotation: Dict[str, Any],
         neighborhoods: Dict[str, Any],
         min_cluster_size: int = 5,
         max_cluster_size: int = 1000,
@@ -173,7 +173,7 @@ class GraphAPI:
 
         Args:
             network (nx.Graph): The network graph.
-            annotations (Dict[str, Any]): Annotations data for the network.
+            annotation (Dict[str, Any]): Annotation data for the network.
             neighborhoods (Dict[str, Any]): Neighborhood significance 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.
@@ -181,17 +181,17 @@ class GraphAPI:
         Returns:
             Dict[str, Any]: Top annotations identified within the network.
         """
-        # Extract necessary data from annotations and neighborhoods
-        ordered_annotations = annotations["ordered_annotations"]
+        # Extract necessary data from annotation and neighborhoods
+        ordered_annotation = annotation["ordered_annotation"]
         neighborhood_significance_sums = neighborhoods["neighborhood_significance_counts"]
         significant_significance_matrix = neighborhoods["significant_significance_matrix"]
         significant_binary_significance_matrix = neighborhoods[
             "significant_binary_significance_matrix"
         ]
         # Call external function to define top annotations
-        return define_top_annotations(
+        return define_top_annotation(
             network=network,
-            ordered_annotation_labels=ordered_annotations,
+            ordered_annotation_labels=ordered_annotation,
             neighborhood_significance_sums=neighborhood_significance_sums,
             significant_significance_matrix=significant_significance_matrix,
             significant_binary_significance_matrix=significant_binary_significance_matrix,

risk/network/graph/graph.py

@@ -17,7 +17,7 @@ class Graph:
     """A class to represent a network graph and process its nodes and edges.
 
     The Graph class provides functionality to handle and manipulate a network graph,
-    including managing domains, annotations, and node significance data. It also includes methods
+    including managing domains, annotation, and node significance data. It also includes methods
     for transforming and mapping graph coordinates, as well as generating colors based on node
     significance.
     """
@@ -25,7 +25,7 @@ class Graph:
     def __init__(
         self,
         network: nx.Graph,
-        annotations: Dict[str, Any],
+        annotation: Dict[str, Any],
         neighborhoods: Dict[str, Any],
         domains: pd.DataFrame,
         trimmed_domains: pd.DataFrame,
@@ -36,7 +36,7 @@ class Graph:
 
         Args:
             network (nx.Graph): The network graph.
-            annotations (Dict[str, Any]): The annotations associated with the network.
+            annotation (Dict[str, Any]): The annotation associated with the network.
             neighborhoods (Dict[str, Any]): Neighborhood significance data.
             domains (pd.DataFrame): DataFrame containing domain data for the network nodes.
             trimmed_domains (pd.DataFrame): DataFrame containing trimmed domain data for the network nodes.
@@ -69,16 +69,20 @@ class Graph:
         self.node_coordinates = self._extract_node_coordinates(self.network)
 
         # NOTE: Only after the above attributes are initialized, we can create the summary
-        self.summary = Summary(annotations, neighborhoods, self)
+        self.summary = Summary(annotation, neighborhoods, self)
 
-    def pop(self, domain_id: str) -> None:
-        """Remove domain ID from instance domain ID mappings. This can be useful for cleaning up
-        domain-specific mappings based on a given criterion, as domain attributes are stored and
-        accessed only in dictionaries modified by this method.
+    def pop(self, domain_id: int) -> List[str]:
+        """Remove a domain ID from the graph and return the corresponding node labels.
 
         Args:
-            key (str): The domain ID key to be removed from each mapping.
+            key (int): The domain ID key to be removed from each mapping.
+
+        Returns:
+            List[str]: A list of node labels associated with the domain ID.
         """
+        # Get the node labels associated with the domain ID
+        node_labels = self.domain_id_to_node_labels_map.get(domain_id, [])
+
         # Define the domain mappings to be updated
         domain_mappings = [
             self.domain_id_to_node_ids_map,
@@ -97,6 +101,8 @@ class Graph:
                 domain_info["domains"].remove(domain_id)
                 domain_info["significances"].pop(domain_id)
 
+        return node_labels
+
     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.
 
@@ -163,8 +169,8 @@ class Graph:
             sorted_descriptions, sorted_scores = zip(*descriptions_and_scores)
             # Assign to the domain info map
             domain_info_map[int(domain_id)] = {
-                "full_descriptions": list(sorted_descriptions),
-                "significance_scores": list(sorted_scores),
+                "full_descriptions": sorted_descriptions,
+                "significance_scores": sorted_scores,
             }
 
         return domain_info_map

risk/network/graph/summary.py

@@ -23,18 +23,18 @@ class Summary:
 
     def __init__(
         self,
-        annotations: Dict[str, Any],
+        annotation: Dict[str, Any],
         neighborhoods: Dict[str, Any],
         graph,  # Avoid type hinting Graph to prevent circular imports
     ):
         """Initialize the Results object with analysis components.
 
         Args:
-            annotations (Dict[str, Any]): Annotation data, including ordered annotations and matrix of associations.
+            annotation (Dict[str, Any]): Annotation data, including ordered annotations and matrix of associations.
             neighborhoods (Dict[str, Any]): Neighborhood data containing p-values for significance and depletion analysis.
             graph (Graph): Graph object representing domain-to-node and node-to-label mappings.
         """
-        self.annotations = annotations
+        self.annotation = annotation
         self.neighborhoods = neighborhoods
         self.graph = graph
 
@@ -81,7 +81,7 @@ class Summary:
                 and annotation member information.
         """
         log_header("Loading analysis summary")
-        # Calculate significance and depletion q-values from p-value matrices in `annotations`
+        # Calculate significance and depletion q-values from p-value matrices in annotation
         enrichment_pvals = self.neighborhoods["enrichment_pvals"]
         depletion_pvals = self.neighborhoods["depletion_pvals"]
         enrichment_qvals = self._calculate_qvalues(enrichment_pvals)
@@ -147,10 +147,10 @@ class Summary:
             .reset_index(drop=True)
         )
 
-        # Convert annotations list to a DataFrame for comparison then merge with results
-        ordered_annotations = pd.DataFrame({"Annotation": self.annotations["ordered_annotations"]})
+        # Convert annotation list to a DataFrame for comparison then merge with results
+        ordered_annotation = pd.DataFrame({"Annotation": self.annotation["ordered_annotation"]})
         # Merge to ensure all annotations are present, filling missing rows with defaults
-        results = pd.merge(ordered_annotations, results, on="Annotation", how="left").fillna(
+        results = pd.merge(ordered_annotation, results, on="Annotation", how="left").fillna(
             {
                 "Domain ID": -1,
                 "Annotation Members in Network": "",
@@ -205,7 +205,7 @@ class Summary:
                 Minimum significance p-value, significance q-value, depletion p-value, depletion q-value.
         """
         try:
-            annotation_idx = self.annotations["ordered_annotations"].index(description)
+            annotation_idx = self.annotation["ordered_annotation"].index(description)
         except ValueError:
             return None, None, None, None  # Description not found
 
@@ -235,12 +235,12 @@ class Summary:
             str: ';'-separated string of node labels that are associated with the annotation.
         """
         try:
-            annotation_idx = self.annotations["ordered_annotations"].index(description)
+            annotation_idx = self.annotation["ordered_annotation"].index(description)
         except ValueError:
             return ""  # Description not found
 
         # Get the column (safely) from the sparse matrix
-        column = self.annotations["matrix"][:, annotation_idx]
+        column = self.annotation["matrix"][:, annotation_idx]
         # Convert the column to a dense array if needed
         column = column.toarray().ravel()  # Convert to a 1D dense array
         # Get nodes present for the annotation and sort by node label - use np.where on the dense array

risk/network/io.py

@@ -48,7 +48,7 @@ class NetworkIO:
             min_edges_per_node=min_edges_per_node,
         )
 
-    def load_gpickle_network(
+    def load_network_gpickle(
         self,
         filepath: str,
         compute_sphere: bool = True,
@@ -71,9 +71,9 @@ class NetworkIO:
             surface_depth=surface_depth,
             min_edges_per_node=min_edges_per_node,
         )
-        return networkio._load_gpickle_network(filepath=filepath)
+        return networkio._load_network_gpickle(filepath=filepath)
 
-    def _load_gpickle_network(self, filepath: str) -> nx.Graph:
+    def _load_network_gpickle(self, filepath: str) -> nx.Graph:
         """Private method to load a network from a GPickle file.
 
         Args:
@@ -93,7 +93,7 @@ class NetworkIO:
         # Initialize the graph
         return self._initialize_graph(G)
 
-    def load_networkx_network(
+    def load_network_networkx(
         self,
         network: nx.Graph,
         compute_sphere: bool = True,
@@ -116,9 +116,9 @@ class NetworkIO:
             surface_depth=surface_depth,
             min_edges_per_node=min_edges_per_node,
         )
-        return networkio._load_networkx_network(network=network)
+        return networkio._load_network_networkx(network=network)
 
-    def _load_networkx_network(self, network: nx.Graph) -> nx.Graph:
+    def _load_network_networkx(self, network: nx.Graph) -> nx.Graph:
         """Private method to load a NetworkX graph.
 
         Args:
@@ -137,7 +137,7 @@ class NetworkIO:
         # Initialize the graph
         return self._initialize_graph(network_copy)
 
-    def load_cytoscape_network(
+    def load_network_cytoscape(
         self,
         filepath: str,
         source_label: str = "source",
@@ -166,14 +166,14 @@ class NetworkIO:
             surface_depth=surface_depth,
             min_edges_per_node=min_edges_per_node,
         )
-        return networkio._load_cytoscape_network(
+        return networkio._load_network_cytoscape(
             filepath=filepath,
             source_label=source_label,
             target_label=target_label,
             view_name=view_name,
         )
 
-    def _load_cytoscape_network(
+    def _load_network_cytoscape(
         self,
         filepath: str,
         source_label: str = "source",
@@ -307,7 +307,7 @@ class NetworkIO:
             if os.path.exists(tmp_dir):
                 shutil.rmtree(tmp_dir)
 
-    def load_cytoscape_json_network(
+    def load_network_cyjs(
         self,
         filepath: str,
         source_label: str = "source",
@@ -334,13 +334,13 @@ class NetworkIO:
             surface_depth=surface_depth,
             min_edges_per_node=min_edges_per_node,
         )
-        return networkio._load_cytoscape_json_network(
+        return networkio._load_network_cyjs(
             filepath=filepath,
             source_label=source_label,
             target_label=target_label,
         )
 
-    def _load_cytoscape_json_network(self, filepath, source_label="source", target_label="target"):
+    def _load_network_cyjs(self, filepath, source_label="source", target_label="target"):
         """Private method to load a network from a Cytoscape JSON (.cyjs) file.
 
         Args:

risk/network/plotter/canvas.py

@@ -76,7 +76,7 @@ class Canvas:
         fig = self.ax.figure
         # Use a tight layout to ensure that title and subtitle do not overlap with the original plot
         fig.tight_layout(
-            rect=[0, 0, 1, 1 - title_space_offset]
+            rect=(0, 0, 1, 1 - title_space_offset)
         )  # Leave space above the plot for title
 
         # Plot title if provided

risk/network/plotter/contour.py

@@ -282,8 +282,8 @@ class Contour:
         scale_factor: float = 1.0,
         ids_to_colors: Union[Dict[int, Any], None] = None,
         random_seed: int = 888,
-    ) -> np.ndarray:
-        """Get colors for the contours based on node annotations or a specified colormap.
+    ) -> List[Tuple]:
+        """Get colors for the contours based on node annotation or a specified colormap.
 
         Args:
             cmap (str, optional): Name of the colormap to use for generating contour colors. Defaults to "gist_rainbow".
@@ -301,7 +301,7 @@ class Contour:
             random_seed (int, optional): Seed for random number generation to ensure reproducibility. Defaults to 888.
 
         Returns:
-            np.ndarray: Array of RGBA colors for contour annotations.
+            List[Tuple]: List of RGBA colors for the contours, one for each domain in the network graph.
         """
         return get_annotated_domain_colors(
             graph=self.graph,