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

risk/{network/io.py → _network/_io.py}

@@ -1,6 +1,6 @@
 """
-risk/network/io
-~~~~~~~~~~~~~~~
+risk/_network/_io
+~~~~~~~~~~~~~~~~~
 """
 
 import copy
@@ -15,111 +15,191 @@ import networkx as nx
 import numpy as np
 import pandas as pd
 
-from risk.log import log_header, logger, params
+from .._log import log_header, logger, params
 
 
-class NetworkIO:
-    """A class for loading, processing, and managing network data.
-
-    The NetworkIO class provides methods to load network data from various formats (e.g., GPickle, NetworkX)
-    and process the network by adjusting node coordinates, calculating edge lengths, and validating graph structure.
+class NetworkAPI:
+    """
+    Public-facing interface for loading and initializing network data.
+    Delegates to the NetworkIO worker class for actual I/O and processing.
     """
 
-    def __init__(
+    def load_network_gpickle(
         self,
+        filepath: str,
         compute_sphere: bool = True,
         surface_depth: float = 0.0,
         min_edges_per_node: int = 0,
-    ):
-        """Initialize the NetworkIO class.
+    ) -> nx.Graph:
+        """
+        Load a network from a GPickle file via NetworkIO.
 
         Args:
-            compute_sphere (bool, optional): Whether to map nodes to a sphere. Defaults to True.
-            surface_depth (float, optional): Surface depth for the sphere. Defaults to 0.0.
-            min_edges_per_node (int, optional): Minimum number of edges per node. Defaults to 0.
+            filepath (str): Path to the GPickle file.
+            compute_sphere (bool, optional): Override or use API default. Defaults to True.
+            surface_depth (float, optional): Override or use API default. Defaults to 0.0.
+            min_edges_per_node (int, optional): Override or use API default. Defaults to 0.
+        Returns:
+            nx.Graph: Loaded and processed network.
         """
-        self.compute_sphere = compute_sphere
-        self.surface_depth = surface_depth
-        self.min_edges_per_node = min_edges_per_node
-        # Log the initialization of the NetworkIO class
-        params.log_network(
+        io = NetworkIO(
             compute_sphere=compute_sphere,
             surface_depth=surface_depth,
             min_edges_per_node=min_edges_per_node,
         )
+        return io.load_network_gpickle(filepath=filepath)
 
-    def load_network_gpickle(
+    def load_network_networkx(
         self,
-        filepath: str,
+        network: nx.Graph,
         compute_sphere: bool = True,
         surface_depth: float = 0.0,
         min_edges_per_node: int = 0,
     ) -> nx.Graph:
-        """Load a network from a GPickle file.
+        """
+        Load a NetworkX graph via NetworkIO.
 
         Args:
-            filepath (str): Path to the GPickle file.
-            compute_sphere (bool, optional): Whether to map nodes to a sphere. Defaults to True.
-            surface_depth (float, optional): Surface depth for the sphere. Defaults to 0.0.
-            min_edges_per_node (int, optional): Minimum number of edges per node. Defaults to 0.
+            network (nx.Graph): A NetworkX graph object.
+            compute_sphere (bool, optional): Override or use API default. Defaults to True.
+            surface_depth (float, optional): Override or use API default. Defaults to 0.0.
+            min_edges_per_node (int, optional): Override or use API default. Defaults to 0.
+        Returns:
+            nx.Graph: Processed network.
+        """
+        io = NetworkIO(
+            compute_sphere=compute_sphere,
+            surface_depth=surface_depth,
+            min_edges_per_node=min_edges_per_node,
+        )
+        return io.load_network_networkx(network=network)
 
+    def load_network_cytoscape(
+        self,
+        filepath: str,
+        source_label: str = "source",
+        target_label: str = "target",
+        view_name: str = "",
+        compute_sphere: bool = True,
+        surface_depth: float = 0.0,
+        min_edges_per_node: int = 0,
+    ) -> nx.Graph:
+        """
+        Load a network from a Cytoscape file via NetworkIO.
+
+        Args:
+            filepath (str): Path to the Cytoscape file.
+            source_label (str, optional): Source node label. Defaults to "source".
+            target_label (str, optional): Target node label. Defaults to "target".
+            view_name (str, optional): Specific view name to load. Defaults to "".
+            compute_sphere (bool, optional): Override or use API default. Defaults to True.
+            surface_depth (float, optional): Override or use API default. Defaults to 0.0.
+            min_edges_per_node (int, optional): Override or use API default. Defaults to 0.
         Returns:
             nx.Graph: Loaded and processed network.
         """
-        networkio = NetworkIO(
+        io = NetworkIO(
             compute_sphere=compute_sphere,
             surface_depth=surface_depth,
             min_edges_per_node=min_edges_per_node,
         )
-        return networkio._load_network_gpickle(filepath=filepath)
+        return io.load_network_cytoscape(
+            filepath=filepath,
+            source_label=source_label,
+            target_label=target_label,
+            view_name=view_name,
+        )
 
-    def _load_network_gpickle(self, filepath: str) -> nx.Graph:
-        """Private method to load a network from a GPickle file.
+    def load_network_cyjs(
+        self,
+        filepath: str,
+        source_label: str = "source",
+        target_label: str = "target",
+        compute_sphere: bool = True,
+        surface_depth: float = 0.0,
+        min_edges_per_node: int = 0,
+    ) -> nx.Graph:
+        """
+        Load a network from a Cytoscape JSON (.cyjs) file via NetworkIO.
 
         Args:
-            filepath (str): Path to the GPickle file.
-
+            filepath (str): Path to the Cytoscape JSON file.
+            source_label (str, optional): Source node label. Defaults to "source".
+            target_label (str, optional): Target node label. Defaults to "target".
+            compute_sphere (bool, optional): Override or use API default. Defaults to True.
+            surface_depth (float, optional): Override or use API default. Defaults to 0.0.
+            min_edges_per_node (int, optional): Override or use API default. Defaults to 0.
         Returns:
             nx.Graph: Loaded and processed network.
         """
-        filetype = "GPickle"
-        # Log the loading of the GPickle file
-        params.log_network(filetype=filetype, filepath=filepath)
-        self._log_loading_network(filetype, filepath=filepath)
+        io = NetworkIO(
+            compute_sphere=compute_sphere,
+            surface_depth=surface_depth,
+            min_edges_per_node=min_edges_per_node,
+        )
+        return io.load_network_cyjs(
+            filepath=filepath,
+            source_label=source_label,
+            target_label=target_label,
+        )
 
-        with open(filepath, "rb") as f:
-            G = pickle.load(f)
 
-        # Initialize the graph
-        return self._initialize_graph(G)
+class NetworkIO:
+    """
+    A class for loading, processing, and managing network data.
 
-    def load_network_networkx(
+    The NetworkIO class provides methods to load network data from various formats (e.g., GPickle, NetworkX)
+    and process the network by adjusting node coordinates, calculating edge lengths, and validating graph structure.
+    """
+
+    def __init__(
         self,
-        network: nx.Graph,
         compute_sphere: bool = True,
         surface_depth: float = 0.0,
         min_edges_per_node: int = 0,
-    ) -> nx.Graph:
-        """Load a NetworkX graph.
+    ):
+        """
+        Initialize the NetworkIO class.
 
         Args:
-            network (nx.Graph): A NetworkX graph object.
             compute_sphere (bool, optional): Whether to map nodes to a sphere. Defaults to True.
             surface_depth (float, optional): Surface depth for the sphere. Defaults to 0.0.
-            min_edges_per_node (int, optional): Minimum number of edges per node. Defaults to 0.
-
-        Returns:
-            nx.Graph: Loaded and processed network.
+            min_edges_per_node (int, optional): Minimum number of edges per node (k-core threshold). Defaults to 0.
         """
-        networkio = NetworkIO(
+        self.compute_sphere = compute_sphere
+        self.surface_depth = surface_depth
+        self.min_edges_per_node = min_edges_per_node
+        # Log the initialization of the NetworkIO class
+        params.log_network(
             compute_sphere=compute_sphere,
             surface_depth=surface_depth,
             min_edges_per_node=min_edges_per_node,
         )
-        return networkio._load_network_networkx(network=network)
 
-    def _load_network_networkx(self, network: nx.Graph) -> nx.Graph:
-        """Private method to load a NetworkX graph.
+    def load_network_gpickle(self, filepath: str) -> nx.Graph:
+        """
+        Load a network from a GPickle file.
+
+        Args:
+            filepath (str): Path to the GPickle file.
+
+        Returns:
+            nx.Graph: Loaded and processed network.
+        """
+        filetype = "GPickle"
+        # Log the loading of the GPickle file
+        params.log_network(filetype=filetype, filepath=filepath)
+        self._log_loading_network(filetype, filepath=filepath)
+
+        with open(filepath, "rb") as f:
+            G = pickle.load(f)
+
+        # Initialize the graph
+        return self._initialize_graph(G)
+
+    def load_network_networkx(self, network: nx.Graph) -> nx.Graph:
+        """
+        Load a NetworkX graph.
 
         Args:
             network (nx.Graph): A NetworkX graph object.
@@ -143,44 +223,9 @@ class NetworkIO:
         source_label: str = "source",
         target_label: str = "target",
         view_name: str = "",
-        compute_sphere: bool = True,
-        surface_depth: float = 0.0,
-        min_edges_per_node: int = 0,
     ) -> nx.Graph:
-        """Load a network from a Cytoscape file.
-
-        Args:
-            filepath (str): Path to the Cytoscape file.
-            source_label (str, optional): Source node label. Defaults to "source".
-            target_label (str, optional): Target node label. Defaults to "target".
-            view_name (str, optional): Specific view name to load. Defaults to "".
-            compute_sphere (bool, optional): Whether to map nodes to a sphere. Defaults to True.
-            surface_depth (float, optional): Surface depth for the sphere. Defaults to 0.0.
-            min_edges_per_node (int, optional): Minimum number of edges per node. Defaults to 0.
-
-        Returns:
-            nx.Graph: Loaded and processed network.
         """
-        networkio = NetworkIO(
-            compute_sphere=compute_sphere,
-            surface_depth=surface_depth,
-            min_edges_per_node=min_edges_per_node,
-        )
-        return networkio._load_network_cytoscape(
-            filepath=filepath,
-            source_label=source_label,
-            target_label=target_label,
-            view_name=view_name,
-        )
-
-    def _load_network_cytoscape(
-        self,
-        filepath: str,
-        source_label: str = "source",
-        target_label: str = "target",
-        view_name: str = "",
-    ) -> nx.Graph:
-        """Private method to load a network from a Cytoscape file.
+        Load a network from a Cytoscape file.
 
         Args:
             filepath (str): Path to the Cytoscape file.
@@ -307,41 +352,9 @@ class NetworkIO:
             if os.path.exists(tmp_dir):
                 shutil.rmtree(tmp_dir)
 
-    def load_network_cyjs(
-        self,
-        filepath: str,
-        source_label: str = "source",
-        target_label: str = "target",
-        compute_sphere: bool = True,
-        surface_depth: float = 0.0,
-        min_edges_per_node: int = 0,
-    ) -> nx.Graph:
-        """Load a network from a Cytoscape JSON (.cyjs) file.
-
-        Args:
-            filepath (str): Path to the Cytoscape JSON file.
-            source_label (str, optional): Source node label. Default is "source".
-            target_label (str, optional): Target node label. Default is "target".
-            compute_sphere (bool, optional): Whether to map nodes to a sphere. Defaults to True.
-            surface_depth (float, optional): Surface depth for the sphere. Defaults to 0.0.
-            min_edges_per_node (int, optional): Minimum number of edges per node. Defaults to 0.
-
-        Returns:
-            NetworkX graph: Loaded and processed network.
+    def load_network_cyjs(self, filepath, source_label="source", target_label="target"):
         """
-        networkio = NetworkIO(
-            compute_sphere=compute_sphere,
-            surface_depth=surface_depth,
-            min_edges_per_node=min_edges_per_node,
-        )
-        return networkio._load_network_cyjs(
-            filepath=filepath,
-            source_label=source_label,
-            target_label=target_label,
-        )
-
-    def _load_network_cyjs(self, filepath, source_label="source", target_label="target"):
-        """Private method to load a network from a Cytoscape JSON (.cyjs) file.
+        Load a network from a Cytoscape JSON (.cyjs) file.
 
         Args:
             filepath (str): Path to the Cytoscape JSON file.
@@ -396,7 +409,8 @@ class NetworkIO:
         return self._initialize_graph(G)
 
     def _initialize_graph(self, G: nx.Graph) -> nx.Graph:
-        """Initialize the graph by processing and validating its nodes and edges.
+        """
+        Initialize the graph by processing and validating its nodes and edges.
 
         Args:
             G (nx.Graph): The input NetworkX graph.
@@ -414,7 +428,8 @@ class NetworkIO:
         return G
 
     def _remove_invalid_graph_properties(self, G: nx.Graph) -> None:
-        """Remove invalid properties from the graph, including self-loops, nodes with fewer edges than
+        """
+        Remove invalid properties from the graph, including self-loops, nodes with fewer edges than
         the threshold, and isolated nodes.
 
         Args:
@@ -425,20 +440,14 @@ class NetworkIO:
         num_initial_edges = G.number_of_edges()
         # Remove self-loops to ensure correct edge count
         G.remove_edges_from(nx.selfloop_edges(G))
-        # Iteratively remove nodes with fewer edges than the threshold
-        while True:
-            nodes_to_remove = [
-                node
-                for node, degree in dict(G.degree()).items()
-                if degree < self.min_edges_per_node
-            ]
-            if not nodes_to_remove:
-                break  # Exit loop if no nodes meet the condition
-            G.remove_nodes_from(nodes_to_remove)
-
-        # Remove isolated nodes
-        isolates = list(nx.isolates(G))
-        G.remove_nodes_from(isolates)
+        # Apply canonical node k-core pruning if requested
+        if self.min_edges_per_node > 0:
+            # networkx.k_core returns a subgraph; to preserve in-place behavior, copy back
+            core = nx.k_core(G, k=self.min_edges_per_node)
+            # Rebuild G in-place to keep external references valid
+            G.clear()
+            G.add_nodes_from(core.nodes(data=True))
+            G.add_edges_from(core.edges(data=True))
 
         # Log the number of nodes and edges before and after cleaning
         num_final_nodes = G.number_of_nodes()
@@ -449,7 +458,8 @@ class NetworkIO:
         logger.debug(f"Final edge count: {num_final_edges}")
 
     def _assign_edge_weights(self, G: nx.Graph) -> None:
-        """Assign default edge weights to the graph.
+        """
+        Assign default edge weights to the graph.
 
         Args:
             G (nx.Graph): A NetworkX graph object.
@@ -459,7 +469,8 @@ class NetworkIO:
         nx.set_edge_attributes(G, default_weight, "weight")
 
     def _validate_nodes(self, G: nx.Graph) -> None:
-        """Validate the graph structure and attributes with attribute fallback for positions and labels.
+        """
+        Validate the graph structure and attributes with attribute fallback for positions and labels.
 
         Args:
             G (nx.Graph): A NetworkX graph object.
@@ -519,7 +530,8 @@ class NetworkIO:
             )
 
     def _assign_edge_lengths(self, G: nx.Graph) -> None:
-        """Prepare the network by adjusting surface depth and calculating edge lengths.
+        """
+        Prepare the network by adjusting surface depth and calculating edge lengths.
 
         Args:
             G (nx.Graph): The input network graph.
@@ -537,7 +549,8 @@ class NetworkIO:
         compute_sphere: bool = True,
         surface_depth: float = 0.0,
     ) -> nx.Graph:
-        """Prepare the graph by normalizing coordinates and optionally mapping nodes to a sphere.
+        """
+        Prepare the graph by normalizing coordinates and optionally mapping nodes to a sphere.
 
         Args:
             G (nx.Graph): The input graph.
@@ -558,7 +571,8 @@ class NetworkIO:
         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.
+        """
+        Compute and assign edge lengths in the graph.
 
         Args:
             G (nx.Graph): The input graph.
@@ -592,7 +606,8 @@ class NetworkIO:
             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.
+        """
+        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.
@@ -616,7 +631,8 @@ class NetworkIO:
         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.
+        """
+        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.
@@ -633,7 +649,8 @@ class NetworkIO:
             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.
+        """
+        Adjust the 'z' attribute of each node based on the subcluster strengths and normalized surface depth.
 
         Args:
             G (nx.Graph): The input graph.
@@ -677,7 +694,8 @@ class NetworkIO:
         filetype: str,
         filepath: str = "",
     ) -> None:
-        """Log the loading of the network with relevant parameters.
+        """
+        Log the loading of the network with relevant parameters.
 
         Args:
             filetype (str): The type of the file being loaded (e.g., 'CSV', 'JSON').

risk/_network/_plotter/__init__.py

@@ -0,0 +1,6 @@
+"""
+risk/_network/_plotter
+~~~~~~~~~~~~~~~~~~~~~~
+"""
+
+from ._api import PlotterAPI

risk/{network/plotter/api.py → _network/_plotter/_api.py}

@@ -1,26 +1,24 @@
 """
-risk/network/plotter/api
-~~~~~~~~~~~~~~~~~~~~~~~~
+risk/_network/_plotter/_api
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
 from typing import List, Tuple, Union
 
 import numpy as np
 
-from risk.log import log_header
-from risk.network.graph.graph import Graph
-from risk.network.plotter.plotter import Plotter
+from ..._log import log_header
+from .._graph import Graph
+from ._plotter import Plotter
 
 
 class PlotterAPI:
-    """Handles the loading of network plotter objects.
+    """
+    Handles the loading of network plotter objects.
 
     The PlotterAPI class provides methods to load and configure Plotter objects for plotting network graphs.
     """
 
-    def __init__(self) -> None:
-        pass
-
     def load_plotter(
         self,
         graph: Graph,
@@ -29,7 +27,8 @@ class PlotterAPI:
         background_alpha: Union[float, None] = 1.0,
         pad: float = 0.3,
     ) -> Plotter:
-        """Get a Plotter object for plotting.
+        """
+        Get a Plotter object for plotting.
 
         Args:
             graph (Graph): The graph to plot.

risk/{network/plotter/canvas.py → _network/_plotter/_canvas.py}

@@ -1,6 +1,6 @@
 """
-risk/network/plotter/canvas
-~~~~~~~~~~~~~~~~~~~~~~~~~~~
+risk/_network/_plotter/_canvas
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
 from typing import List, Tuple, Union
@@ -8,17 +8,18 @@ from typing import List, Tuple, Union
 import matplotlib.pyplot as plt
 import numpy as np
 
-from risk.log import params
-from risk.network.graph.graph import Graph
-from risk.network.plotter.utils.colors import to_rgba
-from risk.network.plotter.utils.layout import calculate_bounding_box
+from ..._log import params
+from .._graph import Graph
+from ._utils._colors import to_rgba
+from ._utils._layout import calculate_bounding_box
 
 
 class Canvas:
     """A class for laying out the canvas in a network graph."""
 
     def __init__(self, graph: Graph, ax: plt.Axes) -> None:
-        """Initialize the Canvas with a Graph and axis for plotting.
+        """
+        Initialize the Canvas with a Graph and axis for plotting.
 
         Args:
             graph (Graph): The Graph object containing the network data.
@@ -41,7 +42,8 @@ class Canvas:
         title_space_offset: float = 0.075,
         subtitle_offset: float = 0.025,
     ) -> None:
-        """Plot title and subtitle on the network graph with customizable parameters.
+        """
+        Plot title and subtitle on the network graph with customizable parameters.
 
         Args:
             title (str, optional): Title of the plot. Defaults to None.
@@ -122,7 +124,8 @@ class Canvas:
         outline_alpha: Union[float, None] = 1.0,
         fill_alpha: Union[float, None] = 0.0,
     ) -> None:
-        """Plot a circle around the network graph to represent the network perimeter.
+        """
+        Plot a circle around the network graph to represent the network perimeter.
 
         Args:
             scale (float, optional): Scaling factor for the perimeter diameter. Defaults to 1.0.
@@ -257,7 +260,8 @@ class Canvas:
         center_offset_x: float = 0.0,
         center_offset_y: float = 0.0,
     ) -> Tuple[float, float]:
-        """Calculate the adjusted center for the network perimeter circle based on user-defined offsets.
+        """
+        Calculate the adjusted center for the network perimeter circle based on user-defined offsets.
 
         Args:
             center (Tuple[float, float]): Original center coordinates of the network graph.

risk/{network/plotter/contour.py → _network/_plotter/_contour.py}

@@ -1,6 +1,6 @@
 """
-risk/network/plotter/contour
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+risk/_network/_plotter/_contour
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
 from typing import Any, Dict, List, Tuple, Union
@@ -11,16 +11,17 @@ from scipy import linalg
 from scipy.ndimage import label
 from scipy.stats import gaussian_kde
 
-from risk.log import logger, params
-from risk.network.graph.graph import Graph
-from risk.network.plotter.utils.colors import get_annotated_domain_colors, to_rgba
+from ..._log import logger, params
+from .._graph import Graph
+from ._utils import get_annotated_domain_colors, to_rgba
 
 
 class Contour:
     """Class to generate Kernel Density Estimate (KDE) contours for nodes in a network graph."""
 
     def __init__(self, graph: Graph, ax: plt.Axes) -> None:
-        """Initialize the Contour with a Graph and axis for plotting.
+        """
+        Initialize the Contour with a Graph and axis for plotting.
 
         Args:
             graph (Graph): The Graph object containing the network data.
@@ -40,7 +41,8 @@ class Contour:
         alpha: Union[float, None] = 1.0,
         fill_alpha: Union[float, None] = None,
     ) -> None:
-        """Draw KDE contours for nodes in various domains of a network graph, highlighting areas of high density.
+        """
+        Draw KDE contours for nodes in various domains of a network graph, highlighting areas of high density.
 
         Args:
             levels (int, optional): Number of contour levels to plot. Defaults to 5.
@@ -105,7 +107,8 @@ class Contour:
         alpha: Union[float, None] = 1.0,
         fill_alpha: Union[float, None] = None,
     ) -> None:
-        """Plot a subcontour for a given set of nodes or a list of node sets using Kernel Density Estimation (KDE).
+        """
+        Plot a subcontour for a given set of nodes or a list of node sets using Kernel Density Estimation (KDE).
 
         Args:
             nodes (List, Tuple, or np.ndarray): List of node labels or list of lists of node labels to plot the contour for.
@@ -179,7 +182,8 @@ class Contour:
         linewidth: float = 1.5,
         fill_alpha: Union[float, None] = 0.2,
     ) -> None:
-        """Draw a Kernel Density Estimate (KDE) contour plot for a set of nodes on a given axis.
+        """
+        Draw a Kernel Density Estimate (KDE) contour plot for a set of nodes on a given axis.
 
         Args:
             ax (plt.Axes): The axis to draw the contour on.
@@ -283,7 +287,8 @@ class Contour:
         ids_to_colors: Union[Dict[int, Any], None] = None,
         random_seed: int = 888,
     ) -> List[Tuple]:
-        """Get colors for the contours based on node annotation or a specified colormap.
+        """
+        Get colors for the contours based on node annotation or a specified colormap.
 
         Args:
             cmap (str, optional): Name of the colormap to use for generating contour colors. Defaults to "gist_rainbow".
@@ -317,7 +322,8 @@ class Contour:
         )
 
     def _is_connected(self, z: np.ndarray) -> bool:
-        """Determine if a thresholded grid represents a single, connected component.
+        """
+        Determine if a thresholded grid represents a single, connected component.
 
         Args:
             z (np.ndarray): A binary grid where the component connectivity is evaluated.