risk-network 0.0.3b4__py3-none-any.whl → 0.0.4__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.3-beta.4"
+__version__ = "0.0.4"

risk/annotations/annotations.py

@@ -171,7 +171,9 @@ def get_description(words_column: pd.Series) -> str:
     stop_words = set(stopwords.words("english"))
     # Tokenize the concatenated string and filter out stopwords and non-alphabetic words
     words = [
-        word.lower()
+        (
+            word.lower() if word.istitle() else word
+        )  # Lowercase all words except proper nouns (e.g., RNA, mRNA)
         for word in word_tokenize(words_column.str.cat(sep=" "))
         if word.isalpha() and word.lower() not in stop_words
     ]
@@ -195,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/annotations/io.py

@@ -25,7 +25,7 @@ class AnnotationsIO:
     def __init__(self):
         pass
 
-    def load_json_annotations(self, filepath: str, network: nx.Graph) -> Dict[str, Any]:
+    def load_json_annotation(self, filepath: str, network: nx.Graph) -> Dict[str, Any]:
         """Load annotations from a JSON file and convert them to a DataFrame.
 
         Args:

risk/neighborhoods/neighborhoods.py

@@ -170,7 +170,16 @@ def _impute_neighbors(
     # Calculate shortest distances for each node to determine the distance threshold
     shortest_distances = []
     for node in network.nodes():
-        neighbors = [n for n in network.neighbors(node) if binary_enrichment_matrix[n].sum() != 0]
+        try:
+            neighbors = [
+                n for n in network.neighbors(node) if binary_enrichment_matrix[n].sum() != 0
+            ]
+        except IndexError as e:
+            raise IndexError(
+                f"Failed to find neighbors for node '{node}': Ensure that the node exists in the network and that the binary enrichment matrix is correctly indexed."
+            ) from e
+
+        # Calculate the shortest distance to a neighbor
         if neighbors:
             shortest_distance = min([_get_euclidean_distance(node, n, network) for n in neighbors])
             shortest_distances.append(shortest_distance)
@@ -312,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/graph.py

@@ -49,8 +49,8 @@ class NetworkGraph:
         self.trimmed_domains = trimmed_domains
         self.node_label_to_id_map = node_label_to_id_map
         self.node_enrichment_sums = node_enrichment_sums
-        # NOTE: self.G and self.node_coordinates are declared in _initialize_network
-        self.G = None
+        # NOTE: self.network and self.node_coordinates are declared in _initialize_network
+        self.network = None
         self.node_coordinates = None
         self._initialize_network(network)
 
@@ -95,8 +95,8 @@ class NetworkGraph:
         """
         # Unfold the network's 3D coordinates to 2D
         G_2d = _unfold_sphere_to_plane(G)
-        # Assign the unfolded graph to self.G
-        self.G = G_2d
+        # Assign the unfolded graph to self.network
+        self.network = G_2d
         # Extract 2D coordinates of nodes
         self.node_coordinates = _extract_node_coordinates(G_2d)
 

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
 
 
@@ -29,25 +30,67 @@ class NetworkIO:
         self,
         compute_sphere: bool = True,
         surface_depth: float = 0.0,
-        distance_metric: str = "dijkstra",
-        edge_length_threshold: float = 0.5,
-        louvain_resolution: float = 0.1,
         min_edges_per_node: int = 0,
         include_edge_weight: bool = True,
         weight_label: str = "weight",
     ):
+        """Initialize the NetworkIO class.
+
+        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.
+            include_edge_weight (bool, optional): Whether to include edge weights in calculations. Defaults to True.
+            weight_label (str, optional): Label for edge weights. Defaults to "weight".
+        """
         self.compute_sphere = compute_sphere
         self.surface_depth = surface_depth
+        self.min_edges_per_node = min_edges_per_node
         self.include_edge_weight = include_edge_weight
         self.weight_label = weight_label
-        self.distance_metric = distance_metric
-        self.edge_length_threshold = edge_length_threshold
-        self.louvain_resolution = louvain_resolution
-        self.min_edges_per_node = min_edges_per_node
+        params.log_network(
+            compute_sphere=compute_sphere,
+            surface_depth=surface_depth,
+            min_edges_per_node=min_edges_per_node,
+            include_edge_weight=include_edge_weight,
+            weight_label=weight_label,
+        )
 
-    def load_gpickle_network(self, filepath: str) -> nx.Graph:
+    @classmethod
+    def load_gpickle_network(
+        cls,
+        filepath: str,
+        compute_sphere: bool = True,
+        surface_depth: float = 0.0,
+        min_edges_per_node: int = 0,
+        include_edge_weight: bool = True,
+        weight_label: str = "weight",
+    ) -> nx.Graph:
         """Load a network from a GPickle file.
 
+        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.
+            include_edge_weight (bool, optional): Whether to include edge weights in calculations. Defaults to True.
+            weight_label (str, optional): Label for edge weights. Defaults to "weight".
+
+        Returns:
+            nx.Graph: Loaded and processed network.
+        """
+        networkio = cls(
+            compute_sphere=compute_sphere,
+            surface_depth=surface_depth,
+            min_edges_per_node=min_edges_per_node,
+            include_edge_weight=include_edge_weight,
+            weight_label=weight_label,
+        )
+        return networkio._load_gpickle_network(filepath=filepath)
+
+    def _load_gpickle_network(self, filepath: str) -> nx.Graph:
+        """Private method to load a network from a GPickle file.
+
         Args:
             filepath (str): Path to the GPickle file.
 
@@ -62,11 +105,43 @@ class NetworkIO:
 
         return self._initialize_graph(G)
 
-    def load_networkx_network(self, G: nx.Graph) -> nx.Graph:
+    @classmethod
+    def load_networkx_network(
+        cls,
+        network: nx.Graph,
+        compute_sphere: bool = True,
+        surface_depth: float = 0.0,
+        min_edges_per_node: int = 0,
+        include_edge_weight: bool = True,
+        weight_label: str = "weight",
+    ) -> nx.Graph:
         """Load a NetworkX graph.
 
         Args:
-            G (nx.Graph): A NetworkX graph object.
+            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.
+            include_edge_weight (bool, optional): Whether to include edge weights in calculations. Defaults to True.
+            weight_label (str, optional): Label for edge weights. Defaults to "weight".
+
+        Returns:
+            nx.Graph: Loaded and processed network.
+        """
+        networkio = cls(
+            compute_sphere=compute_sphere,
+            surface_depth=surface_depth,
+            min_edges_per_node=min_edges_per_node,
+            include_edge_weight=include_edge_weight,
+            weight_label=weight_label,
+        )
+        return networkio._load_networkx_network(network=network)
+
+    def _load_networkx_network(self, network: nx.Graph) -> nx.Graph:
+        """Private method to load a NetworkX graph.
+
+        Args:
+            network (nx.Graph): A NetworkX graph object.
 
         Returns:
             nx.Graph: Processed network.
@@ -74,17 +149,60 @@ class NetworkIO:
         filetype = "NetworkX"
         params.log_network(filetype=filetype)
         self._log_loading(filetype)
-        return self._initialize_graph(G)
+        return self._initialize_graph(network)
 
+    @classmethod
     def load_cytoscape_network(
-        self,
+        cls,
         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,
+        include_edge_weight: bool = True,
+        weight_label: str = "weight",
         view_name: str = "",
     ) -> 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 None.
+            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.
+            include_edge_weight (bool, optional): Whether to include edge weights in calculations. Defaults to True.
+            weight_label (str, optional): Label for edge weights. Defaults to "weight".
+
+        Returns:
+            nx.Graph: Loaded and processed network.
+        """
+        networkio = cls(
+            compute_sphere=compute_sphere,
+            surface_depth=surface_depth,
+            min_edges_per_node=min_edges_per_node,
+            include_edge_weight=include_edge_weight,
+            weight_label=weight_label,
+        )
+        return networkio._load_cytoscape_network(
+            filepath=filepath,
+            source_label=source_label,
+            target_label=target_label,
+            view_name=view_name,
+        )
+
+    def _load_cytoscape_network(
+        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".
@@ -98,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
@@ -127,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]
@@ -174,14 +298,53 @@ 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)
 
-    def load_cytoscape_json_network(self, filepath, source_label="source", target_label="target"):
+    @classmethod
+    def load_cytoscape_json_network(
+        cls,
+        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,
+        include_edge_weight: bool = True,
+        weight_label: str = "weight",
+    ) -> nx.Graph:
         """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.
+            include_edge_weight (bool, optional): Whether to include edge weights in calculations. Defaults to True.
+            weight_label (str, optional): Label for edge weights. Defaults to "weight".
+
+        Returns:
+            NetworkX graph: Loaded and processed network.
+        """
+        networkio = cls(
+            compute_sphere=compute_sphere,
+            surface_depth=surface_depth,
+            min_edges_per_node=min_edges_per_node,
+            include_edge_weight=include_edge_weight,
+            weight_label=weight_label,
+        )
+        return networkio._load_cytoscape_json_network(
+            filepath=filepath,
+            source_label=source_label,
+            target_label=target_label,
+        )
+
+    def _load_cytoscape_json_network(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".
@@ -193,36 +356,46 @@ class NetworkIO:
         filetype = "Cytoscape JSON"
         params.log_network(filetype=filetype, filepath=str(filepath))
         self._log_loading(filetype, filepath=filepath)
+
         # Load the Cytoscape JSON file
         with open(filepath, "r") as f:
             cyjs_data = json.load(f)
 
         # Create a graph
         G = nx.Graph()
-        # Process nodes
+        # Store node positions for later use
         node_x_positions = {}
         node_y_positions = {}
         for node in cyjs_data["elements"]["nodes"]:
             node_data = node["data"]
-            node_id = node_data["id"]
+            node_id = node_data["id_original"]
             node_x_positions[node_id] = node["position"]["x"]
             node_y_positions[node_id] = node["position"]["y"]
-            G.add_node(node_id)
-            G.nodes[node_id]["label"] = node_data.get("name", node_id)
-            G.nodes[node_id]["x"] = node["position"]["x"]
-            G.nodes[node_id]["y"] = node["position"]["y"]
 
-        # Process edges
+        # Process edges and add them to the graph
         for edge in cyjs_data["elements"]["edges"]:
             edge_data = edge["data"]
-            source = edge_data[source_label]
-            target = edge_data[target_label]
+            source = edge_data[f"{source_label}_original"]
+            target = edge_data[f"{target_label}_original"]
+            # Add the edge to the graph, optionally including weights
             if self.weight_label is not None and self.weight_label in edge_data:
                 weight = float(edge_data[self.weight_label])
                 G.add_edge(source, target, weight=weight)
             else:
                 G.add_edge(source, target)
 
+            # Ensure nodes exist in the graph and add them if not present
+            if source not in G:
+                G.add_node(source)
+            if target not in G:
+                G.add_node(target)
+
+        # Add node attributes (like label, x, y positions)
+        for node in G.nodes():
+            G.nodes[node]["label"] = node
+            G.nodes[node]["x"] = node_x_positions.get(node, 0)  # Use stored positions
+            G.nodes[node]["y"] = node_y_positions.get(node, 0)  # Use stored positions
+
         # Initialize the graph
         return self._initialize_graph(G)
 
@@ -235,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:
@@ -249,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.
@@ -289,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,
@@ -317,10 +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 length threshold: {self.edge_length_threshold}")
         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}")