risk-network 0.0.13b5__py3-none-any.whl → 0.0.14__py3-none-any.whl

risk/__init__.py

@@ -5,7 +5,7 @@ risk
 RISK: Regional Inference of Significant Kinships
 """
 
-from .risk import RISK
+from ._risk import RISK
 
 __all__ = ["RISK"]
-__version__ = "0.0.13-beta.5"
+__version__ = "0.0.14"

risk/_annotation/__init__.py

@@ -7,4 +7,4 @@ from ._annotation import (
     define_top_annotation,
     get_weighted_description,
 )
-from ._io import AnnotationIO
+from ._io import AnnotationHandler

risk/_annotation/_io.py

@@ -13,11 +13,11 @@ from .._log import log_header, logger, params
 from ._annotation import load_annotation
 
 
-class AnnotationIO:
+class AnnotationHandler:
     """
     Handles the loading and exporting of annotation in various file formats.
 
-    The AnnotationIO class provides methods to load annotation from different file types (JSON, CSV, Excel, etc.)
+    The AnnotationHandler class provides methods to load annotation from different file types (JSON, CSV, Excel, etc.)
     and to export parameter data to various formats like JSON, CSV, and text files.
     """
 

risk/_neighborhoods/_api.py

@@ -29,9 +29,6 @@ class NeighborhoodsAPI:
     The NeighborhoodsAPI class provides methods to load neighborhood results from statistical tests.
     """
 
-    def __init__(self) -> None:
-        pass
-
     def load_neighborhoods_binom(
         self,
         network: nx.Graph,

risk/_neighborhoods/_domains.py

@@ -54,37 +54,48 @@ def define_domains(
     Raises:
         ValueError: If the clustering criterion is set to "off" or if an error occurs during clustering.
     """
-    try:
-        if linkage_criterion == "off":
-            raise ValueError("Clustering is turned off.")
+    # Validate args first; let user mistakes raise immediately
+    clustering_off = _validate_clustering_args(
+        linkage_criterion, linkage_method, linkage_metric, linkage_threshold
+    )
 
+    # If clustering is turned off, assign unique domains and skip
+    if clustering_off:
+        n_rows = len(top_annotation)
+        logger.warning("Clustering is turned off. Skipping clustering.")
+        top_annotation["domain"] = range(1, n_rows + 1)
+    else:
         # Transpose the matrix to cluster annotations
         m = significant_neighborhoods_significance[:, top_annotation["significant_annotation"]].T
         # Safeguard the matrix by replacing NaN, Inf, and -Inf values
         m = _safeguard_matrix(m)
-        # Optimize silhouette score across different linkage methods and distance metrics
-        best_linkage, best_metric, best_threshold = _optimize_silhouette_across_linkage_and_metrics(
-            m, linkage_criterion, linkage_method, linkage_metric, linkage_threshold
-        )
-        # Perform hierarchical clustering
-        Z = linkage(m, method=best_linkage, metric=best_metric)
-        logger.warning(
-            f"Linkage criterion: '{linkage_criterion}'\nLinkage method: '{best_linkage}'\nLinkage metric: '{best_metric}'\nLinkage threshold: {round(best_threshold, 3)}"
-        )
-        # Calculate the optimal threshold for clustering
-        max_d_optimal = np.max(Z[:, 2]) * best_threshold
-        # Assign domains to the annotation matrix
-        domains = fcluster(Z, max_d_optimal, criterion=linkage_criterion)
-        top_annotation["domain"] = 0
-        top_annotation.loc[top_annotation["significant_annotation"], "domain"] = domains
-    except (ValueError, LinAlgError):
-        # If a ValueError is encountered, handle it by assigning unique domains
-        n_rows = len(top_annotation)
-        if linkage_criterion == "off":
-            logger.warning("Clustering is turned off. Skipping clustering.")
-        else:
-            logger.error("Error encountered. Skipping clustering.")
-        top_annotation["domain"] = range(1, n_rows + 1)  # Assign unique domains
+        try:
+            # Optimize silhouette score across different linkage methods and distance metrics
+            (
+                best_linkage,
+                best_metric,
+                best_threshold,
+            ) = _optimize_silhouette_across_linkage_and_metrics(
+                m, linkage_criterion, linkage_method, linkage_metric, linkage_threshold
+            )
+            # Perform hierarchical clustering
+            Z = linkage(m, method=best_linkage, metric=best_metric)
+            logger.warning(
+                f"Linkage criterion: '{linkage_criterion}'\nLinkage method: '{best_linkage}'\nLinkage metric: '{best_metric}'\nLinkage threshold: {round(best_threshold, 3)}"
+            )
+            # Calculate the optimal threshold for clustering
+            max_d_optimal = np.max(Z[:, 2]) * best_threshold
+            # Assign domains to the annotation matrix
+            domains = fcluster(Z, max_d_optimal, criterion=linkage_criterion)
+            top_annotation["domain"] = 0
+            top_annotation.loc[top_annotation["significant_annotation"], "domain"] = domains
+        except (LinAlgError, ValueError):
+            # Numerical errors or degenerate input are handled gracefully (not user error)
+            n_rows = len(top_annotation)
+            logger.error(
+                "Clustering failed due to numerical or data degeneracy. Assigning unique domains."
+            )
+            top_annotation["domain"] = range(1, n_rows + 1)
 
     # Create DataFrames to store domain information
     node_to_significance = pd.DataFrame(
@@ -184,6 +195,46 @@ def trim_domains(
     return valid_domains, valid_trimmed_domains_matrix
 
 
+def _validate_clustering_args(
+    linkage_criterion: str,
+    linkage_method: str,
+    linkage_metric: str,
+    linkage_threshold: Union[float, str],
+) -> bool:
+    """
+    Validate user-provided clustering arguments.
+
+    Returns:
+        bool: True if clustering is turned off (criterion == 'off'); False otherwise.
+
+    Raises:
+        ValueError: If any argument is invalid (user error).
+    """
+    # Allow opting out of clustering without raising
+    if linkage_criterion == "off":
+        return True
+    # Validate linkage method (allow "auto")
+    if linkage_method != "auto" and linkage_method not in LINKAGE_METHODS:
+        raise ValueError(
+            f"Invalid linkage_method '{linkage_method}'. Allowed values are 'auto' or one of: {sorted(LINKAGE_METHODS)}"
+        )
+    # Validate linkage metric (allow "auto")
+    if linkage_metric != "auto" and linkage_metric not in LINKAGE_METRICS:
+        raise ValueError(
+            f"Invalid linkage_metric '{linkage_metric}'. Allowed values are 'auto' or one of: {sorted(LINKAGE_METRICS)}"
+        )
+    # Validate linkage threshold (allow "auto"; otherwise must be float in (0, 1])
+    if linkage_threshold != "auto":
+        try:
+            lt = float(linkage_threshold)
+        except (TypeError, ValueError):
+            raise ValueError("linkage_threshold must be 'auto' or a float in the interval (0, 1].")
+        if not (0.0 < lt <= 1.0):
+            raise ValueError(f"linkage_threshold must be within (0, 1]. Received: {lt}")
+
+    return False
+
+
 def _safeguard_matrix(matrix: np.ndarray) -> np.ndarray:
     """
     Safeguard the matrix by replacing NaN, Inf, and -Inf values.

risk/_neighborhoods/_neighborhoods.py

@@ -394,34 +394,33 @@ def _prune_neighbors(
     # Identify indices with non-zero rows in the binary significance matrix
     non_zero_indices = np.where(significant_binary_significance_matrix.sum(axis=1) != 0)[0]
     median_distances = []
+    distance_lookup = {}
     for node in non_zero_indices:
-        neighbors = [
-            n
-            for n in network.neighbors(node)
-            if significant_binary_significance_matrix[n].sum() != 0
-        ]
-        if neighbors:
-            median_distance = np.median(
-                [_get_euclidean_distance(node, n, network) for n in neighbors]
-            )
-            median_distances.append(median_distance)
+        dist = _median_distance_to_significant_neighbors(
+            node, network, significant_binary_significance_matrix
+        )
+        if dist is not None:
+            median_distances.append(dist)
+            distance_lookup[node] = dist
+
+    if not median_distances:
+        logger.warning("No significant neighbors found for pruning.")
+        significant_significance_matrix = np.where(
+            significant_binary_significance_matrix == 1, significance_matrix, 0
+        )
+        return (
+            significance_matrix,
+            significant_binary_significance_matrix,
+            significant_significance_matrix,
+        )
 
     # Calculate the distance threshold value based on rank
     distance_threshold_value = _calculate_threshold(median_distances, 1 - distance_threshold)
     # 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 significant_binary_significance_matrix[n].sum() != 0
-        ]
-        if neighbors:
-            median_distance = np.median(
-                [_get_euclidean_distance(row_index, n, network) for n in neighbors]
-            )
-            if median_distance >= distance_threshold_value:
-                significance_matrix[row_index] = 0
-                significant_binary_significance_matrix[row_index] = 0
+    for node, dist in distance_lookup.items():
+        if dist >= distance_threshold_value:
+            significance_matrix[node] = 0
+            significant_binary_significance_matrix[node] = 0
 
     # Create a matrix where non-significant entries are set to zero
     significant_significance_matrix = np.where(
@@ -435,6 +434,29 @@ def _prune_neighbors(
     )
 
 
+def _median_distance_to_significant_neighbors(
+    node, network, significance_mask
+) -> Union[float, None]:
+    """
+    Calculate the median distance from a node to its significant neighbors.
+
+    Args:
+        node (Any): The node for which the median distance is being calculated.
+        network (nx.Graph): The network graph containing the nodes.
+        significance_mask (np.ndarray): Binary matrix indicating significant nodes.
+
+    Returns:
+        Union[float, None]: The median distance to significant neighbors, or None if no significant neighbors exist.
+    """
+    neighbors = [n for n in network.neighbors(node) if significance_mask[n].sum() != 0]
+    if not neighbors:
+        return None
+    # Calculate distances to significant neighbors
+    distances = [_get_euclidean_distance(node, n, network) for n in neighbors]
+
+    return np.median(distances)
+
+
 def _get_euclidean_distance(node1: Any, node2: Any, network: nx.Graph) -> float:
     """
     Calculate the Euclidean distance between two nodes in the network.

risk/_network/__init__.py

@@ -4,5 +4,5 @@ risk/_network
 """
 
 from ._graph import GraphAPI
-from ._io import NetworkIO
+from ._io import NetworkAPI
 from ._plotter import PlotterAPI

risk/_network/_graph/_api.py

@@ -27,9 +27,6 @@ class GraphAPI:
     The GraphAPI class provides methods to load and process network graphs, annotations, and neighborhoods.
     """
 
-    def __init__(self) -> None:
-        pass
-
     def load_graph(
         self,
         network: nx.Graph,

risk/_network/_graph/_summary.py

@@ -84,7 +84,7 @@ class Summary:
 
         Returns:
             pd.DataFrame: Processed DataFrame containing significance scores, p-values, q-values,
-                and annotation member information.
+                and matched annotation members information.
         """
         log_header("Loading analysis summary")
         # Calculate significance and depletion q-values from p-value matrices in annotation
@@ -109,9 +109,9 @@ class Summary:
         # Add minimum p-values and q-values to DataFrame
         results[
             [
-                "Enrichment P-Value",
+                "Enrichment P-value",
                 "Enrichment Q-value",
-                "Depletion P-Value",
+                "Depletion P-value",
                 "Depletion Q-value",
             ]
         ] = results.apply(
@@ -126,13 +126,13 @@ class Summary:
             axis=1,
             result_type="expand",
         )
-        # Add annotation members and their counts
-        results["Annotation Members in Network"] = results["Annotation"].apply(
+        # Add matched annotation members and their counts
+        results["Matched Members"] = results["Annotation"].apply(
             lambda desc: self._get_annotation_members(desc)
         )
-        results["Annotation Members in Network Count"] = results[
-            "Annotation Members in Network"
-        ].apply(lambda x: len(x.split(";")) if x else 0)
+        results["Matched Count"] = results["Matched Members"].apply(
+            lambda x: len(x.split(";")) if x else 0
+        )
 
         # Reorder columns and drop rows with NaN values
         results = (
@@ -140,12 +140,12 @@ class Summary:
                 [
                     "Domain ID",
                     "Annotation",
-                    "Annotation Members in Network",
-                    "Annotation Members in Network Count",
+                    "Matched Members",
+                    "Matched Count",
                     "Summed Significance Score",
-                    "Enrichment P-Value",
+                    "Enrichment P-value",
                     "Enrichment Q-value",
-                    "Depletion P-Value",
+                    "Depletion P-value",
                     "Depletion Q-value",
                 ]
             ]
@@ -159,20 +159,18 @@ class Summary:
         results = pd.merge(ordered_annotation, results, on="Annotation", how="left").fillna(
             {
                 "Domain ID": -1,
-                "Annotation Members in Network": "",
-                "Annotation Members in Network Count": 0,
+                "Matched Members": "",
+                "Matched Count": 0,
                 "Summed Significance Score": 0.0,
-                "Enrichment P-Value": 1.0,
+                "Enrichment P-value": 1.0,
                 "Enrichment Q-value": 1.0,
-                "Depletion P-Value": 1.0,
+                "Depletion P-value": 1.0,
                 "Depletion Q-value": 1.0,
             }
         )
-        # Convert "Domain ID" and "Annotation Members in Network Count" to integers
+        # Convert "Domain ID" and "Matched Count" to integers
         results["Domain ID"] = results["Domain ID"].astype(int)
-        results["Annotation Members in Network Count"] = results[
-            "Annotation Members in Network Count"
-        ].astype(int)
+        results["Matched Count"] = results["Matched Count"].astype(int)
 
         return results
 

risk/_network/_io.py

@@ -18,114 +18,188 @@ import pandas as pd
 from .._log import log_header, logger, params
 
 
-class NetworkIO:
+class NetworkAPI:
     """
-    A class for loading, processing, and managing network data.
-
-    The NetworkIO class provides methods to load network data from various formats (e.g., GPickle, NetworkX)
-    and process the network by adjusting node coordinates, calculating edge lengths, and validating graph structure.
+    Public-facing interface for loading and initializing network data.
+    Delegates to the NetworkIO worker class for actual I/O and processing.
     """
 
-    def __init__(
+    def load_network_gpickle(
         self,
+        filepath: str,
         compute_sphere: bool = True,
         surface_depth: float = 0.0,
         min_edges_per_node: int = 0,
-    ):
+    ) -> nx.Graph:
         """
-        Initialize the NetworkIO class.
+        Load a network from a GPickle file via NetworkIO.
 
         Args:
-            compute_sphere (bool, optional): Whether to map nodes to a sphere. Defaults to True.
-            surface_depth (float, optional): Surface depth for the sphere. Defaults to 0.0.
-            min_edges_per_node (int, optional): Minimum number of edges per node. Defaults to 0.
+            filepath (str): Path to the GPickle file.
+            compute_sphere (bool, optional): Override or use API default. Defaults to True.
+            surface_depth (float, optional): Override or use API default. Defaults to 0.0.
+            min_edges_per_node (int, optional): Override or use API default. Defaults to 0.
+        Returns:
+            nx.Graph: Loaded and processed network.
         """
-        self.compute_sphere = compute_sphere
-        self.surface_depth = surface_depth
-        self.min_edges_per_node = min_edges_per_node
-        # Log the initialization of the NetworkIO class
-        params.log_network(
+        io = NetworkIO(
             compute_sphere=compute_sphere,
             surface_depth=surface_depth,
             min_edges_per_node=min_edges_per_node,
         )
+        return io.load_network_gpickle(filepath=filepath)
 
-    def load_network_gpickle(
+    def load_network_networkx(
         self,
-        filepath: str,
+        network: nx.Graph,
         compute_sphere: bool = True,
         surface_depth: float = 0.0,
         min_edges_per_node: int = 0,
     ) -> nx.Graph:
         """
-        Load a network from a GPickle file.
+        Load a NetworkX graph via NetworkIO.
 
         Args:
-            filepath (str): Path to the GPickle file.
-            compute_sphere (bool, optional): Whether to map nodes to a sphere. Defaults to True.
-            surface_depth (float, optional): Surface depth for the sphere. Defaults to 0.0.
-            min_edges_per_node (int, optional): Minimum number of edges per node. Defaults to 0.
+            network (nx.Graph): A NetworkX graph object.
+            compute_sphere (bool, optional): Override or use API default. Defaults to True.
+            surface_depth (float, optional): Override or use API default. Defaults to 0.0.
+            min_edges_per_node (int, optional): Override or use API default. Defaults to 0.
+        Returns:
+            nx.Graph: Processed network.
+        """
+        io = NetworkIO(
+            compute_sphere=compute_sphere,
+            surface_depth=surface_depth,
+            min_edges_per_node=min_edges_per_node,
+        )
+        return io.load_network_networkx(network=network)
 
+    def load_network_cytoscape(
+        self,
+        filepath: str,
+        source_label: str = "source",
+        target_label: str = "target",
+        view_name: str = "",
+        compute_sphere: bool = True,
+        surface_depth: float = 0.0,
+        min_edges_per_node: int = 0,
+    ) -> nx.Graph:
+        """
+        Load a network from a Cytoscape file via NetworkIO.
+
+        Args:
+            filepath (str): Path to the Cytoscape file.
+            source_label (str, optional): Source node label. Defaults to "source".
+            target_label (str, optional): Target node label. Defaults to "target".
+            view_name (str, optional): Specific view name to load. Defaults to "".
+            compute_sphere (bool, optional): Override or use API default. Defaults to True.
+            surface_depth (float, optional): Override or use API default. Defaults to 0.0.
+            min_edges_per_node (int, optional): Override or use API default. Defaults to 0.
         Returns:
             nx.Graph: Loaded and processed network.
         """
-        networkio = NetworkIO(
+        io = NetworkIO(
             compute_sphere=compute_sphere,
             surface_depth=surface_depth,
             min_edges_per_node=min_edges_per_node,
         )
-        return networkio._load_network_gpickle(filepath=filepath)
+        return io.load_network_cytoscape(
+            filepath=filepath,
+            source_label=source_label,
+            target_label=target_label,
+            view_name=view_name,
+        )
 
-    def _load_network_gpickle(self, filepath: str) -> nx.Graph:
+    def load_network_cyjs(
+        self,
+        filepath: str,
+        source_label: str = "source",
+        target_label: str = "target",
+        compute_sphere: bool = True,
+        surface_depth: float = 0.0,
+        min_edges_per_node: int = 0,
+    ) -> nx.Graph:
         """
-        Private method to load a network from a GPickle file.
+        Load a network from a Cytoscape JSON (.cyjs) file via NetworkIO.
 
         Args:
-            filepath (str): Path to the GPickle file.
-
+            filepath (str): Path to the Cytoscape JSON file.
+            source_label (str, optional): Source node label. Defaults to "source".
+            target_label (str, optional): Target node label. Defaults to "target".
+            compute_sphere (bool, optional): Override or use API default. Defaults to True.
+            surface_depth (float, optional): Override or use API default. Defaults to 0.0.
+            min_edges_per_node (int, optional): Override or use API default. Defaults to 0.
         Returns:
             nx.Graph: Loaded and processed network.
         """
-        filetype = "GPickle"
-        # Log the loading of the GPickle file
-        params.log_network(filetype=filetype, filepath=filepath)
-        self._log_loading_network(filetype, filepath=filepath)
+        io = NetworkIO(
+            compute_sphere=compute_sphere,
+            surface_depth=surface_depth,
+            min_edges_per_node=min_edges_per_node,
+        )
+        return io.load_network_cyjs(
+            filepath=filepath,
+            source_label=source_label,
+            target_label=target_label,
+        )
 
-        with open(filepath, "rb") as f:
-            G = pickle.load(f)
 
-        # Initialize the graph
-        return self._initialize_graph(G)
+class NetworkIO:
+    """
+    A class for loading, processing, and managing network data.
 
-    def load_network_networkx(
+    The NetworkIO class provides methods to load network data from various formats (e.g., GPickle, NetworkX)
+    and process the network by adjusting node coordinates, calculating edge lengths, and validating graph structure.
+    """
+
+    def __init__(
         self,
-        network: nx.Graph,
         compute_sphere: bool = True,
         surface_depth: float = 0.0,
         min_edges_per_node: int = 0,
-    ) -> nx.Graph:
+    ):
         """
-        Load a NetworkX graph.
+        Initialize the NetworkIO class.
 
         Args:
-            network (nx.Graph): A NetworkX graph object.
             compute_sphere (bool, optional): Whether to map nodes to a sphere. Defaults to True.
             surface_depth (float, optional): Surface depth for the sphere. Defaults to 0.0.
-            min_edges_per_node (int, optional): Minimum number of edges per node. Defaults to 0.
-
-        Returns:
-            nx.Graph: Loaded and processed network.
+            min_edges_per_node (int, optional): Minimum number of edges per node (k-core threshold). Defaults to 0.
         """
-        networkio = NetworkIO(
+        self.compute_sphere = compute_sphere
+        self.surface_depth = surface_depth
+        self.min_edges_per_node = min_edges_per_node
+        # Log the initialization of the NetworkIO class
+        params.log_network(
             compute_sphere=compute_sphere,
             surface_depth=surface_depth,
             min_edges_per_node=min_edges_per_node,
         )
-        return networkio._load_network_networkx(network=network)
 
-    def _load_network_networkx(self, network: nx.Graph) -> nx.Graph:
+    def load_network_gpickle(self, filepath: str) -> nx.Graph:
         """
-        Private method to load a NetworkX graph.
+        Load a network from a GPickle file.
+
+        Args:
+            filepath (str): Path to the GPickle file.
+
+        Returns:
+            nx.Graph: Loaded and processed network.
+        """
+        filetype = "GPickle"
+        # Log the loading of the GPickle file
+        params.log_network(filetype=filetype, filepath=filepath)
+        self._log_loading_network(filetype, filepath=filepath)
+
+        with open(filepath, "rb") as f:
+            G = pickle.load(f)
+
+        # Initialize the graph
+        return self._initialize_graph(G)
+
+    def load_network_networkx(self, network: nx.Graph) -> nx.Graph:
+        """
+        Load a NetworkX graph.
 
         Args:
             network (nx.Graph): A NetworkX graph object.
@@ -149,47 +223,10 @@ class NetworkIO:
         source_label: str = "source",
         target_label: str = "target",
         view_name: str = "",
-        compute_sphere: bool = True,
-        surface_depth: float = 0.0,
-        min_edges_per_node: int = 0,
     ) -> nx.Graph:
         """
         Load a network from a Cytoscape file.
 
-        Args:
-            filepath (str): Path to the Cytoscape file.
-            source_label (str, optional): Source node label. Defaults to "source".
-            target_label (str, optional): Target node label. Defaults to "target".
-            view_name (str, optional): Specific view name to load. Defaults to "".
-            compute_sphere (bool, optional): Whether to map nodes to a sphere. Defaults to True.
-            surface_depth (float, optional): Surface depth for the sphere. Defaults to 0.0.
-            min_edges_per_node (int, optional): Minimum number of edges per node. Defaults to 0.
-
-        Returns:
-            nx.Graph: Loaded and processed network.
-        """
-        networkio = NetworkIO(
-            compute_sphere=compute_sphere,
-            surface_depth=surface_depth,
-            min_edges_per_node=min_edges_per_node,
-        )
-        return networkio._load_network_cytoscape(
-            filepath=filepath,
-            source_label=source_label,
-            target_label=target_label,
-            view_name=view_name,
-        )
-
-    def _load_network_cytoscape(
-        self,
-        filepath: str,
-        source_label: str = "source",
-        target_label: str = "target",
-        view_name: str = "",
-    ) -> nx.Graph:
-        """
-        Private method to load a network from a Cytoscape file.
-
         Args:
             filepath (str): Path to the Cytoscape file.
             source_label (str, optional): Source node label. Defaults to "source".
@@ -315,44 +352,10 @@ class NetworkIO:
             if os.path.exists(tmp_dir):
                 shutil.rmtree(tmp_dir)
 
-    def load_network_cyjs(
-        self,
-        filepath: str,
-        source_label: str = "source",
-        target_label: str = "target",
-        compute_sphere: bool = True,
-        surface_depth: float = 0.0,
-        min_edges_per_node: int = 0,
-    ) -> nx.Graph:
+    def load_network_cyjs(self, filepath, source_label="source", target_label="target"):
         """
         Load a network from a Cytoscape JSON (.cyjs) file.
 
-        Args:
-            filepath (str): Path to the Cytoscape JSON file.
-            source_label (str, optional): Source node label. Default is "source".
-            target_label (str, optional): Target node label. Default is "target".
-            compute_sphere (bool, optional): Whether to map nodes to a sphere. Defaults to True.
-            surface_depth (float, optional): Surface depth for the sphere. Defaults to 0.0.
-            min_edges_per_node (int, optional): Minimum number of edges per node. Defaults to 0.
-
-        Returns:
-            NetworkX graph: Loaded and processed network.
-        """
-        networkio = NetworkIO(
-            compute_sphere=compute_sphere,
-            surface_depth=surface_depth,
-            min_edges_per_node=min_edges_per_node,
-        )
-        return networkio._load_network_cyjs(
-            filepath=filepath,
-            source_label=source_label,
-            target_label=target_label,
-        )
-
-    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:
             filepath (str): Path to the Cytoscape JSON file.
             source_label (str, optional): Source node label. Default is "source".
@@ -437,20 +440,14 @@ class NetworkIO:
         num_initial_edges = G.number_of_edges()
         # Remove self-loops to ensure correct edge count
         G.remove_edges_from(nx.selfloop_edges(G))
-        # Iteratively remove nodes with fewer edges than the threshold
-        while True:
-            nodes_to_remove = [
-                node
-                for node, degree in dict(G.degree()).items()
-                if degree < self.min_edges_per_node
-            ]
-            if not nodes_to_remove:
-                break  # Exit loop if no nodes meet the condition
-            G.remove_nodes_from(nodes_to_remove)
-
-        # Remove isolated nodes
-        isolates = list(nx.isolates(G))
-        G.remove_nodes_from(isolates)
+        # Apply canonical node k-core pruning if requested
+        if self.min_edges_per_node > 0:
+            # networkx.k_core returns a subgraph; to preserve in-place behavior, copy back
+            core = nx.k_core(G, k=self.min_edges_per_node)
+            # Rebuild G in-place to keep external references valid
+            G.clear()
+            G.add_nodes_from(core.nodes(data=True))
+            G.add_edges_from(core.edges(data=True))
 
         # Log the number of nodes and edges before and after cleaning
         num_final_nodes = G.number_of_nodes()

risk/_network/_plotter/_api.py

@@ -19,9 +19,6 @@ class PlotterAPI:
     The PlotterAPI class provides methods to load and configure Plotter objects for plotting network graphs.
     """
 
-    def __init__(self) -> None:
-        pass
-
     def load_plotter(
         self,
         graph: Graph,

risk/{risk.py → _risk.py}

@@ -1,15 +1,15 @@
 """
-risk/risk
-~~~~~~~~~
+risk/_risk
+~~~~~~~~~~
 """
 
-from ._annotation import AnnotationIO
+from ._annotation import AnnotationHandler
 from ._log import params, set_global_verbosity
 from ._neighborhoods import NeighborhoodsAPI
-from ._network import GraphAPI, NetworkIO, PlotterAPI
+from ._network import GraphAPI, NetworkAPI, PlotterAPI
 
 
-class RISK(NetworkIO, AnnotationIO, NeighborhoodsAPI, GraphAPI, PlotterAPI):
+class RISK(NetworkAPI, AnnotationHandler, NeighborhoodsAPI, GraphAPI, PlotterAPI):
     """
     RISK: A class for network analysis and visualization.
 

risk_network-0.0.14.dist-info/METADATA

@@ -0,0 +1,115 @@
+Metadata-Version: 2.4
+Name: risk-network
+Version: 0.0.14
+Summary: A Python package for scalable network analysis and high-quality visualization.
+Author-email: Ira Horecka <ira89@icloud.com>
+License: GPL-3.0-or-later
+Project-URL: Homepage, https://github.com/riskportal/network
+Project-URL: Issues, https://github.com/riskportal/network/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: ipywidgets
+Requires-Dist: leidenalg
+Requires-Dist: markov_clustering
+Requires-Dist: matplotlib
+Requires-Dist: networkx
+Requires-Dist: nltk
+Requires-Dist: numpy
+Requires-Dist: openpyxl
+Requires-Dist: pandas
+Requires-Dist: python-igraph
+Requires-Dist: python-louvain
+Requires-Dist: scikit-learn
+Requires-Dist: scipy
+Requires-Dist: statsmodels
+Requires-Dist: threadpoolctl
+Requires-Dist: tqdm
+Dynamic: license-file
+
+# RISK Network
+
+<p align="center">
+  <img src="https://i.imgur.com/8TleEJs.png" width="50%" />
+</p>
+
+<br>
+
+![Python](https://img.shields.io/badge/python-3.8%2B-yellow)
+[![pypiv](https://img.shields.io/pypi/v/risk-network.svg)](https://pypi.python.org/pypi/risk-network)
+![License](https://img.shields.io/badge/license-GPLv3-purple)
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.xxxxxxx.svg)](https://doi.org/10.5281/zenodo.xxxxxxx)
+![Downloads](https://img.shields.io/pypi/dm/risk-network)
+![Tests](https://github.com/riskportal/network/actions/workflows/ci.yml/badge.svg)
+
+**RISK** (Regional Inference of Significant Kinships) is a next-generation tool for biological network annotation and visualization. It integrates community detection algorithms, rigorous overrepresentation analysis, and a modular framework for diverse network types. RISK identifies biologically coherent relationships within networks and generates publication-ready visualizations, making it a useful tool for biological and interdisciplinary network analysis.
+
+For a full description of RISK and its applications, see:
+<br>
+**Horecka and Röst (2025)**, _"RISK: a next-generation tool for biological network annotation and visualization"_.
+<br>
+DOI: [10.5281/zenodo.xxxxxxx](https://doi.org/10.5281/zenodo.xxxxxxx)
+
+## Documentation and Tutorial
+
+Full documentation is available at:
+
+- **Docs:** [https://riskportal.github.io/network-tutorial](https://riskportal.github.io/network-tutorial)
+- **Tutorial Jupyter Notebook Repository:** [https://github.com/riskportal/network-tutorial](https://github.com/riskportal/network-tutorial)
+
+## Installation
+
+RISK is compatible with Python 3.8 or later and runs on all major operating systems. To install the latest version of RISK, run:
+
+```bash
+pip install risk-network --upgrade
+```
+
+## Key Features of RISK
+
+- **Broad Data Compatibility**: Accepts multiple network formats (NetworkX, Cytoscape, GPickle) and user-provided annotations formatted as term–to–gene membership tables (JSON, CSV, TSV, Excel, or Python dictionaries).
+- **Flexible Clustering**: Offers Louvain, Leiden, Markov Clustering, Greedy Modularity, Label Propagation, Spinglass, and Walktrap, with user-defined resolution parameters to detect both coarse and fine-grained modules.
+- **Statistical Testing**: Provides hypergeometric, binomial, chi-squared, Poisson, z-score, and permutation tests, balancing speed with statistical rigor.
+- **High-Resolution Visualization**: Generates publication-ready figures with contour overlays, customizable node/edge properties, and export to SVG, PNG, or PDF.
+
+## Example Usage
+
+We applied RISK to a _Saccharomyces cerevisiae_ protein–protein interaction (PPI) network (Michaelis _et al_., 2023; 3,839 proteins, 30,955 interactions). RISK identified compact, functional modules overrepresented in Gene Ontology Biological Process (GO BP) terms (Ashburner _et al_., 2000), revealing biological organization including ribosomal assembly, mitochondrial organization, and RNA polymerase activity (P < 0.0001).
+
+[![Yeast PPI network annotated with GO BP terms](https://i.imgur.com/jQKatLY.jpeg)](https://i.imgur.com/jQKatLY.jpeg)
+**RISK workflow overview and analysis of the yeast PPI network**. GO BP terms are color-coded to represent key cellular processes—including ribosomal assembly, mitochondrial organization, and RNA polymerase activity (P < 0.0001).
+
+## Citation
+
+If you use RISK in your research, please cite the following:
+
+**Horecka and Röst (2025)**, _"RISK: a next-generation tool for biological network annotation and visualization"_.
+<br>
+DOI: [10.5281/zenodo.xxxxxxx](https://doi.org/10.5281/zenodo.xxxxxxx)
+
+## Contributing
+
+We welcome contributions from the community:
+
+- [Issues Tracker](https://github.com/riskportal/network/issues)
+- [Source Code](https://github.com/riskportal/network/tree/main/risk)
+
+## Support
+
+If you encounter issues or have suggestions for new features, please use the [Issues Tracker](https://github.com/riskportal/network/issues) on GitHub.
+
+## License
+
+RISK is open source under the [GNU General Public License v3.0](https://www.gnu.org/licenses/gpl-3.0.en.html).

{risk_network-0.0.13b5.dist-info → risk_network-0.0.14.dist-info}/RECORD

@@ -1,31 +1,31 @@
-risk/__init__.py,sha256=lyhdzjETYJ9Jg8da35gncJ_u2_QrElRsW5t1c69OIJY,142
-risk/risk.py,sha256=l7Btltgd-K00rmUV4_jTgJTwikSmMb-9A2IUQN5PnY8,1040
-risk/_annotation/__init__.py,sha256=LBLL5P_MdfwWaxkHBQHfQTPY-FF8hIGoUGKyHF1Wg4s,159
+risk/__init__.py,sha256=dIsUIx_RUj6VLoSixswIhpxEO91S4LoLQT86GuAMllU,136
+risk/_risk.py,sha256=VULCdM41BlWKM1ou4Qc579ffZ9dMZkfhAwKYgbaEeKM,1054
+risk/_annotation/__init__.py,sha256=zr7w1DHkmvrkKFGKdPhrcvZHV-xsfd5TZOaWtFiP4Dc,164
 risk/_annotation/_annotation.py,sha256=03vcnkdi4HGH5UUyokUyOdyyjXOLoKSmLFuK7VAl41c,15174
-risk/_annotation/_io.py,sha256=gEq6STSWFIFjSWoGXJfwxTME4GDJZTOgPeXZABgSdXc,12447
+risk/_annotation/_io.py,sha256=xic3dkEA54X82HbyWfCiXrUpAhPWFPBZ69R8jw31omQ,12457
 risk/_annotation/_nltk_setup.py,sha256=aHHnElLOKiouVDrZ3uON0CSFmBxvzmYfjYPi07v2rJM,3584
 risk/_log/__init__.py,sha256=LX6BsfcGOH0RbAdQaUmIU-LVMmArDdKwn0jFtj45FYo,205
 risk/_log/_console.py,sha256=1jSFzY3w0-vVqIBCgc-IhyJPNT6vRg8GSGxhyw_D9MI,4653
 risk/_log/_parameters.py,sha256=8FkeeBtULDFVw3UijLArK-G3OIjy6YXyRXmPPckK7fU,5893
 risk/_neighborhoods/__init__.py,sha256=eKwjpEUKSUmAirRZ_qPTVF7MLkvhCn_fulPVq158wM8,185
-risk/_neighborhoods/_api.py,sha256=6vt25y38wSvEhMvNxy9Rl-CrQc9ARSuvGwexWagg5z0,23344
+risk/_neighborhoods/_api.py,sha256=s1f4d_nEPWc66KDmOUUpRNXzp6dfoevw45ewOg9eMNo,23298
 risk/_neighborhoods/_community.py,sha256=Tr-EHO91EWbMmNr_z21UCngiqWOlWIqcjwBig_VXI8c,17850
-risk/_neighborhoods/_domains.py,sha256=He8G2-E9-yYQB8ChUtMFr51HVlfRj5EaxGu3sGVNUCo,14630
-risk/_neighborhoods/_neighborhoods.py,sha256=9H7BickJx9GdnOo5d5wpdtXkcWyvzq2w6FAy1rwLBtk,20614
+risk/_neighborhoods/_domains.py,sha256=Q3MUWW9KjuERpxs4H1dNFhalDjdatMkWSnB12BerUDU,16580
+risk/_neighborhoods/_neighborhoods.py,sha256=9hpQCYG0d9fZLYj-fVACgLJBtw3dW8C-0YbE2OWuX-M,21436
 risk/_neighborhoods/_stats/__init__.py,sha256=nL83A3unzpCTzRDPanCiqU1RsKPJJNDe46S9igoe3pg,264
 risk/_neighborhoods/_stats/_tests.py,sha256=-ioHdyrsgW63YnypKFpanatauuKrF3LT7aMZ3b6otrU,12091
 risk/_neighborhoods/_stats/_permutation/__init__.py,sha256=nfTaW29CK8OZCdFnpMVlHnFaqr1E4AZp6mvhlUazHXM,140
 risk/_neighborhoods/_stats/_permutation/_permutation.py,sha256=e5qVuYWGhiAn5Jv8VILk-WYMOO4km48cGdRYTOl355M,10661
 risk/_neighborhoods/_stats/_permutation/_test_functions.py,sha256=lGI_MkdbW4UHI0jWN_T1OattRjXrq_qmzAmOfels670,3165
-risk/_network/__init__.py,sha256=LbXsJGU2-ydDMw5_qgwizE6YHMljGDuOGc6TO-jk4Pk,126
-risk/_network/_io.py,sha256=vOSfAWnj1Q4jQSVo9BqY-nwQIoEG-CYZ_Cv2clopVw0,28090
+risk/_network/__init__.py,sha256=YrAMfhL0CMWQb3sY-mn1VxK44zZAWeFAvHrBONH9I-A,127
+risk/_network/_io.py,sha256=wmokwNViz24Gv6o3OFRTYHftYYz4sN64VigGrdEGzy8,28057
 risk/_network/_graph/__init__.py,sha256=SFgxgxUiZK4vvw6bdQ04DSMXEr8xjMaQV-Wne6wAIqM,104
-risk/_network/_graph/_api.py,sha256=zH7n-ulqLcbgHdAfLu1yWErdR5G4LgSqR7DcN2qApco,8520
+risk/_network/_graph/_api.py,sha256=sp3_mLJDP_xQexYBjyM17iyzLb2oGmiC050kcw-jVho,8474
 risk/_network/_graph/_graph.py,sha256=x2EWT_ZVwxh7m9a01yG4WMdmAxBxiaxX3CvkqP9QAXE,12486
 risk/_network/_graph/_stats.py,sha256=6mxZkuL6LJlwKDsBbP22DAVkNUEhq-JZwYMKhFKD08k,7359
-risk/_network/_graph/_summary.py,sha256=4eGhCArssePDg4LXr3sg5bUpNn7KFK9oPZcCz5lJKEQ,10334
+risk/_network/_graph/_summary.py,sha256=I8FhMdpawGbvCJHPpsyvbtM7Qa0xXzwKvjnX9N8HSm8,10141
 risk/_network/_plotter/__init__.py,sha256=qFRtQKSBGIqmUGwmA7VPL7hTHBb9yvRIt0nLISXnwkY,84
-risk/_network/_plotter/_api.py,sha256=MHZIMTlul2u-Ve5m9r-eUljI2oC3IRklNn7AVlfmzGs,1773
+risk/_network/_plotter/_api.py,sha256=OaV1CCRGsz98wEEzyEhaq2CqEuZh6t2qS7g_rY6HJJs,1727
 risk/_network/_plotter/_canvas.py,sha256=H7rPz4Gv7ED3bDHMif4cf2usdU4ifmxzXeug5A_no68,13599
 risk/_network/_plotter/_contour.py,sha256=E3ILjlv-VBSbK3ClwObB84TvP1D48_B47ODXwtApjIE,15557
 risk/_network/_plotter/_labels.py,sha256=8JXzEOIBQefwr1ngF-2ZYCnYLZXs2Erz-R1c28NnsL0,46915
@@ -34,8 +34,8 @@ risk/_network/_plotter/_plotter.py,sha256=F2hw-spUdsXjvuG36o0YFR3Pnd-CZOHYUq4vW0
 risk/_network/_plotter/_utils/__init__.py,sha256=JXgjKiBWvXx0X2IeFnrOh5YZQGQoELbhJZ0Zh2mFEOo,211
 risk/_network/_plotter/_utils/_colors.py,sha256=JCliSvz8_-TsjilaRHSEsqdXFBUYlzhXKOSRGdCm9Kw,19177
 risk/_network/_plotter/_utils/_layout.py,sha256=GyGLc2U1WWUVL1Te9uPi_CLqlW_E4TImXRAL5TeA5D8,3633
-risk_network-0.0.13b5.dist-info/licenses/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
-risk_network-0.0.13b5.dist-info/METADATA,sha256=dkYs8JCdMr945DZ-7bJ95MX0zuxfbkw1VpOhuLtCE_U,6853
-risk_network-0.0.13b5.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
-risk_network-0.0.13b5.dist-info/top_level.txt,sha256=NX7C2PFKTvC1JhVKv14DFlFAIFnKc6Lpsu1ZfxvQwVw,5
-risk_network-0.0.13b5.dist-info/RECORD,,
+risk_network-0.0.14.dist-info/licenses/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+risk_network-0.0.14.dist-info/METADATA,sha256=wdfJmWVphRRLwTAIURl5xSa9vLzl1SCQk8_HB5ezfG0,5698
+risk_network-0.0.14.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+risk_network-0.0.14.dist-info/top_level.txt,sha256=NX7C2PFKTvC1JhVKv14DFlFAIFnKc6Lpsu1ZfxvQwVw,5
+risk_network-0.0.14.dist-info/RECORD,,

{risk_network-0.0.13b5.dist-info → risk_network-0.0.14.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.3.1)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

risk_network-0.0.13b5.dist-info/METADATA

@@ -1,125 +0,0 @@
-Metadata-Version: 2.4
-Name: risk-network
-Version: 0.0.13b5
-Summary: A Python package for scalable network analysis and high-quality visualization.
-Author-email: Ira Horecka <ira89@icloud.com>
-License: GPL-3.0-or-later
-Project-URL: Homepage, https://github.com/riskportal/network
-Project-URL: Issues, https://github.com/riskportal/network/issues
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
-Classifier: Topic :: Scientific/Engineering :: Information Analysis
-Classifier: Topic :: Scientific/Engineering :: Visualization
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: ipywidgets
-Requires-Dist: leidenalg
-Requires-Dist: markov_clustering
-Requires-Dist: matplotlib
-Requires-Dist: networkx
-Requires-Dist: nltk
-Requires-Dist: numpy
-Requires-Dist: openpyxl
-Requires-Dist: pandas
-Requires-Dist: python-igraph
-Requires-Dist: python-louvain
-Requires-Dist: scikit-learn
-Requires-Dist: scipy
-Requires-Dist: statsmodels
-Requires-Dist: threadpoolctl
-Requires-Dist: tqdm
-Dynamic: license-file
-
-# RISK Network
-
-<p align="center">
-  <img src="https://i.imgur.com/8TleEJs.png" width="50%" />
-</p>
-
-<br>
-
-![Python](https://img.shields.io/badge/python-3.8%2B-yellow)
-[![pypiv](https://img.shields.io/pypi/v/risk-network.svg)](https://pypi.python.org/pypi/risk-network)
-![License](https://img.shields.io/badge/license-GPLv3-purple)
-[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.xxxxxxx.svg)](https://doi.org/10.5281/zenodo.xxxxxxx)
-![Downloads](https://img.shields.io/pypi/dm/risk-network)
-![Tests](https://github.com/riskportal/network/actions/workflows/ci.yml/badge.svg)
-
-**RISK** (Regional Inference of Significant Kinships) is a next-generation tool for biological network annotation and visualization. RISK integrates community detection-based clustering, rigorous statistical enrichment analysis, and a modular framework to uncover biologically meaningful relationships and generate high-resolution visualizations. RISK supports diverse data formats and is optimized for large-scale network analysis, making it a valuable resource for researchers in systems biology and beyond.
-
-## Documentation and Tutorial
-
-Full documentation is available at:
-
-- **Docs:** [https://riskportal.github.io/network-tutorial](https://riskportal.github.io/network-tutorial)  
-- **Tutorial Jupyter Notebook Repository:** [https://github.com/riskportal/network-tutorial](https://github.com/riskportal/network-tutorial)
-
-## Installation
-
-RISK is compatible with Python 3.8 or later and runs on all major operating systems. To install the latest version of RISK, run:
-
-```bash
-pip install risk-network --upgrade
-```
-
-## Features
-
-- **Comprehensive Network Analysis**: Analyze biological networks (e.g., protein–protein interaction and genetic interaction networks) as well as non-biological networks.
-- **Advanced Clustering Algorithms**: Supports Louvain, Leiden, Markov Clustering, Greedy Modularity, Label Propagation, Spinglass, and Walktrap for identifying structured network regions.
-- **Flexible Visualization**: Produce customizable, high-resolution network visualizations with kernel density estimate overlays, adjustable node and edge attributes, and export options in SVG, PNG, and PDF formats.
-- **Efficient Data Handling**: Supports multiple input/output formats, including JSON, CSV, TSV, Excel, Cytoscape, and GPickle.
-- **Statistical Analysis**: Assess functional enrichment using hypergeometric, permutation (network-aware), binomial, chi-squared, Poisson, and z-score tests, ensuring statistical adaptability across datasets.
-- **Cross-Domain Applicability**: Suitable for network analysis across biological and non-biological domains, including social and communication networks.
-
-## Example Usage
-
-We applied RISK to a *Saccharomyces cerevisiae* protein–protein interaction network from Michaelis et al. (2023), filtering for proteins with six or more interactions to emphasize core functional relationships. RISK identified compact, statistically enriched clusters corresponding to biological processes such as ribosomal assembly and mitochondrial organization.
-
-[![Figure 1](https://i.imgur.com/lJHJrJr.jpeg)](https://i.imgur.com/lJHJrJr.jpeg)
-
-This figure highlights RISK’s capability to detect both established and novel functional modules within the yeast interactome.
-
-## Citation
-
-If you use RISK in your research, please reference the following:
-
-**Horecka et al.**, *"RISK: a next-generation tool for biological network annotation and visualization"*, 2025.  
-DOI: [10.1234/zenodo.xxxxxxx](https://doi.org/10.1234/zenodo.xxxxxxx)
-
-## Software Architecture and Implementation
-
-RISK features a streamlined, modular architecture designed to meet diverse research needs. RISK’s modular design enables users to run individual components—such as clustering, statistical testing, or visualization—independently or in combination, depending on the analysis workflow. It includes dedicated modules for:
-
-- **Data I/O**: Supports JSON, CSV, TSV, Excel, Cytoscape, and GPickle formats.
-- **Clustering**: Supports multiple clustering methods, including Louvain, Leiden, Markov Clustering, Greedy Modularity, Label Propagation, Spinglass, and Walktrap. Provides flexible distance metrics tailored to network structure.
-- **Statistical Analysis**: Provides a suite of tests for overrepresentation analysis of annotations.
-- **Visualization**: Offers customizable, high-resolution output in multiple formats, including SVG, PNG, and PDF.
-- **Configuration Management**: Centralized parameters in risk.params ensure reproducibility and easy tuning for large-scale analyses.
-
-## Performance and Efficiency
-
-Benchmarking results demonstrate that RISK efficiently scales to networks exceeding hundreds of thousands of edges, maintaining low execution times and optimal memory usage across statistical tests.
-
-## Contributing
-
-We welcome contributions from the community:
-
-- [Issues Tracker](https://github.com/riskportal/network/issues)
-- [Source Code](https://github.com/riskportal/network/tree/main/risk)
-
-## Support
-
-If you encounter issues or have suggestions for new features, please use the [Issues Tracker](https://github.com/riskportal/network/issues) on GitHub.
-
-## License
-
-RISK is open source under the [GNU General Public License v3.0](https://www.gnu.org/licenses/gpl-3.0.en.html).