risk-network 0.0.4b0__py3-none-any.whl → 0.0.4b2__py3-none-any.whl

risk/__init__.py

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

risk/annotations/io.py

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

risk/neighborhoods/neighborhoods.py

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

risk/network/graph.py

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

risk/network/io.py

@@ -33,15 +33,63 @@ class NetworkIO:
         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.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.
 
@@ -56,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.
@@ -68,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".
@@ -173,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".
@@ -187,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)
 

risk/network/plot.py

@@ -27,7 +27,7 @@ class NetworkPlotter:
 
     def __init__(
         self,
-        network_graph: NetworkGraph,
+        graph: NetworkGraph,
         figsize: tuple = (10, 10),
         background_color: str = "white",
         plot_outline: bool = True,
@@ -37,22 +37,22 @@ class NetworkPlotter:
         """Initialize the NetworkPlotter with a NetworkGraph object and plotting parameters.
 
         Args:
-            network_graph (NetworkGraph): The network data and attributes to be visualized.
+            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, optional): Background color of the plot. Defaults to "white".
             plot_outline (bool, optional): Whether to plot the network perimeter circle. Defaults to True.
             outline_color (str, optional): Color of the network perimeter circle. Defaults to "black".
             outline_scale (float, optional): Outline scaling factor for the perimeter diameter. Defaults to 1.0.
         """
-        self.network_graph = network_graph
+        self.graph = graph
         # Initialize the plot with the specified parameters
         self.ax = self._initialize_plot(
-            network_graph, figsize, background_color, plot_outline, outline_color, outline_scale
+            graph, figsize, background_color, plot_outline, outline_color, outline_scale
         )
 
     def _initialize_plot(
         self,
-        network_graph: NetworkGraph,
+        graph: NetworkGraph,
         figsize: tuple,
         background_color: str,
         plot_outline: bool,
@@ -62,7 +62,7 @@ class NetworkPlotter:
         """Set up the plot with figure size, optional circle perimeter, and background color.
 
         Args:
-            network_graph (NetworkGraph): The network data and attributes to be visualized.
+            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.
             plot_outline (bool): Whether to plot the network perimeter circle.
@@ -73,7 +73,7 @@ class NetworkPlotter:
             plt.Axes: The axis object for the plot.
         """
         # Extract node coordinates from the network graph
-        node_coordinates = network_graph.node_coordinates
+        node_coordinates = graph.node_coordinates
         # Calculate the center and radius of the bounding box around the network
         center, radius = _calculate_bounding_box(node_coordinates)
         # Scale the radius by the outline_scale factor
@@ -141,10 +141,10 @@ class NetworkPlotter:
             network_node_shape=node_shape,
         )
         # Extract node coordinates from the network graph
-        node_coordinates = self.network_graph.node_coordinates
+        node_coordinates = self.graph.node_coordinates
         # Draw the nodes of the graph
         nx.draw_networkx_nodes(
-            self.network_graph.G,
+            self.graph.network,
             pos=node_coordinates,
             node_size=node_size,
             node_color=node_color,
@@ -155,7 +155,7 @@ class NetworkPlotter:
         )
         # Draw the edges of the graph
         nx.draw_networkx_edges(
-            self.network_graph.G,
+            self.graph.network,
             pos=node_coordinates,
             width=edge_width,
             edge_color=edge_color,
@@ -197,20 +197,18 @@ class NetworkPlotter:
         )
         # Filter to get node IDs and their coordinates
         node_ids = [
-            self.network_graph.node_label_to_id_map.get(node)
+            self.graph.node_label_to_id_map.get(node)
             for node in nodes
-            if node in self.network_graph.node_label_to_id_map
+            if node in self.graph.node_label_to_id_map
         ]
         if not node_ids:
             raise ValueError("No nodes found in the network graph.")
 
         # Get the coordinates of the filtered nodes
-        node_coordinates = {
-            node_id: self.network_graph.node_coordinates[node_id] for node_id in node_ids
-        }
+        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.network_graph.G,
+            self.graph.network,
             pos=node_coordinates,
             nodelist=node_ids,
             node_size=node_size,
@@ -221,7 +219,7 @@ class NetworkPlotter:
             ax=self.ax,
         )
         # Draw the edges between the specified nodes in the subnetwork
-        subgraph = self.network_graph.G.subgraph(node_ids)
+        subgraph = self.graph.network.subgraph(node_ids)
         nx.draw_networkx_edges(
             subgraph,
             pos=node_coordinates,
@@ -260,9 +258,9 @@ class NetworkPlotter:
             color = self.get_annotated_contour_colors(color=color)
 
         # Extract node coordinates from the network graph
-        node_coordinates = self.network_graph.node_coordinates
+        node_coordinates = self.graph.node_coordinates
         # Draw contours for each domain in the network
-        for idx, (_, nodes) in enumerate(self.network_graph.domain_to_nodes.items()):
+        for idx, (_, nodes) in enumerate(self.graph.domain_to_nodes.items()):
             if len(nodes) > 1:
                 self._draw_kde_contour(
                     self.ax,
@@ -307,15 +305,15 @@ class NetworkPlotter:
         )
         # Filter to get node IDs and their coordinates
         node_ids = [
-            self.network_graph.node_label_to_id_map.get(node)
+            self.graph.node_label_to_id_map.get(node)
             for node in nodes
-            if node in self.network_graph.node_label_to_id_map
+            if node in self.graph.node_label_to_id_map
         ]
         if not node_ids or len(node_ids) == 1:
             raise ValueError("No nodes found in the network graph or insufficient nodes to plot.")
 
         # Draw the KDE contour for the specified nodes
-        node_coordinates = self.network_graph.node_coordinates
+        node_coordinates = self.graph.node_coordinates
         self._draw_kde_contour(
             self.ax,
             node_coordinates,
@@ -438,7 +436,7 @@ class NetworkPlotter:
 
         # Calculate the center and radius of the network
         domain_centroids = {}
-        for domain, nodes in self.network_graph.domain_to_nodes.items():
+        for domain, nodes in self.graph.domain_to_nodes.items():
             if nodes:  # Skip if the domain has no nodes
                 domain_centroids[domain] = self._calculate_domain_centroid(nodes)
 
@@ -448,10 +446,7 @@ class NetworkPlotter:
         # Loop through domain_centroids with index
         for idx, (domain, centroid) in enumerate(domain_centroids.items()):
             # Check if the domain passes the word count condition
-            if (
-                len(self.network_graph.trimmed_domain_to_term[domain].split(" ")[:max_words])
-                >= min_words
-            ):
+            if len(self.graph.trimmed_domain_to_term[domain].split(" ")[:max_words]) >= min_words:
                 # Add to filtered_domain_centroids
                 filtered_domain_centroids[domain] = centroid
                 # Keep track of the valid index
@@ -463,7 +458,7 @@ class NetworkPlotter:
 
         # Calculate the bounding box around the network
         center, radius = _calculate_bounding_box(
-            self.network_graph.node_coordinates, radius_margin=perimeter_scale
+            self.graph.node_coordinates, radius_margin=perimeter_scale
         )
         # Calculate the best positions for labels around the perimeter
         best_label_positions = _best_label_positions(
@@ -472,7 +467,7 @@ class NetworkPlotter:
         # Annotate the network with labels
         for idx, (domain, pos) in enumerate(best_label_positions.items()):
             centroid = filtered_domain_centroids[domain]
-            annotations = self.network_graph.trimmed_domain_to_term[domain].split(" ")[:max_words]
+            annotations = self.graph.trimmed_domain_to_term[domain].split(" ")[:max_words]
             self.ax.annotate(
                 "\n".join(annotations),
                 xy=centroid,
@@ -527,17 +522,19 @@ class NetworkPlotter:
 
         # Map node labels to IDs
         node_ids = [
-            self.network_graph.node_label_to_id_map.get(node)
+            self.graph.node_label_to_id_map.get(node)
             for node in nodes
-            if node in self.network_graph.node_label_to_id_map
+            if node in self.graph.node_label_to_id_map
         ]
+        if not node_ids or len(node_ids) == 1:
+            raise ValueError("No nodes found in the network graph or insufficient nodes to plot.")
 
         # Calculate the centroid of the provided nodes
         centroid = self._calculate_domain_centroid(node_ids)
 
         # Calculate the bounding box around the network
         center, radius = _calculate_bounding_box(
-            self.network_graph.node_coordinates, radius_margin=perimeter_scale
+            self.graph.node_coordinates, radius_margin=perimeter_scale
         )
 
         # Convert radial position to radians, adjusting for a 90-degree rotation
@@ -571,7 +568,7 @@ class NetworkPlotter:
             tuple: A tuple containing the domain's central node coordinates.
         """
         # Extract positions of all nodes in the domain
-        node_positions = self.network_graph.node_coordinates[nodes, :]
+        node_positions = self.graph.node_coordinates[nodes, :]
         # Calculate the pairwise distance matrix between all nodes in the domain
         distances_matrix = np.linalg.norm(node_positions[:, np.newaxis] - node_positions, axis=2)
         # Sum the distances for each node to all other nodes in the domain
@@ -596,7 +593,7 @@ class NetworkPlotter:
             np.ndarray: Array of RGBA colors adjusted for enrichment status.
         """
         # Get the initial domain colors for each node
-        network_colors = self.network_graph.get_domain_colors(**kwargs, random_seed=random_seed)
+        network_colors = self.graph.get_domain_colors(**kwargs, random_seed=random_seed)
         if isinstance(nonenriched_color, str):
             # Convert the non-enriched color from string to RGBA
             nonenriched_color = mcolors.to_rgba(nonenriched_color)
@@ -623,14 +620,14 @@ class NetworkPlotter:
         """
         # Merge all enriched nodes from the domain_to_nodes dictionary
         enriched_nodes = set()
-        for _, nodes in self.network_graph.domain_to_nodes.items():
+        for _, nodes in self.graph.domain_to_nodes.items():
             enriched_nodes.update(nodes)
 
         # Initialize all node sizes to the non-enriched size
-        node_sizes = np.full(len(self.network_graph.G.nodes), nonenriched_nodesize)
+        node_sizes = np.full(len(self.graph.network.nodes), nonenriched_nodesize)
         # Set the size for enriched nodes
         for node in enriched_nodes:
-            if node in self.network_graph.G.nodes:
+            if node in self.graph.network.nodes:
                 node_sizes[node] = enriched_nodesize
 
         return node_sizes
@@ -675,12 +672,12 @@ class NetworkPlotter:
         if isinstance(color, str):
             # If a single color string is provided, convert it to RGBA and apply to all domains
             rgba_color = np.array(matplotlib.colors.to_rgba(color))
-            return np.array([rgba_color for _ in self.network_graph.domain_to_nodes])
+            return np.array([rgba_color for _ in self.graph.domain_to_nodes])
 
         # Generate colors for each domain using the provided arguments and random seed
-        node_colors = self.network_graph.get_domain_colors(**kwargs, random_seed=random_seed)
+        node_colors = self.graph.get_domain_colors(**kwargs, random_seed=random_seed)
         annotated_colors = []
-        for _, nodes in self.network_graph.domain_to_nodes.items():
+        for _, nodes in self.graph.domain_to_nodes.items():
             if len(nodes) > 1:
                 # For domains with multiple nodes, choose the brightest color (sum of RGB values)
                 domain_colors = np.array([node_colors[node] for node in nodes])

risk/risk.py

@@ -27,49 +27,12 @@ class RISK(NetworkIO, AnnotationsIO):
     and performing network-based statistical analysis, such as neighborhood significance testing.
     """
 
-    def __init__(
-        self,
-        compute_sphere: bool = True,
-        surface_depth: float = 0.0,
-        min_edges_per_node: int = 0,
-        include_edge_weight: bool = True,
-        weight_label: str = "weight",
-    ):
-        """Initialize the RISK class with configuration settings.
-
-        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".
-        """
+    def __init__(self, *args, **kwargs):
+        """Initialize the RISK class with configuration settings."""
         # Initialize and log network parameters
         params.initialize()
-        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,
-        )
-        # Initialize parent classes
-        NetworkIO.__init__(
-            self,
-            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,
-        )
-        AnnotationsIO.__init__(self)
-
-        # Set class attributes
-        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
+        # Initialize the parent classes
+        super().__init__(*args, **kwargs)
 
     @property
     def params(self):

{risk_network-0.0.4b0.dist-info → risk_network-0.0.4b2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: risk-network
-Version: 0.0.4b0
+Version: 0.0.4b2
 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>
 

{risk_network-0.0.4b0.dist-info → risk_network-0.0.4b2.dist-info}/RECORD

@@ -1,26 +1,26 @@
-risk/__init__.py,sha256=_RCFU6OMr2y2rQgkEL8v7GNdoRzp66xcSTHGsIJYDuU,122
+risk/__init__.py,sha256=k1uCNFu-aa2ozj1u_pYR_tKhWf_Snf43Y6DX8O9_d0I,122
 risk/constants.py,sha256=AICk3x5qRQhls_ijTb4VdbdxU6mZ1aLGbAjLEdBwfJI,550
-risk/risk.py,sha256=GSIhjtn__c6752O9fSLCHH21mY0m8XDKIiLLaDmPhoI,16228
+risk/risk.py,sha256=Kaju0siA2piDWuawSB1iZcngm9BND_R7iJAqAS_55E0,14717
 risk/annotations/__init__.py,sha256=vUpVvMRE5if01Ic8QY6M2Ae3EFGJHdugEe9PdEkAW4Y,138
 risk/annotations/annotations.py,sha256=0-Yf2XPVdMzpttLLgLxtTTnH0Eed_Uv8VXMur6E6xKw,10481
-risk/annotations/io.py,sha256=ozi7aFn3_geB6G0kt7Ya1qVhNOqP6rB0YISjriSZyNw,7989
+risk/annotations/io.py,sha256=TMicRACfY8bNtmbvVrxHoh8zkOVLOIhZwWrpxUlR28Q,7988
 risk/log/__init__.py,sha256=xuLImfxFlKpnVhzi_gDYlr2_c9cLkrw2c_3iEsXb1as,107
 risk/log/console.py,sha256=im9DRExwf6wHlcn9fewoDcKIpo3vPcorZIaNAl-0csY,355
 risk/log/params.py,sha256=Tbb-sovFTptGBqPDKafUA8KOpby4zFObutAT_Iti1hE,6302
 risk/neighborhoods/__init__.py,sha256=tKKEg4lsbqFukpgYlUGxU_v_9FOqK7V0uvM9T2QzoL0,206
 risk/neighborhoods/community.py,sha256=eL2IGT-8sbiJIyfyb_FGngev7pEMxw7tZb8YzbzOYw8,6512
 risk/neighborhoods/domains.py,sha256=HwuChmZH0RGD9eQOvk2-ezQDJRUHHn93vhVgHb-kX6I,10192
-risk/neighborhoods/neighborhoods.py,sha256=zGtxVIs0_Bg0wt1By6d77_lqW0PGXpOtQxeCEtyZFzA,13475
+risk/neighborhoods/neighborhoods.py,sha256=benMk6ZCufhi9FKo6ByaeOzwJ8y43vkFbCD-wUNaCAU,13828
 risk/network/__init__.py,sha256=iEPeJdZfqp0toxtbElryB8jbz9_t_k4QQ3iDvKE8C_0,126
 risk/network/geometry.py,sha256=euBMOVvxpj-0WZam40IbHdsT7E4WXpTwSxuGbmAGTDg,6757
-risk/network/graph.py,sha256=a7gM1d2jHqscFVwn1GZaJWb3oZOFraNsQ2RxC4osaV4,11528
-risk/network/io.py,sha256=KR838qmbDjUX0ziXJ15pgT6LgdKRf3zJpxxAv0VtzbM,12202
-risk/network/plot.py,sha256=dbACRp73EnZZwdOAoIiMivhDn-b1MSDOxUcgSFRHOLI,38465
+risk/network/graph.py,sha256=m3bFWU5528OEm246LPG5XP3l_30vaBiJv4AO4iq0pSA,11552
+risk/network/io.py,sha256=Vn__hWla0EI9djIv7mWc1bFSTS2pRpUwOjPCqMWQOYI,19689
+risk/network/plot.py,sha256=-8LyRqeQi4cxEVxNsTDCyHhmTfFuObLLaFbKQGZwHCI,38289
 risk/stats/__init__.py,sha256=4s9gdJo5B1G_cQc0iMoeIBt5OrQNXkdtNXkAMFQkLxc,103
 risk/stats/permutation.py,sha256=xgaZbaxo57t_FzPlpcb2nsq8oCzc_wj-zAm-xj3P2dA,3404
 risk/stats/stats.py,sha256=7Z-1sJ5zvS3XDjG2UfOV0Y3c3xliYeB-6fk_UHNqfiE,16019
-risk_network-0.0.4b0.dist-info/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
-risk_network-0.0.4b0.dist-info/METADATA,sha256=UgNIQbca_cOb1Ft3kBJ0qil5sF2Y392uzS1HDKfLqUU,43250
-risk_network-0.0.4b0.dist-info/WHEEL,sha256=HiCZjzuy6Dw0hdX5R3LCFPDmFS4BWl8H-8W39XfmgX4,91
-risk_network-0.0.4b0.dist-info/top_level.txt,sha256=NX7C2PFKTvC1JhVKv14DFlFAIFnKc6Lpsu1ZfxvQwVw,5
-risk_network-0.0.4b0.dist-info/RECORD,,
+risk_network-0.0.4b2.dist-info/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+risk_network-0.0.4b2.dist-info/METADATA,sha256=B7fcNMOXnMjV5BuPE1t8UXb8cpk3NiuYmsdDzUKY7oo,43250
+risk_network-0.0.4b2.dist-info/WHEEL,sha256=Mdi9PDNwEZptOjTlUcAth7XJDFtKrHYaQMPulZeBCiQ,91
+risk_network-0.0.4b2.dist-info/top_level.txt,sha256=NX7C2PFKTvC1JhVKv14DFlFAIFnKc6Lpsu1ZfxvQwVw,5
+risk_network-0.0.4b2.dist-info/RECORD,,

{risk_network-0.0.4b0.dist-info → risk_network-0.0.4b2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (72.2.0)
+Generator: setuptools (73.0.1)
 Root-Is-Purelib: true
 Tag: py3-none-any