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

risk/__init__.py

@@ -2,12 +2,9 @@
 risk
 ~~~~
 
-risk
-~~~~
-
 RISK: RISK Infers Spatial Kinship
 """
 
 from risk.risk import RISK
 
-__version__ = "0.0.4-beta.1"
+__version__ = "0.0.4-beta.3"

risk/annotations/annotations.py

@@ -197,7 +197,7 @@ def _simplify_word_list(words: List[str], threshold: float = 0.80) -> List[str]:
     word_counts = Counter(words)
     filtered_words = []
     used_words = set()
-
+    # Iterate through the words to find similar words
     for word in word_counts:
         if word in used_words:
             continue

risk/neighborhoods/neighborhoods.py

@@ -321,7 +321,11 @@ def _calculate_threshold(average_distances: list, distance_threshold: float) ->
     rank_percentiles = np.linspace(0, 1, len(sorted_distances))
     # Interpolating the ranks to 1000 evenly spaced percentiles
     interpolated_percentiles = np.linspace(0, 1, 1000)
-    smoothed_distances = np.interp(interpolated_percentiles, rank_percentiles, sorted_distances)
+    try:
+        smoothed_distances = np.interp(interpolated_percentiles, rank_percentiles, sorted_distances)
+    except ValueError as e:
+        raise ValueError("No significant annotations found.") from e
+
     # Determine the index corresponding to the distance threshold
     threshold_index = int(np.ceil(distance_threshold * len(smoothed_distances))) - 1
     # Return the smoothed distance at the calculated index

risk/network/geometry.py

@@ -7,13 +7,13 @@ import networkx as nx
 import numpy as np
 
 
-def apply_edge_lengths(
+def assign_edge_lengths(
     G: nx.Graph,
     compute_sphere: bool = True,
     surface_depth: float = 0.0,
     include_edge_weight: bool = False,
 ) -> nx.Graph:
-    """Apply edge lengths in the graph, optionally mapping nodes to a sphere and including edge weights.
+    """Assign edge lengths in the graph, optionally mapping nodes to a sphere and including edge weights.
 
     Args:
         G (nx.Graph): The input graph.

risk/network/io.py

@@ -6,6 +6,7 @@ This file contains the code for the RISK class and command-line access.
 """
 
 import json
+import os
 import pickle
 import shutil
 import zipfile
@@ -14,7 +15,7 @@ from xml.dom import minidom
 import networkx as nx
 import pandas as pd
 
-from risk.network.geometry import apply_edge_lengths
+from risk.network.geometry import assign_edge_lengths
 from risk.log import params, print_header
 
 
@@ -215,14 +216,20 @@ class NetworkIO:
         params.log_network(filetype=filetype, filepath=str(filepath))
         self._log_loading(filetype, filepath=filepath)
         cys_files = []
+        tmp_dir = ".tmp_cytoscape"
         # Try / finally to remove unzipped files
         try:
-            # Unzip CYS file
+            # Create the temporary directory if it doesn't exist
+            if not os.path.exists(tmp_dir):
+                os.makedirs(tmp_dir)
+
+            # Unzip CYS file into the temporary directory
             with zipfile.ZipFile(filepath, "r") as zip_ref:
                 cys_files = zip_ref.namelist()
-                zip_ref.extractall("./")
+                zip_ref.extractall(tmp_dir)
+
             # Get first view and network instances
-            cys_view_files = [cf for cf in cys_files if "/views/" in cf]
+            cys_view_files = [os.path.join(tmp_dir, cf) for cf in cys_files if "/views/" in cf]
             cys_view_file = (
                 cys_view_files[0]
                 if not view_name
@@ -244,7 +251,7 @@ class NetworkIO:
             # Read the node attributes (from /tables/)
             attribute_metadata_keywords = ["/tables/", "SHARED_ATTRS", "edge.cytable"]
             attribute_metadata = [
-                cf
+                os.path.join(tmp_dir, cf)
                 for cf in cys_files
                 if all(keyword in cf for keyword in attribute_metadata_keywords)
             ][0]
@@ -291,10 +298,9 @@ class NetworkIO:
             return self._initialize_graph(G)
 
         finally:
-            # Remove unzipped files/directories
-            cys_dirnames = list(set([cf.split("/")[0] for cf in cys_files]))
-            for dirname in cys_dirnames:
-                shutil.rmtree(dirname)
+            # Remove the temporary directory and its contents
+            if os.path.exists(tmp_dir):
+                shutil.rmtree(tmp_dir)
 
     @classmethod
     def load_cytoscape_json_network(
@@ -402,12 +408,13 @@ class NetworkIO:
         Returns:
             nx.Graph: The processed and validated graph.
         """
+        self._validate_nodes(G)
+        self._assign_edge_weights(G)
+        self._assign_edge_lengths(G)
+        self._remove_invalid_graph_properties(G)
         # IMPORTANT: This is where the graph node labels are converted to integers
+        # Make sure to perform this step after all other processing
         G = nx.relabel_nodes(G, {node: idx for idx, node in enumerate(G.nodes)})
-        self._remove_invalid_graph_properties(G)
-        self._validate_edges(G)
-        self._validate_nodes(G)
-        self._process_graph(G)
         return G
 
     def _remove_invalid_graph_properties(self, G: nx.Graph) -> None:
@@ -416,18 +423,26 @@ class NetworkIO:
         Args:
             G (nx.Graph): A NetworkX graph object.
         """
-        print(f"Minimum edges per node: {self.min_edges_per_node}")
-        # Remove nodes with fewer edges than the specified threshold
-        nodes_with_few_edges = [
-            node for node in G.nodes() if G.degree(node) <= self.min_edges_per_node
-        ]
-        G.remove_nodes_from(nodes_with_few_edges)
-        # Remove self-loop edges
-        self_loops = list(nx.selfloop_edges(G))
-        G.remove_edges_from(self_loops)
-
-    def _validate_edges(self, G: nx.Graph) -> None:
-        """Validate and assign weights to the edges in the graph.
+        # First, Remove self-loop edges to ensure correct edge count
+        G.remove_edges_from(list(nx.selfloop_edges(G)))
+        # Then, iteratively remove nodes with fewer edges than the specified threshold
+        while True:
+            nodes_to_remove = [
+                node for node in G.nodes() if G.degree(node) < self.min_edges_per_node
+            ]
+            if not nodes_to_remove:
+                break  # Exit loop if no more nodes to remove
+
+            # Remove the nodes and their associated edges
+            G.remove_nodes_from(nodes_to_remove)
+
+        # Optionally: Remove any isolated nodes if needed
+        isolated_nodes = list(nx.isolates(G))
+        if isolated_nodes:
+            G.remove_nodes_from(isolated_nodes)
+
+    def _assign_edge_weights(self, G: nx.Graph) -> None:
+        """Assign weights to the edges in the graph.
 
         Args:
             G (nx.Graph): A NetworkX graph object.
@@ -456,13 +471,13 @@ class NetworkIO:
             ), f"Node {node} is missing 'x' or 'y' position attributes."
             assert "label" in attrs, f"Node {node} is missing a 'label' attribute."
 
-    def _process_graph(self, G: nx.Graph) -> None:
+    def _assign_edge_lengths(self, G: nx.Graph) -> None:
         """Prepare the network by adjusting surface depth and calculating edge lengths.
 
         Args:
             G (nx.Graph): The input network graph.
         """
-        apply_edge_lengths(
+        assign_edge_lengths(
             G,
             compute_sphere=self.compute_sphere,
             surface_depth=self.surface_depth,
@@ -484,9 +499,9 @@ class NetworkIO:
         print(f"Filetype: {filetype}")
         if filepath:
             print(f"Filepath: {filepath}")
-        print(f"Projection: {'Sphere' if self.compute_sphere else 'Plane'}")
-        if self.compute_sphere:
-            print(f"Surface depth: {self.surface_depth}")
         print(f"Edge weight: {'Included' if self.include_edge_weight else 'Excluded'}")
         if self.include_edge_weight:
             print(f"Weight label: {self.weight_label}")
+        print(f"Projection: {'Sphere' if self.compute_sphere else 'Plane'}")
+        if self.compute_sphere:
+            print(f"Surface depth: {self.surface_depth}")

risk/network/plot.py

@@ -400,8 +400,10 @@ class NetworkPlotter:
         fontcolor: Union[str, np.ndarray] = "black",
         arrow_linewidth: float = 1,
         arrow_color: Union[str, np.ndarray] = "black",
+        max_labels: Union[int, None] = None,
         max_words: int = 10,
         min_words: int = 1,
+        words_to_omit: Union[List[str], None] = None,
     ) -> None:
         """Annotate the network graph with labels for different domains, positioned around the network for clarity.
 
@@ -413,8 +415,10 @@ class NetworkPlotter:
             fontcolor (str or np.ndarray, optional): Color of the label text. Can be a string or RGBA array. Defaults to "black".
             arrow_linewidth (float, optional): Line width of the arrows pointing to centroids. Defaults to 1.
             arrow_color (str or np.ndarray, optional): Color of the arrows. Can be a string or RGBA array. Defaults to "black".
+            max_labels (int, optional): Maximum number of labels to plot. Defaults to None (no limit).
             max_words (int, optional): Maximum number of words in a label. Defaults to 10.
             min_words (int, optional): Minimum number of words required to display a label. Defaults to 1.
+            words_to_omit (List[str], optional): List of words to omit from the labels. Defaults to None.
         """
         # Log the plotting parameters
         params.log_plotter(
@@ -425,14 +429,20 @@ class NetworkPlotter:
             label_fontcolor="custom" if isinstance(fontcolor, np.ndarray) else fontcolor,
             label_arrow_linewidth=arrow_linewidth,
             label_arrow_color="custom" if isinstance(arrow_color, np.ndarray) else arrow_color,
+            label_max_labels=max_labels,
             label_max_words=max_words,
             label_min_words=min_words,
+            label_words_to_omit=words_to_omit,  # Log words_to_omit parameter
         )
+
         # Convert color strings to RGBA arrays if necessary
         if isinstance(fontcolor, str):
-            fontcolor = self.get_annotated_contour_colors(color=fontcolor)
+            fontcolor = self.get_annotated_label_colors(color=fontcolor)
         if isinstance(arrow_color, str):
-            arrow_color = self.get_annotated_contour_colors(color=arrow_color)
+            arrow_color = self.get_annotated_label_colors(color=arrow_color)
+        # Normalize words_to_omit to lowercase
+        if words_to_omit:
+            words_to_omit = set(word.lower() for word in words_to_omit)
 
         # Calculate the center and radius of the network
         domain_centroids = {}
@@ -443,18 +453,45 @@ class NetworkPlotter:
         # Initialize empty lists to collect valid indices
         valid_indices = []
         filtered_domain_centroids = {}
+        filtered_domain_terms = {}
         # Loop through domain_centroids with index
         for idx, (domain, centroid) in enumerate(domain_centroids.items()):
+            # Process the domain term
+            terms = self.graph.trimmed_domain_to_term[domain].split(" ")
+            # Remove words_to_omit
+            if words_to_omit:
+                terms = [term for term in terms if term.lower() not in words_to_omit]
+            # Trim to max_words
+            terms = terms[:max_words]
             # Check if the domain passes the word count condition
-            if len(self.graph.trimmed_domain_to_term[domain].split(" ")[:max_words]) >= min_words:
+            if len(terms) >= min_words:
                 # Add to filtered_domain_centroids
                 filtered_domain_centroids[domain] = centroid
+                # Store the trimmed terms
+                filtered_domain_terms[domain] = " ".join(terms)
                 # Keep track of the valid index
                 valid_indices.append(idx)
 
-        # Now filter fontcolor and arrow_color to keep only the valid indices
-        fontcolor = fontcolor[valid_indices]
-        arrow_color = arrow_color[valid_indices]
+        # If max_labels is specified and less than the available labels
+        if max_labels is not None and max_labels < len(filtered_domain_centroids):
+            step = len(filtered_domain_centroids) / max_labels
+            selected_indices = [int(i * step) for i in range(max_labels)]
+            filtered_domain_centroids = {
+                k: v
+                for i, (k, v) in enumerate(filtered_domain_centroids.items())
+                if i in selected_indices
+            }
+            filtered_domain_terms = {
+                k: v
+                for i, (k, v) in enumerate(filtered_domain_terms.items())
+                if i in selected_indices
+            }
+            fontcolor = fontcolor[selected_indices]
+            arrow_color = arrow_color[selected_indices]
+
+        # Update the terms in the graph after omitting words and filtering
+        for domain, terms in filtered_domain_terms.items():
+            self.graph.trimmed_domain_to_term[domain] = terms
 
         # Calculate the bounding box around the network
         center, radius = _calculate_bounding_box(
@@ -531,12 +568,10 @@ class NetworkPlotter:
 
         # Calculate the centroid of the provided nodes
         centroid = self._calculate_domain_centroid(node_ids)
-
         # Calculate the bounding box around the network
         center, radius = _calculate_bounding_box(
             self.graph.node_coordinates, radius_margin=perimeter_scale
         )
-
         # Convert radial position to radians, adjusting for a 90-degree rotation
         radial_radians = np.deg2rad(radial_position - 90)
         label_position = (

risk/risk.py

@@ -6,6 +6,7 @@ risk/risk
 from typing import Any, Dict
 
 import networkx as nx
+import numpy as np
 import pandas as pd
 
 from risk.annotations import AnnotationsIO, define_top_annotations
@@ -17,7 +18,12 @@ from risk.neighborhoods import (
     trim_domains_and_top_annotations,
 )
 from risk.network import NetworkIO, NetworkGraph, NetworkPlotter
-from risk.stats import compute_permutation, calculate_significance_matrices
+from risk.stats import (
+    calculate_significance_matrices,
+    compute_fisher_exact_test,
+    compute_hypergeom_test,
+    compute_permutation_test,
+)
 
 
 class RISK(NetworkIO, AnnotationsIO):
@@ -39,7 +45,7 @@ class RISK(NetworkIO, AnnotationsIO):
         """Access the logged parameters."""
         return params
 
-    def load_neighborhoods(
+    def load_neighborhoods_by_permutation(
         self,
         network: nx.Graph,
         annotations: Dict[str, Any],
@@ -52,7 +58,7 @@ class RISK(NetworkIO, AnnotationsIO):
         random_seed: int = 888,
         max_workers: int = 1,
     ) -> Dict[str, Any]:
-        """Load significant neighborhoods for the network.
+        """Load significant neighborhoods for the network using the permutation test.
 
         Args:
             network (nx.Graph): The network graph.
@@ -75,6 +81,7 @@ class RISK(NetworkIO, AnnotationsIO):
             distance_metric=distance_metric,
             louvain_resolution=louvain_resolution,
             edge_length_threshold=edge_length_threshold,
+            statistical_test_function="permutation",
             score_metric=score_metric,
             null_distribution=null_distribution,
             num_permutations=num_permutations,
@@ -82,30 +89,22 @@ class RISK(NetworkIO, AnnotationsIO):
             max_workers=max_workers,
         )
 
-        # Display the chosen distance metric
-        if distance_metric == "louvain":
-            for_print_distance_metric = f"louvain (resolution={louvain_resolution})"
-        else:
-            for_print_distance_metric = distance_metric
-        print(f"Distance metric: '{for_print_distance_metric}'")
-        print(f"Edge length threshold: {edge_length_threshold}")
-        # Compute neighborhoods based on the network and distance metric
-        neighborhoods = get_network_neighborhoods(
+        # Load neighborhoods based on the network and distance metric
+        neighborhoods = self._load_neighborhoods(
             network,
             distance_metric,
-            edge_length_threshold,
             louvain_resolution=louvain_resolution,
+            edge_length_threshold=edge_length_threshold,
             random_seed=random_seed,
         )
 
         # Log and display permutation test settings
-        print(f"Null distribution: '{null_distribution}'")
         print(f"Neighborhood scoring metric: '{score_metric}'")
+        print(f"Null distribution: '{null_distribution}'")
         print(f"Number of permutations: {num_permutations}")
-        print(f"Random seed: {random_seed}")
         print(f"Maximum workers: {max_workers}")
-        # Run the permutation test to compute neighborhood significance
-        neighborhood_significance = compute_permutation(
+        # Run permutation test to compute neighborhood significance
+        neighborhood_significance = compute_permutation_test(
             neighborhoods=neighborhoods,
             annotations=annotations["matrix"],
             score_metric=score_metric,
@@ -117,6 +116,116 @@ class RISK(NetworkIO, AnnotationsIO):
 
         return neighborhood_significance
 
+    def load_neighborhoods_by_fisher_exact(
+        self,
+        network: nx.Graph,
+        annotations: Dict[str, Any],
+        distance_metric: str = "dijkstra",
+        louvain_resolution: float = 0.1,
+        edge_length_threshold: float = 0.5,
+        random_seed: int = 888,
+        max_workers: int = 1,
+    ) -> Dict[str, Any]:
+        """Load significant neighborhoods for the network using the Fisher's exact test.
+
+        Args:
+            network (nx.Graph): The network graph.
+            annotations (pd.DataFrame): The matrix of annotations associated with the network.
+            distance_metric (str, optional): Distance metric for neighborhood analysis. Defaults to "dijkstra".
+            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.
+            random_seed (int, optional): Seed for random number generation. Defaults to 888.
+            max_workers (int, optional): Maximum number of workers for parallel computation. Defaults to 1.
+
+        Returns:
+            dict: Computed significance of neighborhoods.
+        """
+        print_header("Running Fisher's exact test")
+        # Log neighborhood analysis parameters
+        params.log_neighborhoods(
+            distance_metric=distance_metric,
+            louvain_resolution=louvain_resolution,
+            edge_length_threshold=edge_length_threshold,
+            statistical_test_function="fisher_exact",
+            random_seed=random_seed,
+            max_workers=max_workers,
+        )
+
+        # Load neighborhoods based on the network and distance metric
+        neighborhoods = self._load_neighborhoods(
+            network,
+            distance_metric,
+            louvain_resolution=louvain_resolution,
+            edge_length_threshold=edge_length_threshold,
+            random_seed=random_seed,
+        )
+
+        # Log and display Fisher's exact test settings
+        print(f"Maximum workers: {max_workers}")
+        # Run Fisher's exact test to compute neighborhood significance
+        neighborhood_significance = compute_fisher_exact_test(
+            neighborhoods=neighborhoods,
+            annotations=annotations["matrix"],
+            max_workers=max_workers,
+        )
+
+        return neighborhood_significance
+
+    def load_neighborhoods_by_hypergeom(
+        self,
+        network: nx.Graph,
+        annotations: Dict[str, Any],
+        distance_metric: str = "dijkstra",
+        louvain_resolution: float = 0.1,
+        edge_length_threshold: float = 0.5,
+        random_seed: int = 888,
+        max_workers: int = 1,
+    ) -> Dict[str, Any]:
+        """Load significant neighborhoods for the network using the hypergeometric test.
+
+        Args:
+            network (nx.Graph): The network graph.
+            annotations (pd.DataFrame): The matrix of annotations associated with the network.
+            distance_metric (str, optional): Distance metric for neighborhood analysis. Defaults to "dijkstra".
+            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.
+            random_seed (int, optional): Seed for random number generation. Defaults to 888.
+            max_workers (int, optional): Maximum number of workers for parallel computation. Defaults to 1.
+
+        Returns:
+            dict: Computed significance of neighborhoods.
+        """
+        print_header("Running hypergeometric test")
+        # Log neighborhood analysis parameters
+        params.log_neighborhoods(
+            distance_metric=distance_metric,
+            louvain_resolution=louvain_resolution,
+            edge_length_threshold=edge_length_threshold,
+            statistical_test_function="hypergeom",
+            random_seed=random_seed,
+            max_workers=max_workers,
+        )
+
+        # Load neighborhoods based on the network and distance metric
+        neighborhoods = self._load_neighborhoods(
+            network,
+            distance_metric,
+            louvain_resolution=louvain_resolution,
+            edge_length_threshold=edge_length_threshold,
+            random_seed=random_seed,
+        )
+
+        # Log and display hypergeometric test settings
+        print(f"Maximum workers: {max_workers}")
+        # Run hypergeometric test to compute neighborhood significance
+        neighborhood_significance = compute_hypergeom_test(
+            neighborhoods=neighborhoods,
+            annotations=annotations["matrix"],
+            max_workers=max_workers,
+        )
+
+        return neighborhood_significance
+
     def load_graph(
         self,
         network: nx.Graph,
@@ -140,7 +249,7 @@ class RISK(NetworkIO, AnnotationsIO):
             annotations (pd.DataFrame): DataFrame containing annotation data for the network.
             neighborhoods (dict): Neighborhood enrichment data.
             tail (str, optional): Type of significance tail ("right", "left", "both"). Defaults to "right".
-            pval_cutoff (float, optional): P-value cutoff for significance. Defaults to 0.01.
+            pval_cutoff (float, optional): p-value cutoff for significance. Defaults to 0.01.
             fdr_cutoff (float, optional): FDR cutoff for significance. Defaults to 0.9999.
             impute_depth (int, optional): Depth for imputing neighbors. Defaults to 1.
             prune_threshold (float, optional): Distance threshold for pruning neighbors. Defaults to 0.0.
@@ -168,7 +277,7 @@ class RISK(NetworkIO, AnnotationsIO):
             max_cluster_size=max_cluster_size,
         )
 
-        print(f"P-value cutoff: {pval_cutoff}")
+        print(f"p-value cutoff: {pval_cutoff}")
         print(f"FDR BH cutoff: {fdr_cutoff}")
         print(
             f"Significance tail: '{tail}' ({'enrichment' if tail == 'right' else 'depletion' if tail == 'left' else 'both'})"
@@ -266,6 +375,7 @@ class RISK(NetworkIO, AnnotationsIO):
             outline_color=outline_color,
             outline_scale=outline_scale,
         )
+
         # Initialize and return a NetworkPlotter object
         return NetworkPlotter(
             graph,
@@ -276,6 +386,48 @@ class RISK(NetworkIO, AnnotationsIO):
             outline_scale=outline_scale,
         )
 
+    def _load_neighborhoods(
+        self,
+        network: nx.Graph,
+        distance_metric: str = "dijkstra",
+        louvain_resolution: float = 0.1,
+        edge_length_threshold: float = 0.5,
+        random_seed: int = 888,
+    ) -> np.ndarray:
+        """Load significant neighborhoods for the network.
+
+        Args:
+            network (nx.Graph): The network graph.
+            annotations (pd.DataFrame): The matrix of annotations associated with the network.
+            distance_metric (str, optional): Distance metric for neighborhood analysis. Defaults to "dijkstra".
+            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.
+            random_seed (int, optional): Seed for random number generation. Defaults to 888.
+
+        Returns:
+            np.ndarray: Neighborhood matrix calculated based on the selected distance metric.
+        """
+        # Display the chosen distance metric
+        if distance_metric == "louvain":
+            for_print_distance_metric = f"louvain (resolution={louvain_resolution})"
+        else:
+            for_print_distance_metric = distance_metric
+        # Log and display neighborhood settings
+        print(f"Distance metric: '{for_print_distance_metric}'")
+        print(f"Edge length threshold: {edge_length_threshold}")
+        print(f"Random seed: {random_seed}")
+
+        # Compute neighborhoods based on the network and distance metric
+        neighborhoods = get_network_neighborhoods(
+            network,
+            distance_metric,
+            edge_length_threshold,
+            louvain_resolution=louvain_resolution,
+            random_seed=random_seed,
+        )
+
+        return neighborhoods
+
     def _define_top_annotations(
         self,
         network: nx.Graph,

risk/stats/__init__.py

@@ -3,4 +3,7 @@ risk/stats
 ~~~~~~~~~~
 """
 
-from .stats import calculate_significance_matrices, compute_permutation
+from .stats import calculate_significance_matrices
+from .fisher_exact import compute_fisher_exact_test
+from .hypergeom import compute_hypergeom_test
+from .permutation import compute_permutation_test