risk-network 0.0.8b7__py3-none-any.whl → 0.0.8b9__py3-none-any.whl

risk/network/plot/network.py

@@ -0,0 +1,269 @@
+"""
+risk/network/plot/network
+~~~~~~~~~~~~~~~~~~~~~~~~~
+"""
+
+from typing import Any, List, Tuple, Union
+
+import networkx as nx
+import numpy as np
+
+from risk.log import params
+from risk.network.graph import NetworkGraph
+from risk.network.plot.utils import to_rgba
+
+
+class Network:
+    """Class for plotting nodes and edges in a network graph."""
+
+    def __init__(self, graph: NetworkGraph, ax: Any = None) -> None:
+        """Initialize the NetworkPlotter class.
+
+        Args:
+            graph (NetworkGraph): The network data and attributes to be visualized.
+            ax (Any, optional): Axes object to plot the network graph. Defaults to None.
+        """
+        self.graph = graph
+        self.ax = ax
+
+    def plot_network(
+        self,
+        node_size: Union[int, np.ndarray] = 50,
+        node_shape: str = "o",
+        node_edgewidth: float = 1.0,
+        edge_width: float = 1.0,
+        node_color: Union[str, List, Tuple, np.ndarray] = "white",
+        node_edgecolor: Union[str, List, Tuple, np.ndarray] = "black",
+        edge_color: Union[str, List, Tuple, np.ndarray] = "black",
+        node_alpha: Union[float, None] = 1.0,
+        edge_alpha: Union[float, None] = 1.0,
+    ) -> None:
+        """Plot the network graph with customizable node colors, sizes, edge widths, and node edge widths.
+
+        Args:
+            node_size (int or np.ndarray, optional): Size of the nodes. Can be a single integer or an array of sizes. Defaults to 50.
+            node_shape (str, optional): Shape of the nodes. Defaults to "o".
+            node_edgewidth (float, optional): Width of the node edges. Defaults to 1.0.
+            edge_width (float, optional): Width of the edges. Defaults to 1.0.
+            node_color (str, list, tuple, or np.ndarray, optional): Color of the nodes. Can be a single color or an array of colors.
+                Defaults to "white".
+            node_edgecolor (str, list, tuple, or np.ndarray, optional): Color of the node edges. Defaults to "black".
+            edge_color (str, list, tuple, or np.ndarray, optional): Color of the edges. Defaults to "black".
+            node_alpha (float, None, optional): Alpha value (transparency) for the nodes. If provided, it overrides any existing alpha
+                values found in node_color. Defaults to 1.0. Annotated node_color alphas will override this value.
+            edge_alpha (float, None, optional): Alpha value (transparency) for the edges. If provided, it overrides any existing alpha
+                values found in edge_color. Defaults to 1.0.
+        """
+        # Log the plotting parameters
+        params.log_plotter(
+            network_node_size=(
+                "custom" if isinstance(node_size, np.ndarray) else node_size
+            ),  # np.ndarray usually indicates custom sizes
+            network_node_shape=node_shape,
+            network_node_edgewidth=node_edgewidth,
+            network_edge_width=edge_width,
+            network_node_color=(
+                "custom" if isinstance(node_color, np.ndarray) else node_color
+            ),  # np.ndarray usually indicates custom colors
+            network_node_edgecolor=node_edgecolor,
+            network_edge_color=edge_color,
+            network_node_alpha=node_alpha,
+            network_edge_alpha=edge_alpha,
+        )
+
+        # Convert colors to RGBA using the to_rgba helper function
+        # If node_colors was generated using get_annotated_node_colors, its alpha values will override node_alpha
+        node_color = to_rgba(
+            color=node_color, alpha=node_alpha, num_repeats=len(self.graph.network.nodes)
+        )
+        node_edgecolor = to_rgba(
+            color=node_edgecolor, alpha=1.0, num_repeats=len(self.graph.network.nodes)
+        )
+        edge_color = to_rgba(
+            color=edge_color, alpha=edge_alpha, num_repeats=len(self.graph.network.edges)
+        )
+
+        # Extract node coordinates from the network graph
+        node_coordinates = self.graph.node_coordinates
+
+        # Draw the nodes of the graph
+        nx.draw_networkx_nodes(
+            self.graph.network,
+            pos=node_coordinates,
+            node_size=node_size,
+            node_shape=node_shape,
+            node_color=node_color,
+            edgecolors=node_edgecolor,
+            linewidths=node_edgewidth,
+            ax=self.ax,
+        )
+        # Draw the edges of the graph
+        nx.draw_networkx_edges(
+            self.graph.network,
+            pos=node_coordinates,
+            width=edge_width,
+            edge_color=edge_color,
+            ax=self.ax,
+        )
+
+    def plot_subnetwork(
+        self,
+        nodes: Union[List, Tuple, np.ndarray],
+        node_size: Union[int, np.ndarray] = 50,
+        node_shape: str = "o",
+        node_edgewidth: float = 1.0,
+        edge_width: float = 1.0,
+        node_color: Union[str, List, Tuple, np.ndarray] = "white",
+        node_edgecolor: Union[str, List, Tuple, np.ndarray] = "black",
+        edge_color: Union[str, List, Tuple, np.ndarray] = "black",
+        node_alpha: Union[float, None] = None,
+        edge_alpha: Union[float, None] = None,
+    ) -> None:
+        """Plot a subnetwork of selected nodes with customizable node and edge attributes.
+
+        Args:
+            nodes (list, tuple, or np.ndarray): List of node labels to include in the subnetwork. Accepts nested lists.
+            node_size (int or np.ndarray, optional): Size of the nodes. Can be a single integer or an array of sizes. Defaults to 50.
+            node_shape (str, optional): Shape of the nodes. Defaults to "o".
+            node_edgewidth (float, optional): Width of the node edges. Defaults to 1.0.
+            edge_width (float, optional): Width of the edges. Defaults to 1.0.
+            node_color (str, list, tuple, or np.ndarray, optional): Color of the nodes. Defaults to "white".
+            node_edgecolor (str, list, tuple, or np.ndarray, optional): Color of the node edges. Defaults to "black".
+            edge_color (str, list, tuple, or np.ndarray, optional): Color of the edges. Defaults to "black".
+            node_alpha (float, None, optional): Transparency for the nodes. If provided, it overrides any existing alpha values
+                found in node_color. Defaults to 1.0.
+            edge_alpha (float, None, optional): Transparency for the edges. If provided, it overrides any existing alpha values
+                found in node_color. Defaults to 1.0.
+
+        Raises:
+            ValueError: If no valid nodes are found in the network graph.
+        """
+        # Flatten nested lists of nodes, if necessary
+        if any(isinstance(item, (list, tuple, np.ndarray)) for item in nodes):
+            nodes = [node for sublist in nodes for node in sublist]
+
+        # Filter to get node IDs and their coordinates
+        node_ids = [
+            self.graph.node_label_to_node_id_map.get(node)
+            for node in nodes
+            if node in self.graph.node_label_to_node_id_map
+        ]
+        if not node_ids:
+            raise ValueError("No nodes found in the network graph.")
+
+        # Check if node_color is a single color or a list of colors
+        if not isinstance(node_color, (str, tuple, np.ndarray)):
+            node_color = [
+                node_color[nodes.index(node)]
+                for node in nodes
+                if node in self.graph.node_label_to_node_id_map
+            ]
+
+        # Convert colors to RGBA using the to_rgba helper function
+        node_color = to_rgba(color=node_color, alpha=node_alpha, num_repeats=len(node_ids))
+        node_edgecolor = to_rgba(color=node_edgecolor, alpha=1.0, num_repeats=len(node_ids))
+        edge_color = to_rgba(
+            color=edge_color, alpha=edge_alpha, num_repeats=len(self.graph.network.edges)
+        )
+
+        # Get the coordinates of the filtered nodes
+        node_coordinates = {node_id: self.graph.node_coordinates[node_id] for node_id in node_ids}
+
+        # Draw the nodes in the subnetwork
+        nx.draw_networkx_nodes(
+            self.graph.network,
+            pos=node_coordinates,
+            nodelist=node_ids,
+            node_size=node_size,
+            node_shape=node_shape,
+            node_color=node_color,
+            edgecolors=node_edgecolor,
+            linewidths=node_edgewidth,
+            ax=self.ax,
+        )
+        # Draw the edges between the specified nodes in the subnetwork
+        subgraph = self.graph.network.subgraph(node_ids)
+        nx.draw_networkx_edges(
+            subgraph,
+            pos=node_coordinates,
+            width=edge_width,
+            edge_color=edge_color,
+            ax=self.ax,
+        )
+
+    def get_annotated_node_colors(
+        self,
+        cmap: str = "gist_rainbow",
+        color: Union[str, None] = None,
+        min_scale: float = 0.8,
+        max_scale: float = 1.0,
+        scale_factor: float = 1.0,
+        alpha: Union[float, None] = 1.0,
+        nonenriched_color: Union[str, List, Tuple, np.ndarray] = "white",
+        nonenriched_alpha: Union[float, None] = 1.0,
+        random_seed: int = 888,
+    ) -> np.ndarray:
+        """Adjust the colors of nodes in the network graph based on enrichment.
+
+        Args:
+            cmap (str, optional): Colormap to use for coloring the nodes. Defaults to "gist_rainbow".
+            color (str or None, optional): Color to use for the nodes. If None, the colormap will be used. Defaults to None.
+            min_scale (float, optional): Minimum scale for color intensity. Defaults to 0.8.
+            max_scale (float, optional): Maximum scale for color intensity. Defaults to 1.0.
+            scale_factor (float, optional): Factor for adjusting the color scaling intensity. Defaults to 1.0.
+            alpha (float, None, optional): Alpha value for enriched nodes. If provided, it overrides any existing alpha values
+                found in color. Defaults to 1.0.
+            nonenriched_color (str, list, tuple, or np.ndarray, optional): Color for non-enriched nodes. Defaults to "white".
+            nonenriched_alpha (float, None, optional): Alpha value for non-enriched nodes. If provided, it overrides any existing
+                alpha values found in nonenriched_color. Defaults to 1.0.
+            random_seed (int, optional): Seed for random number generation. Defaults to 888.
+
+        Returns:
+            np.ndarray: Array of RGBA colors adjusted for enrichment status.
+        """
+        # Get the initial domain colors for each node, which are returned as RGBA
+        network_colors = self.graph.get_domain_colors(
+            cmap=cmap,
+            color=color,
+            min_scale=min_scale,
+            max_scale=max_scale,
+            scale_factor=scale_factor,
+            random_seed=random_seed,
+        )
+        # Apply the alpha value for enriched nodes
+        network_colors[:, 3] = alpha  # Apply the alpha value to the enriched nodes' A channel
+        # Convert the non-enriched color to RGBA using the to_rgba helper function
+        nonenriched_color = to_rgba(color=nonenriched_color, alpha=nonenriched_alpha)
+        # Adjust node colors: replace any fully black nodes (RGB == 0) with the non-enriched color and its alpha
+        adjusted_network_colors = np.where(
+            np.all(network_colors[:, :3] == 0, axis=1, keepdims=True),  # Check RGB values only
+            np.array(nonenriched_color),  # Apply the non-enriched color with alpha
+            network_colors,  # Keep the original colors for enriched nodes
+        )
+        return adjusted_network_colors
+
+    def get_annotated_node_sizes(
+        self, enriched_size: int = 50, nonenriched_size: int = 25
+    ) -> np.ndarray:
+        """Adjust the sizes of nodes in the network graph based on whether they are enriched or not.
+
+        Args:
+            enriched_size (int): Size for enriched nodes. Defaults to 50.
+            nonenriched_size (int): Size for non-enriched nodes. Defaults to 25.
+
+        Returns:
+            np.ndarray: Array of node sizes, with enriched nodes larger than non-enriched ones.
+        """
+        # Merge all enriched nodes from the domain_id_to_node_ids_map dictionary
+        enriched_nodes = set()
+        for _, node_ids in self.graph.domain_id_to_node_ids_map.items():
+            enriched_nodes.update(node_ids)
+
+        # Initialize all node sizes to the non-enriched size
+        node_sizes = np.full(len(self.graph.network.nodes), nonenriched_size)
+        # Set the size for enriched nodes
+        for node in enriched_nodes:
+            if node in self.graph.network.nodes:
+                node_sizes[node] = enriched_size
+
+        return node_sizes

risk/network/plot/plotter.py

@@ -0,0 +1,134 @@
+"""
+risk/network/plot/plotter
+~~~~~~~~~~~~~~~~~~~~~~~~~
+"""
+
+from typing import List, Tuple, Union
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+from risk.log import params
+from risk.network.graph import NetworkGraph
+from risk.network.plot.canvas import Canvas
+from risk.network.plot.contour import Contour
+from risk.network.plot.labels import Labels
+from risk.network.plot.network import Network
+from risk.network.plot.utils import calculate_bounding_box, to_rgba
+
+
+class NetworkPlotter(Canvas, Network, Contour, Labels):
+    """A class for visualizing network graphs with customizable options.
+
+    The NetworkPlotter class uses a NetworkGraph object and provides methods to plot the network with
+    flexible node and edge properties. It also supports plotting labels, contours, drawing the network's
+    perimeter, and adjusting background colors.
+    """
+
+    def __init__(
+        self,
+        graph: NetworkGraph,
+        figsize: Tuple = (10, 10),
+        background_color: Union[str, List, Tuple, np.ndarray] = "white",
+        background_alpha: Union[float, None] = 1.0,
+        pad: float = 0.3,
+    ) -> None:
+        """Initialize the NetworkPlotter with a NetworkGraph object and plotting parameters.
+
+        Args:
+            graph (NetworkGraph): The network data and attributes to be visualized.
+            figsize (tuple, optional): Size of the figure in inches (width, height). Defaults to (10, 10).
+            background_color (str, list, tuple, np.ndarray, optional): Background color of the plot. Defaults to "white".
+            background_alpha (float, None, optional): Transparency level of the background color. If provided, it overrides
+                any existing alpha values found in background_color. Defaults to 1.0.
+            pad (float, optional): Padding value to adjust the axis limits. Defaults to 0.3.
+        """
+        self.graph = graph
+        # Initialize the plot with the specified parameters
+        self.ax = self._initialize_plot(
+            graph=graph,
+            figsize=figsize,
+            background_color=background_color,
+            background_alpha=background_alpha,
+            pad=pad,
+        )
+        super().__init__(graph=graph, ax=self.ax)
+
+    def _initialize_plot(
+        self,
+        graph: NetworkGraph,
+        figsize: Tuple,
+        background_color: Union[str, List, Tuple, np.ndarray],
+        background_alpha: Union[float, None],
+        pad: float,
+    ) -> plt.Axes:
+        """Set up the plot with figure size and background color.
+
+        Args:
+            graph (NetworkGraph): The network data and attributes to be visualized.
+            figsize (tuple): Size of the figure in inches (width, height).
+            background_color (str): Background color of the plot.
+            background_alpha (float, None, optional): Transparency level of the background color. If provided, it overrides any
+            existing alpha values found in background_color.
+            pad (float, optional): Padding value to adjust the axis limits.
+
+        Returns:
+            plt.Axes: The axis object for the plot.
+        """
+        # Log the plotter settings
+        params.log_plotter(
+            figsize=figsize,
+            background_color=background_color,
+            background_alpha=background_alpha,
+            pad=pad,
+        )
+
+        # Extract node coordinates from the network graph
+        node_coordinates = graph.node_coordinates
+        # Calculate the center and radius of the bounding box around the network
+        center, radius = calculate_bounding_box(node_coordinates)
+
+        # Create a new figure and axis for plotting
+        fig, ax = plt.subplots(figsize=figsize)
+        fig.tight_layout()  # Adjust subplot parameters to give specified padding
+        # Set axis limits based on the calculated bounding box and radius
+        ax.set_xlim([center[0] - radius - pad, center[0] + radius + pad])
+        ax.set_ylim([center[1] - radius - pad, center[1] + radius + pad])
+        ax.set_aspect("equal")  # Ensure the aspect ratio is equal
+
+        # Set the background color of the plot
+        # Convert color to RGBA using the to_rgba helper function
+        fig.patch.set_facecolor(to_rgba(color=background_color, alpha=background_alpha))
+        ax.invert_yaxis()  # Invert the y-axis to match typical image coordinates
+        # Remove axis spines for a cleaner look
+        for spine in ax.spines.values():
+            spine.set_visible(False)
+
+        # Hide axis ticks and labels
+        ax.set_xticks([])
+        ax.set_yticks([])
+        ax.patch.set_visible(False)  # Hide the axis background
+
+        return ax
+
+    @staticmethod
+    def savefig(*args, pad_inches: float = 0.5, dpi: int = 100, **kwargs) -> None:
+        """Save the current plot to a file with additional export options.
+
+        Args:
+            *args: Positional arguments passed to `plt.savefig`.
+            pad_inches (float, optional): Padding around the figure when saving. Defaults to 0.5.
+            dpi (int, optional): Dots per inch (DPI) for the exported image. Defaults to 300.
+            **kwargs: Keyword arguments passed to `plt.savefig`, such as filename and format.
+        """
+        plt.savefig(*args, bbox_inches="tight", pad_inches=pad_inches, dpi=dpi, **kwargs)
+
+    @staticmethod
+    def show(*args, **kwargs) -> None:
+        """Display the current plot.
+
+        Args:
+            *args: Positional arguments passed to `plt.show`.
+            **kwargs: Keyword arguments passed to `plt.show`.
+        """
+        plt.show(*args, **kwargs)

risk/network/plot/utils.py

@@ -0,0 +1,153 @@
+"""
+risk/network/plot/utils
+~~~~~~~~~~~~~~~~~~~~~~~
+"""
+
+from typing import List, Tuple, Union
+
+import matplotlib.colors as mcolors
+import numpy as np
+
+from risk.network.graph import NetworkGraph
+
+
+def get_annotated_domain_colors(
+    graph: NetworkGraph,
+    cmap: str = "gist_rainbow",
+    color: Union[str, None] = None,
+    min_scale: float = 0.8,
+    max_scale: float = 1.0,
+    scale_factor: float = 1.0,
+    random_seed: int = 888,
+) -> np.ndarray:
+    """Get colors for the domains based on node annotations, or use a specified color.
+
+    Args:
+        graph (NetworkGraph): The network data and attributes to be visualized.
+        cmap (str, optional): Colormap to use for generating domain colors. Defaults to "gist_rainbow".
+        color (str or None, optional): Color to use for the domains. If None, the colormap will be used. Defaults to None.
+        min_scale (float, optional): Minimum scale for color intensity when generating domain colors.
+            Defaults to 0.8.
+        max_scale (float, optional): Maximum scale for color intensity when generating domain colors.
+            Defaults to 1.0.
+        scale_factor (float, optional): Factor for adjusting the contrast in the colors generated based on
+            enrichment. Higher values increase the contrast. Defaults to 1.0.
+        random_seed (int, optional): Seed for random number generation to ensure reproducibility. Defaults to 888.
+
+    Returns:
+        np.ndarray: Array of RGBA colors for each domain.
+    """
+    # Generate domain colors based on the enrichment data
+    node_colors = graph.get_domain_colors(
+        cmap=cmap,
+        color=color,
+        min_scale=min_scale,
+        max_scale=max_scale,
+        scale_factor=scale_factor,
+        random_seed=random_seed,
+    )
+    annotated_colors = []
+    for _, node_ids in graph.domain_id_to_node_ids_map.items():
+        if len(node_ids) > 1:
+            # For multi-node domains, choose the brightest color based on RGB sum
+            domain_colors = np.array([node_colors[node] for node in node_ids])
+            brightest_color = domain_colors[
+                np.argmax(domain_colors[:, :3].sum(axis=1))  # Sum the RGB values
+            ]
+            annotated_colors.append(brightest_color)
+        else:
+            # Single-node domains default to white (RGBA)
+            default_color = np.array([1.0, 1.0, 1.0, 1.0])
+            annotated_colors.append(default_color)
+
+    return np.array(annotated_colors)
+
+
+def calculate_bounding_box(
+    node_coordinates: np.ndarray, radius_margin: float = 1.05
+) -> Tuple[np.ndarray, float]:
+    """Calculate the bounding box of the network based on node coordinates.
+
+    Args:
+        node_coordinates (np.ndarray): Array of node coordinates (x, y).
+        radius_margin (float, optional): Margin factor to apply to the bounding box radius. Defaults to 1.05.
+
+    Returns:
+        tuple: Center of the bounding box and the radius (adjusted by the radius margin).
+    """
+    # Find minimum and maximum x, y coordinates
+    x_min, y_min = np.min(node_coordinates, axis=0)
+    x_max, y_max = np.max(node_coordinates, axis=0)
+    # Calculate the center of the bounding box
+    center = np.array([(x_min + x_max) / 2, (y_min + y_max) / 2])
+    # Calculate the radius of the bounding box, adjusted by the margin
+    radius = max(x_max - x_min, y_max - y_min) / 2 * radius_margin
+    return center, radius
+
+
+def to_rgba(
+    color: Union[str, List, Tuple, np.ndarray],
+    alpha: Union[float, None] = None,
+    num_repeats: Union[int, None] = None,
+) -> np.ndarray:
+    """Convert color(s) to RGBA format, applying alpha and repeating as needed.
+
+    Args:
+        color (Union[str, list, tuple, np.ndarray]): The color(s) to convert. Can be a string, list, tuple, or np.ndarray.
+        alpha (float, None, optional): Alpha value (transparency) to apply. If provided, it overrides any existing alpha values
+            found in color.
+        num_repeats (int, None, optional): If provided, the color(s) will be repeated this many times. Defaults to None.
+
+    Returns:
+        np.ndarray: Array of RGBA colors repeated `num_repeats` times, if applicable.
+    """
+
+    def convert_to_rgba(c: Union[str, List, Tuple, np.ndarray]) -> np.ndarray:
+        """Convert a single color to RGBA format, handling strings, hex, and RGB/RGBA lists."""
+        # Note: if no alpha is provided, the default alpha value is 1.0 by mcolors.to_rgba
+        if isinstance(c, str):
+            # Convert color names or hex values (e.g., 'red', '#FF5733') to RGBA
+            rgba = np.array(mcolors.to_rgba(c))
+        elif isinstance(c, (list, tuple, np.ndarray)) and len(c) in [3, 4]:
+            # Convert RGB (3) or RGBA (4) values to RGBA format
+            rgba = np.array(mcolors.to_rgba(c))
+        else:
+            raise ValueError(
+                f"Invalid color format: {c}. Must be a valid string or RGB/RGBA sequence."
+            )
+
+        if alpha is not None:  # Override alpha if provided
+            rgba[3] = alpha
+        return rgba
+
+    # If color is a 2D array of RGBA values, convert it to a list of lists
+    if isinstance(color, np.ndarray) and color.ndim == 2 and color.shape[1] == 4:
+        color = [list(c) for c in color]
+
+    # Handle a single color (string or RGB/RGBA list/tuple)
+    if isinstance(color, (str, list, tuple)) and not any(
+        isinstance(c, (list, tuple, np.ndarray)) for c in color
+    ):
+        rgba_color = convert_to_rgba(color)
+        if num_repeats:
+            return np.tile(
+                rgba_color, (num_repeats, 1)
+            )  # Repeat the color if num_repeats is provided
+        return np.array([rgba_color])  # Return a single color wrapped in a numpy array
+
+    # Handle a list/array of colors
+    elif isinstance(color, (list, tuple, np.ndarray)):
+        rgba_colors = np.array(
+            [convert_to_rgba(c) for c in color]
+        )  # Convert each color in the list to RGBA
+        # Handle repetition if num_repeats is provided
+        if num_repeats:
+            repeated_colors = np.array(
+                [rgba_colors[i % len(rgba_colors)] for i in range(num_repeats)]
+            )
+            return repeated_colors
+
+        return rgba_colors
+
+    else:
+        raise ValueError("Color must be a valid RGB/RGBA or array of RGB/RGBA colors.")

risk/risk.py

@@ -356,6 +356,7 @@ class RISK(NetworkIO, AnnotationsIO):
         figsize: Tuple = (10, 10),
         background_color: str = "white",
         background_alpha: Union[float, None] = 1.0,
+        pad: float = 0.3,
     ) -> NetworkPlotter:
         """Get a NetworkPlotter object for plotting.
 
@@ -365,16 +366,12 @@ class RISK(NetworkIO, AnnotationsIO):
             background_color (str, optional): Background color of the plot. Defaults to "white".
             background_alpha (float, None, optional): Transparency level of the background color. If provided, it overrides
                 any existing alpha values found in background_color. Defaults to 1.0.
+            pad (float, optional): Padding value to adjust the axis limits. Defaults to 0.3.
 
         Returns:
             NetworkPlotter: A NetworkPlotter object configured with the given parameters.
         """
         log_header("Loading plotter")
-        # Log the plotter settings
-        params.log_plotter(
-            figsize=figsize,
-            background_color=background_color,
-        )
 
         # Initialize and return a NetworkPlotter object
         return NetworkPlotter(
@@ -382,6 +379,7 @@ class RISK(NetworkIO, AnnotationsIO):
             figsize=figsize,
             background_color=background_color,
             background_alpha=background_alpha,
+            pad=pad,
         )
 
     def _load_neighborhoods(

{risk_network-0.0.8b7.dist-info → risk_network-0.0.8b9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: risk-network
-Version: 0.0.8b7
+Version: 0.0.8b9
 Summary: A Python package for biological network analysis
 Author: Ira Horecka
 Author-email: Ira Horecka <ira89@icloud.com>

{risk_network-0.0.8b7.dist-info → risk_network-0.0.8b9.dist-info}/RECORD

@@ -1,6 +1,6 @@
-risk/__init__.py,sha256=Ld6-5HUuOVDCaSGqPvt7caqDuDx8YQ6yDSV1MrTjnCQ,112
+risk/__init__.py,sha256=ZdYPjV9cVMzz6tSQJbYp9MnzLO53YJLS50zbeWZ1SSI,112
 risk/constants.py,sha256=XInRaH78Slnw_sWgAsBFbUHkyA0h0jL0DKGuQNbOvjM,550
-risk/risk.py,sha256=uZH7GuADCAAkDIx-rPlS6O_is6tUU2Hg28P8xpR-d9g,21240
+risk/risk.py,sha256=slJXca_a726_D7oXwe765HaKTv3ZrOvhttyrWdCGPkA,21231
 risk/annotations/__init__.py,sha256=vUpVvMRE5if01Ic8QY6M2Ae3EFGJHdugEe9PdEkAW4Y,138
 risk/annotations/annotations.py,sha256=ySc_N3nXnKx5RnOpFaEkM6zvTbswbrRcfFLzM0KdOck,11391
 risk/annotations/io.py,sha256=TTXVJQgUGAlKpnGBcx7Dow146IGyozA03nSbl3S7M5M,9475
@@ -15,7 +15,13 @@ risk/network/__init__.py,sha256=iEPeJdZfqp0toxtbElryB8jbz9_t_k4QQ3iDvKE8C_0,126
 risk/network/geometry.py,sha256=H1yGVVqgbfpzBzJwEheDLfvGLSA284jGQQTn612L4Vc,6759
 risk/network/graph.py,sha256=EwD4-1THC5YNdP6PY01Oe35k2QYYqtZpxWraPVH6wa4,16426
 risk/network/io.py,sha256=kY7HqmL3wa1NnqHu61_G8IpT21qpBijpAZ4ixmsseJA,22911
-risk/network/plot/base.py,sha256=8Wbrm2Es8cGYGGGOoJqzeUfuDlNlgJ4_6IEIIfMShN8,85611
+risk/network/plot/__init__.py,sha256=MfmaXJgAZJgXZ2wrhK8pXwzETlcMaLChhWXKAozniAo,98
+risk/network/plot/canvas.py,sha256=-Y2shCy4Udp-stB9tBXGZRTASQZiv8RVqVcQ5lBhVu0,10291
+risk/network/plot/contour.py,sha256=YPG8Uz0VlJ4skLdGaTH_FmQN6A_ArK8XSTNo1LzkSws,14276
+risk/network/plot/labels.py,sha256=o_V_eWQZB_otjXpw6aAwEPp1Uu-auQNcxQYpGBOL7uU,40777
+risk/network/plot/network.py,sha256=83ZXjGGrgRprWvDldWfhRe6SFXTv_QoI20OWzyEmVJU,12593
+risk/network/plot/plotter.py,sha256=rQV4Db6Ud86FJm11uaBvgSuzpmGsrZxnsRnUKjg6w84,5572
+risk/network/plot/utils.py,sha256=jZgI8EysSjviQmdYAceZk2MwJXcdeFAkYp-odZNqV0k,6316
 risk/stats/__init__.py,sha256=WcgoETQ-hS0LQqKRsAMIPtP15xZ-4eul6VUBuUx4Wzc,220
 risk/stats/hypergeom.py,sha256=o6Qnj31gCAKxr2uQirXrbv7XvdDJGEq69MFW-ubx_hA,2272
 risk/stats/poisson.py,sha256=8x9hB4DCukq4gNIlIKO-c_jYG1-BTwTX53oLauFyfj8,1793
@@ -23,8 +29,8 @@ risk/stats/stats.py,sha256=kvShov-94W6ffgDUTb522vB9hDJQSyTsYif_UIaFfSM,7059
 risk/stats/permutation/__init__.py,sha256=neJp7FENC-zg_CGOXqv-iIvz1r5XUKI9Ruxhmq7kDOI,105
 risk/stats/permutation/permutation.py,sha256=D84Rcpt6iTQniK0PfQGcw9bLcHbMt9p-ARcurUnIXZQ,10095
 risk/stats/permutation/test_functions.py,sha256=lftOude6hee0pyR80HlBD32522JkDoN5hrKQ9VEbuoY,2345
-risk_network-0.0.8b7.dist-info/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
-risk_network-0.0.8b7.dist-info/METADATA,sha256=wOm-_aHavf5zpMp_UjqIBx2NPl4nR_2YtS1cfFn6UBA,47450
-risk_network-0.0.8b7.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-risk_network-0.0.8b7.dist-info/top_level.txt,sha256=NX7C2PFKTvC1JhVKv14DFlFAIFnKc6Lpsu1ZfxvQwVw,5
-risk_network-0.0.8b7.dist-info/RECORD,,
+risk_network-0.0.8b9.dist-info/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+risk_network-0.0.8b9.dist-info/METADATA,sha256=Sq_d-xGJT_RHwo6lxwl0s9ydoIeNTRW-1vrG1V-NknA,47450
+risk_network-0.0.8b9.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+risk_network-0.0.8b9.dist-info/top_level.txt,sha256=NX7C2PFKTvC1JhVKv14DFlFAIFnKc6Lpsu1ZfxvQwVw,5
+risk_network-0.0.8b9.dist-info/RECORD,,