risk-network 0.0.11__py3-none-any.whl → 0.0.12__py3-none-any.whl

risk/network/graph/graph.py

@@ -17,7 +17,7 @@ class Graph:
     """A class to represent a network graph and process its nodes and edges.
 
     The Graph class provides functionality to handle and manipulate a network graph,
-    including managing domains, annotations, and node significance data. It also includes methods
+    including managing domains, annotation, and node significance data. It also includes methods
     for transforming and mapping graph coordinates, as well as generating colors based on node
     significance.
     """
@@ -25,7 +25,7 @@ class Graph:
     def __init__(
         self,
         network: nx.Graph,
-        annotations: Dict[str, Any],
+        annotation: Dict[str, Any],
         neighborhoods: Dict[str, Any],
         domains: pd.DataFrame,
         trimmed_domains: pd.DataFrame,
@@ -36,7 +36,7 @@ class Graph:
 
         Args:
             network (nx.Graph): The network graph.
-            annotations (Dict[str, Any]): The annotations associated with the network.
+            annotation (Dict[str, Any]): The annotation associated with the network.
             neighborhoods (Dict[str, Any]): Neighborhood significance data.
             domains (pd.DataFrame): DataFrame containing domain data for the network nodes.
             trimmed_domains (pd.DataFrame): DataFrame containing trimmed domain data for the network nodes.
@@ -65,20 +65,24 @@ class Graph:
         # NOTE: Below this point, instance attributes (i.e., self) will be used!
         self.domain_id_to_node_labels_map = self._create_domain_id_to_node_labels_map()
         # Unfold the network's 3D coordinates to 2D and extract node coordinates
-        self.network = _unfold_sphere_to_plane(network)
-        self.node_coordinates = _extract_node_coordinates(self.network)
+        self.network = self._unfold_sphere_to_plane(network)
+        self.node_coordinates = self._extract_node_coordinates(self.network)
 
         # NOTE: Only after the above attributes are initialized, we can create the summary
-        self.summary = Summary(annotations, neighborhoods, self)
+        self.summary = Summary(annotation, neighborhoods, self)
 
-    def pop(self, domain_id: str) -> None:
-        """Remove domain ID from instance domain ID mappings. This can be useful for cleaning up
-        domain-specific mappings based on a given criterion, as domain attributes are stored and
-        accessed only in dictionaries modified by this method.
+    def pop(self, domain_id: int) -> List[str]:
+        """Remove a domain ID from the graph and return the corresponding node labels.
 
         Args:
-            key (str): The domain ID key to be removed from each mapping.
+            key (int): The domain ID key to be removed from each mapping.
+
+        Returns:
+            List[str]: A list of node labels associated with the domain ID.
         """
+        # Get the node labels associated with the domain ID
+        node_labels = self.domain_id_to_node_labels_map.get(domain_id, [])
+
         # Define the domain mappings to be updated
         domain_mappings = [
             self.domain_id_to_node_ids_map,
@@ -97,8 +101,9 @@ class Graph:
                 domain_info["domains"].remove(domain_id)
                 domain_info["significances"].pop(domain_id)
 
-    @staticmethod
-    def _create_domain_id_to_node_ids_map(domains: pd.DataFrame) -> Dict[int, Any]:
+        return node_labels
+
+    def _create_domain_id_to_node_ids_map(self, domains: pd.DataFrame) -> Dict[int, Any]:
         """Create a mapping from domains to the list of node IDs belonging to each domain.
 
         Args:
@@ -115,8 +120,9 @@ class Graph:
 
         return domain_id_to_node_ids_map
 
-    @staticmethod
-    def _create_domain_id_to_domain_terms_map(trimmed_domains: pd.DataFrame) -> Dict[int, Any]:
+    def _create_domain_id_to_domain_terms_map(
+        self, trimmed_domains: pd.DataFrame
+    ) -> Dict[int, Any]:
         """Create a mapping from domain IDs to their corresponding terms.
 
         Args:
@@ -132,8 +138,8 @@ class Graph:
             )
         )
 
-    @staticmethod
     def _create_domain_id_to_domain_info_map(
+        self,
         trimmed_domains: pd.DataFrame,
     ) -> Dict[int, Dict[str, Any]]:
         """Create a mapping from domain IDs to their corresponding full description and significance score,
@@ -163,14 +169,15 @@ class Graph:
             sorted_descriptions, sorted_scores = zip(*descriptions_and_scores)
             # Assign to the domain info map
             domain_info_map[int(domain_id)] = {
-                "full_descriptions": list(sorted_descriptions),
-                "significance_scores": list(sorted_scores),
+                "full_descriptions": sorted_descriptions,
+                "significance_scores": sorted_scores,
             }
 
         return domain_info_map
 
-    @staticmethod
-    def _create_node_id_to_domain_ids_and_significances(domains: pd.DataFrame) -> Dict[int, Dict]:
+    def _create_node_id_to_domain_ids_and_significances(
+        self, domains: pd.DataFrame
+    ) -> Dict[int, Dict]:
         """Creates a dictionary mapping each node ID to its corresponding domain IDs and significance values.
 
         Args:
@@ -216,54 +223,52 @@ class Graph:
 
         return domain_id_to_label_map
 
+    def _unfold_sphere_to_plane(self, G: nx.Graph) -> nx.Graph:
+        """Convert 3D coordinates to 2D by unfolding a sphere to a plane.
+
+        Args:
+            G (nx.Graph): A network graph with 3D coordinates. Each node should have 'x', 'y', and 'z' attributes.
 
-def _unfold_sphere_to_plane(G: nx.Graph) -> nx.Graph:
-    """Convert 3D coordinates to 2D by unfolding a sphere to a plane.
+        Returns:
+            nx.Graph: The network graph with updated 2D coordinates (only 'x' and 'y').
+        """
+        for node in G.nodes():
+            if "z" in G.nodes[node]:
+                # Extract 3D coordinates
+                x, y, z = G.nodes[node]["x"], G.nodes[node]["y"], G.nodes[node]["z"]
+                # Calculate spherical coordinates theta and phi from Cartesian coordinates
+                r = np.sqrt(x**2 + y**2 + z**2)
+                theta = np.arctan2(y, x)
+                phi = np.arccos(z / r)
+
+                # Convert spherical coordinates to 2D plane coordinates
+                unfolded_x = (theta + np.pi) / (2 * np.pi)  # Shift and normalize theta to [0, 1]
+                unfolded_x = unfolded_x + 0.5 if unfolded_x < 0.5 else unfolded_x - 0.5
+                unfolded_y = (np.pi - phi) / np.pi  # Reflect phi and normalize to [0, 1]
+                # Update network node attributes
+                G.nodes[node]["x"] = unfolded_x
+                G.nodes[node]["y"] = -unfolded_y
+                # Remove the 'z' coordinate as it's no longer needed
+                del G.nodes[node]["z"]
+
+        return G
+
+    def _extract_node_coordinates(self, G: nx.Graph) -> np.ndarray:
+        """Extract 2D coordinates of nodes from the graph.
 
-    Args:
-        G (nx.Graph): A network graph with 3D coordinates. Each node should have 'x', 'y', and 'z' attributes.
+        Args:
+            G (nx.Graph): The network graph with node coordinates.
 
-    Returns:
-        nx.Graph: The network graph with updated 2D coordinates (only 'x' and 'y').
-    """
-    for node in G.nodes():
-        if "z" in G.nodes[node]:
-            # Extract 3D coordinates
-            x, y, z = G.nodes[node]["x"], G.nodes[node]["y"], G.nodes[node]["z"]
-            # Calculate spherical coordinates theta and phi from Cartesian coordinates
-            r = np.sqrt(x**2 + y**2 + z**2)
-            theta = np.arctan2(y, x)
-            phi = np.arccos(z / r)
-
-            # Convert spherical coordinates to 2D plane coordinates
-            unfolded_x = (theta + np.pi) / (2 * np.pi)  # Shift and normalize theta to [0, 1]
-            unfolded_x = unfolded_x + 0.5 if unfolded_x < 0.5 else unfolded_x - 0.5
-            unfolded_y = (np.pi - phi) / np.pi  # Reflect phi and normalize to [0, 1]
-            # Update network node attributes
-            G.nodes[node]["x"] = unfolded_x
-            G.nodes[node]["y"] = -unfolded_y
-            # Remove the 'z' coordinate as it's no longer needed
-            del G.nodes[node]["z"]
-
-    return G
-
-
-def _extract_node_coordinates(G: nx.Graph) -> np.ndarray:
-    """Extract 2D coordinates of nodes from the graph.
-
-    Args:
-        G (nx.Graph): The network graph with node coordinates.
-
-    Returns:
-        np.ndarray: Array of node coordinates with shape (num_nodes, 2).
-    """
-    # Extract x and y coordinates from graph nodes
-    x_coords = dict(G.nodes.data("x"))
-    y_coords = dict(G.nodes.data("y"))
-    coordinates_dicts = [x_coords, y_coords]
-    # Combine x and y coordinates into a single array
-    node_positions = {
-        node: np.array([coords[node] for coords in coordinates_dicts]) for node in x_coords
-    }
-    node_coordinates = np.vstack(list(node_positions.values()))
-    return node_coordinates
+        Returns:
+            np.ndarray: Array of node coordinates with shape (num_nodes, 2).
+        """
+        # Extract x and y coordinates from graph nodes
+        x_coords = dict(G.nodes.data("x"))
+        y_coords = dict(G.nodes.data("y"))
+        coordinates_dicts = [x_coords, y_coords]
+        # Combine x and y coordinates into a single array
+        node_positions = {
+            node: np.array([coords[node] for coords in coordinates_dicts]) for node in x_coords
+        }
+        node_coordinates = np.vstack(list(node_positions.values()))
+        return node_coordinates

risk/{stats/significance.py → network/graph/stats.py}

@@ -1,6 +1,6 @@
 """
-risk/stats/significance
-~~~~~~~~~~~~~~~~~~~~~~~
+risk/network/graph/stats
+~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
 from typing import Any, Dict, Union

risk/network/graph/summary.py

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

risk/network/io.py

@@ -15,8 +15,7 @@ import networkx as nx
 import numpy as np
 import pandas as pd
 
-from risk.network.geometry import assign_edge_lengths
-from risk.log import params, logger, log_header
+from risk.log import log_header, logger, params
 
 
 class NetworkIO:
@@ -49,8 +48,8 @@ class NetworkIO:
             min_edges_per_node=min_edges_per_node,
         )
 
-    @staticmethod
-    def load_gpickle_network(
+    def load_network_gpickle(
+        self,
         filepath: str,
         compute_sphere: bool = True,
         surface_depth: float = 0.0,
@@ -72,9 +71,9 @@ class NetworkIO:
             surface_depth=surface_depth,
             min_edges_per_node=min_edges_per_node,
         )
-        return networkio._load_gpickle_network(filepath=filepath)
+        return networkio._load_network_gpickle(filepath=filepath)
 
-    def _load_gpickle_network(self, filepath: str) -> nx.Graph:
+    def _load_network_gpickle(self, filepath: str) -> nx.Graph:
         """Private method to load a network from a GPickle file.
 
         Args:
@@ -94,8 +93,8 @@ class NetworkIO:
         # Initialize the graph
         return self._initialize_graph(G)
 
-    @staticmethod
-    def load_networkx_network(
+    def load_network_networkx(
+        self,
         network: nx.Graph,
         compute_sphere: bool = True,
         surface_depth: float = 0.0,
@@ -117,9 +116,9 @@ class NetworkIO:
             surface_depth=surface_depth,
             min_edges_per_node=min_edges_per_node,
         )
-        return networkio._load_networkx_network(network=network)
+        return networkio._load_network_networkx(network=network)
 
-    def _load_networkx_network(self, network: nx.Graph) -> nx.Graph:
+    def _load_network_networkx(self, network: nx.Graph) -> nx.Graph:
         """Private method to load a NetworkX graph.
 
         Args:
@@ -138,8 +137,8 @@ class NetworkIO:
         # Initialize the graph
         return self._initialize_graph(network_copy)
 
-    @staticmethod
-    def load_cytoscape_network(
+    def load_network_cytoscape(
+        self,
         filepath: str,
         source_label: str = "source",
         target_label: str = "target",
@@ -167,14 +166,14 @@ class NetworkIO:
             surface_depth=surface_depth,
             min_edges_per_node=min_edges_per_node,
         )
-        return networkio._load_cytoscape_network(
+        return networkio._load_network_cytoscape(
             filepath=filepath,
             source_label=source_label,
             target_label=target_label,
             view_name=view_name,
         )
 
-    def _load_cytoscape_network(
+    def _load_network_cytoscape(
         self,
         filepath: str,
         source_label: str = "source",
@@ -194,6 +193,7 @@ class NetworkIO:
 
         Raises:
             ValueError: If no matching attribute metadata file is found.
+            KeyError: If the source or target label is not found in the attribute table.
         """
         filetype = "Cytoscape"
         # Log the loading of the Cytoscape file
@@ -307,8 +307,8 @@ class NetworkIO:
             if os.path.exists(tmp_dir):
                 shutil.rmtree(tmp_dir)
 
-    @staticmethod
-    def load_cytoscape_json_network(
+    def load_network_cyjs(
+        self,
         filepath: str,
         source_label: str = "source",
         target_label: str = "target",
@@ -334,13 +334,13 @@ class NetworkIO:
             surface_depth=surface_depth,
             min_edges_per_node=min_edges_per_node,
         )
-        return networkio._load_cytoscape_json_network(
+        return networkio._load_network_cyjs(
             filepath=filepath,
             source_label=source_label,
             target_label=target_label,
         )
 
-    def _load_cytoscape_json_network(self, filepath, source_label="source", target_label="target"):
+    def _load_network_cyjs(self, filepath, source_label="source", target_label="target"):
         """Private method to load a network from a Cytoscape JSON (.cyjs) file.
 
         Args:
@@ -437,7 +437,8 @@ class NetworkIO:
             G.remove_nodes_from(nodes_to_remove)
 
         # Remove isolated nodes
-        G.remove_nodes_from(nx.isolates(G))
+        isolates = list(nx.isolates(G))
+        G.remove_nodes_from(isolates)
 
         # Log the number of nodes and edges before and after cleaning
         num_final_nodes = G.number_of_nodes()
@@ -523,11 +524,153 @@ class NetworkIO:
         Args:
             G (nx.Graph): The input network graph.
         """
-        assign_edge_lengths(
+        G_transformed = self._prepare_graph_for_edge_length_assignment(
             G,
             compute_sphere=self.compute_sphere,
             surface_depth=self.surface_depth,
         )
+        self._calculate_and_set_edge_lengths(G_transformed, self.compute_sphere)
+
+    def _prepare_graph_for_edge_length_assignment(
+        self,
+        G: nx.Graph,
+        compute_sphere: bool = True,
+        surface_depth: float = 0.0,
+    ) -> nx.Graph:
+        """Prepare the graph by normalizing coordinates and optionally mapping nodes to a sphere.
+
+        Args:
+            G (nx.Graph): The input graph.
+            compute_sphere (bool): Whether to map nodes to a sphere. Defaults to True.
+            surface_depth (float): The surface depth for mapping to a sphere. Defaults to 0.0.
+
+        Returns:
+            nx.Graph: The graph with transformed coordinates.
+        """
+        self._normalize_graph_coordinates(G)
+
+        if compute_sphere:
+            self._map_to_sphere(G)
+            G_depth = self._create_depth(G, surface_depth=surface_depth)
+        else:
+            G_depth = G
+
+        return G_depth
+
+    def _calculate_and_set_edge_lengths(self, G: nx.Graph, compute_sphere: bool) -> None:
+        """Compute and assign edge lengths in the graph.
+
+        Args:
+            G (nx.Graph): The input graph.
+            compute_sphere (bool): Whether to compute spherical distances.
+        """
+
+        def compute_distance_vectorized(coords, is_sphere):
+            """Compute Euclidean or spherical distances between edges in bulk."""
+            u_coords, v_coords = coords[:, 0, :], coords[:, 1, :]
+            if is_sphere:
+                u_coords /= np.linalg.norm(u_coords, axis=1, keepdims=True)
+                v_coords /= np.linalg.norm(v_coords, axis=1, keepdims=True)
+                dot_products = np.einsum("ij,ij->i", u_coords, v_coords)
+                return np.arccos(np.clip(dot_products, -1.0, 1.0))
+            return np.linalg.norm(u_coords - v_coords, axis=1)
+
+        # Precompute edge coordinate arrays and compute distances in bulk
+        edge_data = np.array(
+            [
+                [
+                    np.array([G.nodes[u]["x"], G.nodes[u]["y"], G.nodes[u].get("z", 0)]),
+                    np.array([G.nodes[v]["x"], G.nodes[v]["y"], G.nodes[v].get("z", 0)]),
+                ]
+                for u, v in G.edges
+            ]
+        )
+        # Compute distances
+        distances = compute_distance_vectorized(edge_data, compute_sphere)
+        # Assign Euclidean or spherical distances to edges
+        for (u, v), distance in zip(G.edges, distances):
+            G.edges[u, v]["length"] = distance
+
+    def _map_to_sphere(self, G: nx.Graph) -> None:
+        """Map the x and y coordinates of graph nodes onto a 3D sphere.
+
+        Args:
+            G (nx.Graph): The input graph with nodes having 'x' and 'y' coordinates.
+        """
+        # Extract x, y coordinates as a NumPy array
+        nodes = list(G.nodes)
+        xy_coords = np.array([[G.nodes[node]["x"], G.nodes[node]["y"]] for node in nodes])
+        # Normalize coordinates between [0, 1]
+        min_vals = xy_coords.min(axis=0)
+        max_vals = xy_coords.max(axis=0)
+        normalized_xy = (xy_coords - min_vals) / (max_vals - min_vals)
+        # Convert normalized coordinates to spherical coordinates
+        theta = normalized_xy[:, 0] * np.pi * 2
+        phi = normalized_xy[:, 1] * np.pi
+        # Compute 3D Cartesian coordinates
+        x = np.sin(phi) * np.cos(theta)
+        y = np.sin(phi) * np.sin(theta)
+        z = np.cos(phi)
+        # Assign coordinates back to graph nodes in bulk
+        xyz_coords = {node: {"x": x[i], "y": y[i], "z": z[i]} for i, node in enumerate(nodes)}
+        nx.set_node_attributes(G, xyz_coords)
+
+    def _normalize_graph_coordinates(self, G: nx.Graph) -> None:
+        """Normalize the x and y coordinates of the nodes in the graph to the [0, 1] range.
+
+        Args:
+            G (nx.Graph): The input graph with nodes having 'x' and 'y' coordinates.
+        """
+        # Extract x, y coordinates from the graph nodes
+        xy_coords = np.array([[G.nodes[node]["x"], G.nodes[node]["y"]] for node in G.nodes()])
+        # Calculate min and max values for x and y
+        min_vals = np.min(xy_coords, axis=0)
+        max_vals = np.max(xy_coords, axis=0)
+        # Normalize the coordinates to [0, 1]
+        normalized_xy = (xy_coords - min_vals) / (max_vals - min_vals)
+        # Update the node coordinates with the normalized values
+        for i, node in enumerate(G.nodes()):
+            G.nodes[node]["x"], G.nodes[node]["y"] = normalized_xy[i]
+
+    def _create_depth(self, G: nx.Graph, surface_depth: float = 0.0) -> nx.Graph:
+        """Adjust the 'z' attribute of each node based on the subcluster strengths and normalized surface depth.
+
+        Args:
+            G (nx.Graph): The input graph.
+            surface_depth (float): The maximum surface depth to apply for the strongest subcluster.
+
+        Returns:
+            nx.Graph: The graph with adjusted 'z' attribute for each node.
+        """
+        if surface_depth >= 1.0:
+            surface_depth -= 1e-6  # Cap the surface depth to prevent a value of 1.0
+
+        # Compute subclusters as connected components
+        connected_components = list(nx.connected_components(G))
+        subcluster_strengths = {}
+        max_strength = 0
+        # Precompute strengths and track the maximum strength
+        for component in connected_components:
+            size = len(component)
+            max_strength = max(max_strength, size)
+            for node in component:
+                subcluster_strengths[node] = size
+
+        # Avoid repeated lookups and computations by pre-fetching node data
+        nodes = list(G.nodes(data=True))
+        node_updates = {}
+        for node, attrs in nodes:
+            strength = subcluster_strengths[node]
+            normalized_surface_depth = (strength / max_strength) * surface_depth
+            x, y, z = attrs["x"], attrs["y"], attrs["z"]
+            norm = np.sqrt(x**2 + y**2 + z**2)
+            adjusted_z = z - (z / norm) * normalized_surface_depth
+            node_updates[node] = {"z": adjusted_z}
+
+        # Batch update node attributes
+        nx.set_node_attributes(G, node_updates)
+
+        return G
 
     def _log_loading(
         self,

risk/network/plotter/__init__.py

@@ -2,5 +2,3 @@
 risk/network/plotter
 ~~~~~~~~~~~~~~~~~~~~
 """
-
-from risk.network.plotter.api import PlotterAPI

risk/network/plotter/api.py

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