risk-network 0.0.3b4__tar.gz → 0.0.4b1__tar.gz

{risk_network-0.0.3b4 → risk_network-0.0.4b1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: risk-network
-Version: 0.0.3b4
+Version: 0.0.4b1
 Summary: A Python package for biological network analysis
 Author: Ira Horecka
 Author-email: Ira Horecka <ira89@icloud.com>
@@ -684,14 +684,14 @@ 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.7
+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
 Classifier: Development Status :: 4 - Beta
-Requires-Python: >=3.7
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: ipywidgets
@@ -716,7 +716,7 @@ Requires-Dist: tqdm
 
 <p align="center">
   <a href="https://pypi.python.org/pypi/risk-network"><img src="https://img.shields.io/pypi/v/risk-network.svg" alt="pypiv"></a>
-  <a href="https://www.python.org/downloads/"><img src="https://img.shields.io/badge/python-3.7+-blue.svg" alt="Python 3.7+"></a>
+  <a href="https://www.python.org/downloads/"><img src="https://img.shields.io/badge/python-3.8+-blue.svg" alt="Python 3.8+"></a>
   <a href="https://raw.githubusercontent.com/irahorecka/chrono24/main/LICENSE"><img src="https://img.shields.io/badge/License-GPLv3-blue.svg" alt="License: GPL v3"></a>
 </p>
 
@@ -736,7 +736,7 @@ RISK is a software tool for visualizing spatial relationships in networks. It ai
 
 *Saccharomyces cerevisiae* proteins oriented by physical interactions discovered through affinity enrichment and mass spectrometry (Michaelis et al., 2023).
 
-![Metabolic Network Demo](./docs/github/network.png)
+![PPI Network Demo](./docs/github/network.png)
 
 ## Installation
 

{risk_network-0.0.3b4 → risk_network-0.0.4b1}/README.md

@@ -5,7 +5,7 @@
 
 <p align="center">
   <a href="https://pypi.python.org/pypi/risk-network"><img src="https://img.shields.io/pypi/v/risk-network.svg" alt="pypiv"></a>
-  <a href="https://www.python.org/downloads/"><img src="https://img.shields.io/badge/python-3.7+-blue.svg" alt="Python 3.7+"></a>
+  <a href="https://www.python.org/downloads/"><img src="https://img.shields.io/badge/python-3.8+-blue.svg" alt="Python 3.8+"></a>
   <a href="https://raw.githubusercontent.com/irahorecka/chrono24/main/LICENSE"><img src="https://img.shields.io/badge/License-GPLv3-blue.svg" alt="License: GPL v3"></a>
 </p>
 
@@ -25,7 +25,7 @@ RISK is a software tool for visualizing spatial relationships in networks. It ai
 
 *Saccharomyces cerevisiae* proteins oriented by physical interactions discovered through affinity enrichment and mass spectrometry (Michaelis et al., 2023).
 
-![Metabolic Network Demo](./docs/github/network.png)
+![PPI Network Demo](./docs/github/network.png)
 
 ## Installation
 

{risk_network-0.0.3b4 → risk_network-0.0.4b1}/pyproject.toml

@@ -17,7 +17,7 @@ classifiers = [
     "License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)",
     "Operating System :: OS Independent",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8",
     "Programming Language :: Python :: 3 :: Only",
     "Topic :: Scientific/Engineering :: Bio-Informatics",
     "Topic :: Scientific/Engineering :: Information Analysis",
@@ -41,4 +41,4 @@ dependencies = [
     "threadpoolctl",
     "tqdm",
 ]
-requires-python = ">=3.7"
+requires-python = ">=3.8"

{risk_network-0.0.3b4 → risk_network-0.0.4b1}/risk/__init__.py

@@ -10,4 +10,4 @@ RISK: RISK Infers Spatial Kinship
 
 from risk.risk import RISK
 
-__version__ = "0.0.3-beta.4"
+__version__ = "0.0.4-beta.1"

{risk_network-0.0.3b4 → risk_network-0.0.4b1}/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
     ]

{risk_network-0.0.3b4 → risk_network-0.0.4b1}/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_network-0.0.3b4 → risk_network-0.0.4b1}/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)

{risk_network-0.0.3b4 → risk_network-0.0.4b1}/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-0.0.3b4 → risk_network-0.0.4b1}/risk/network/io.py

@@ -29,25 +29,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 +104,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 +148,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".
@@ -179,9 +296,49 @@ class NetworkIO:
             for dirname in cys_dirnames:
                 shutil.rmtree(dirname)
 
-    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 +350,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)
 
@@ -320,7 +487,6 @@ class NetworkIO:
         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}")