risk-network 0.0.3b4__py3-none-any.whl → 0.0.4b1__py3-none-any.whl

risk/__init__.py

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

risk/annotations/annotations.py

@@ -171,7 +171,9 @@ def get_description(words_column: pd.Series) -> str:
     stop_words = set(stopwords.words("english"))
     # Tokenize the concatenated string and filter out stopwords and non-alphabetic words
     words = [
-        word.lower()
+        (
+            word.lower() if word.istitle() else word
+        )  # Lowercase all words except proper nouns (e.g., RNA, mRNA)
         for word in word_tokenize(words_column.str.cat(sep=" "))
         if word.isalpha() and word.lower() not in stop_words
     ]

risk/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

@@ -29,25 +29,67 @@ class NetworkIO:
         self,
         compute_sphere: bool = True,
         surface_depth: float = 0.0,
-        distance_metric: str = "dijkstra",
-        edge_length_threshold: float = 0.5,
-        louvain_resolution: float = 0.1,
         min_edges_per_node: int = 0,
         include_edge_weight: bool = True,
         weight_label: str = "weight",
     ):
+        """Initialize the NetworkIO class.
+
+        Args:
+            compute_sphere (bool, optional): Whether to map nodes to a sphere. Defaults to True.
+            surface_depth (float, optional): Surface depth for the sphere. Defaults to 0.0.
+            min_edges_per_node (int, optional): Minimum number of edges per node. Defaults to 0.
+            include_edge_weight (bool, optional): Whether to include edge weights in calculations. Defaults to True.
+            weight_label (str, optional): Label for edge weights. Defaults to "weight".
+        """
         self.compute_sphere = compute_sphere
         self.surface_depth = surface_depth
+        self.min_edges_per_node = min_edges_per_node
         self.include_edge_weight = include_edge_weight
         self.weight_label = weight_label
-        self.distance_metric = distance_metric
-        self.edge_length_threshold = edge_length_threshold
-        self.louvain_resolution = louvain_resolution
-        self.min_edges_per_node = min_edges_per_node
+        params.log_network(
+            compute_sphere=compute_sphere,
+            surface_depth=surface_depth,
+            min_edges_per_node=min_edges_per_node,
+            include_edge_weight=include_edge_weight,
+            weight_label=weight_label,
+        )
 
-    def load_gpickle_network(self, filepath: str) -> nx.Graph:
+    @classmethod
+    def load_gpickle_network(
+        cls,
+        filepath: str,
+        compute_sphere: bool = True,
+        surface_depth: float = 0.0,
+        min_edges_per_node: int = 0,
+        include_edge_weight: bool = True,
+        weight_label: str = "weight",
+    ) -> nx.Graph:
         """Load a network from a GPickle file.
 
+        Args:
+            filepath (str): Path to the GPickle file.
+            compute_sphere (bool, optional): Whether to map nodes to a sphere. Defaults to True.
+            surface_depth (float, optional): Surface depth for the sphere. Defaults to 0.0.
+            min_edges_per_node (int, optional): Minimum number of edges per node. Defaults to 0.
+            include_edge_weight (bool, optional): Whether to include edge weights in calculations. Defaults to True.
+            weight_label (str, optional): Label for edge weights. Defaults to "weight".
+
+        Returns:
+            nx.Graph: Loaded and processed network.
+        """
+        networkio = cls(
+            compute_sphere=compute_sphere,
+            surface_depth=surface_depth,
+            min_edges_per_node=min_edges_per_node,
+            include_edge_weight=include_edge_weight,
+            weight_label=weight_label,
+        )
+        return networkio._load_gpickle_network(filepath=filepath)
+
+    def _load_gpickle_network(self, filepath: str) -> nx.Graph:
+        """Private method to load a network from a GPickle file.
+
         Args:
             filepath (str): Path to the GPickle file.
 
@@ -62,11 +104,43 @@ class NetworkIO:
 
         return self._initialize_graph(G)
 
-    def load_networkx_network(self, G: nx.Graph) -> nx.Graph:
+    @classmethod
+    def load_networkx_network(
+        cls,
+        network: nx.Graph,
+        compute_sphere: bool = True,
+        surface_depth: float = 0.0,
+        min_edges_per_node: int = 0,
+        include_edge_weight: bool = True,
+        weight_label: str = "weight",
+    ) -> nx.Graph:
         """Load a NetworkX graph.
 
         Args:
-            G (nx.Graph): A NetworkX graph object.
+            network (nx.Graph): A NetworkX graph object.
+            compute_sphere (bool, optional): Whether to map nodes to a sphere. Defaults to True.
+            surface_depth (float, optional): Surface depth for the sphere. Defaults to 0.0.
+            min_edges_per_node (int, optional): Minimum number of edges per node. Defaults to 0.
+            include_edge_weight (bool, optional): Whether to include edge weights in calculations. Defaults to True.
+            weight_label (str, optional): Label for edge weights. Defaults to "weight".
+
+        Returns:
+            nx.Graph: Loaded and processed network.
+        """
+        networkio = cls(
+            compute_sphere=compute_sphere,
+            surface_depth=surface_depth,
+            min_edges_per_node=min_edges_per_node,
+            include_edge_weight=include_edge_weight,
+            weight_label=weight_label,
+        )
+        return networkio._load_networkx_network(network=network)
+
+    def _load_networkx_network(self, network: nx.Graph) -> nx.Graph:
+        """Private method to load a NetworkX graph.
+
+        Args:
+            network (nx.Graph): A NetworkX graph object.
 
         Returns:
             nx.Graph: Processed network.
@@ -74,17 +148,60 @@ class NetworkIO:
         filetype = "NetworkX"
         params.log_network(filetype=filetype)
         self._log_loading(filetype)
-        return self._initialize_graph(G)
+        return self._initialize_graph(network)
 
+    @classmethod
     def load_cytoscape_network(
-        self,
+        cls,
         filepath: str,
         source_label: str = "source",
         target_label: str = "target",
+        compute_sphere: bool = True,
+        surface_depth: float = 0.0,
+        min_edges_per_node: int = 0,
+        include_edge_weight: bool = True,
+        weight_label: str = "weight",
         view_name: str = "",
     ) -> nx.Graph:
         """Load a network from a Cytoscape file.
 
+        Args:
+            filepath (str): Path to the Cytoscape file.
+            source_label (str, optional): Source node label. Defaults to "source".
+            target_label (str, optional): Target node label. Defaults to "target".
+            view_name (str, optional): Specific view name to load. Defaults to None.
+            compute_sphere (bool, optional): Whether to map nodes to a sphere. Defaults to True.
+            surface_depth (float, optional): Surface depth for the sphere. Defaults to 0.0.
+            min_edges_per_node (int, optional): Minimum number of edges per node. Defaults to 0.
+            include_edge_weight (bool, optional): Whether to include edge weights in calculations. Defaults to True.
+            weight_label (str, optional): Label for edge weights. Defaults to "weight".
+
+        Returns:
+            nx.Graph: Loaded and processed network.
+        """
+        networkio = cls(
+            compute_sphere=compute_sphere,
+            surface_depth=surface_depth,
+            min_edges_per_node=min_edges_per_node,
+            include_edge_weight=include_edge_weight,
+            weight_label=weight_label,
+        )
+        return networkio._load_cytoscape_network(
+            filepath=filepath,
+            source_label=source_label,
+            target_label=target_label,
+            view_name=view_name,
+        )
+
+    def _load_cytoscape_network(
+        self,
+        filepath: str,
+        source_label: str = "source",
+        target_label: str = "target",
+        view_name: str = "",
+    ) -> nx.Graph:
+        """Private method to load a network from a Cytoscape file.
+
         Args:
             filepath (str): Path to the Cytoscape file.
             source_label (str, optional): Source node label. Defaults to "source".
@@ -179,9 +296,49 @@ class NetworkIO:
             for dirname in cys_dirnames:
                 shutil.rmtree(dirname)
 
-    def load_cytoscape_json_network(self, filepath, source_label="source", target_label="target"):
+    @classmethod
+    def load_cytoscape_json_network(
+        cls,
+        filepath: str,
+        source_label: str = "source",
+        target_label: str = "target",
+        compute_sphere: bool = True,
+        surface_depth: float = 0.0,
+        min_edges_per_node: int = 0,
+        include_edge_weight: bool = True,
+        weight_label: str = "weight",
+    ) -> nx.Graph:
         """Load a network from a Cytoscape JSON (.cyjs) file.
 
+        Args:
+            filepath (str): Path to the Cytoscape JSON file.
+            source_label (str, optional): Source node label. Default is "source".
+            target_label (str, optional): Target node label. Default is "target".
+            compute_sphere (bool, optional): Whether to map nodes to a sphere. Defaults to True.
+            surface_depth (float, optional): Surface depth for the sphere. Defaults to 0.0.
+            min_edges_per_node (int, optional): Minimum number of edges per node. Defaults to 0.
+            include_edge_weight (bool, optional): Whether to include edge weights in calculations. Defaults to True.
+            weight_label (str, optional): Label for edge weights. Defaults to "weight".
+
+        Returns:
+            NetworkX graph: Loaded and processed network.
+        """
+        networkio = cls(
+            compute_sphere=compute_sphere,
+            surface_depth=surface_depth,
+            min_edges_per_node=min_edges_per_node,
+            include_edge_weight=include_edge_weight,
+            weight_label=weight_label,
+        )
+        return networkio._load_cytoscape_json_network(
+            filepath=filepath,
+            source_label=source_label,
+            target_label=target_label,
+        )
+
+    def _load_cytoscape_json_network(self, filepath, source_label="source", target_label="target"):
+        """Private method to load a network from a Cytoscape JSON (.cyjs) file.
+
         Args:
             filepath (str): Path to the Cytoscape JSON file.
             source_label (str, optional): Source node label. Default is "source".
@@ -193,36 +350,46 @@ class NetworkIO:
         filetype = "Cytoscape JSON"
         params.log_network(filetype=filetype, filepath=str(filepath))
         self._log_loading(filetype, filepath=filepath)
+
         # Load the Cytoscape JSON file
         with open(filepath, "r") as f:
             cyjs_data = json.load(f)
 
         # Create a graph
         G = nx.Graph()
-        # Process nodes
+        # Store node positions for later use
         node_x_positions = {}
         node_y_positions = {}
         for node in cyjs_data["elements"]["nodes"]:
             node_data = node["data"]
-            node_id = node_data["id"]
+            node_id = node_data["id_original"]
             node_x_positions[node_id] = node["position"]["x"]
             node_y_positions[node_id] = node["position"]["y"]
-            G.add_node(node_id)
-            G.nodes[node_id]["label"] = node_data.get("name", node_id)
-            G.nodes[node_id]["x"] = node["position"]["x"]
-            G.nodes[node_id]["y"] = node["position"]["y"]
 
-        # Process edges
+        # Process edges and add them to the graph
         for edge in cyjs_data["elements"]["edges"]:
             edge_data = edge["data"]
-            source = edge_data[source_label]
-            target = edge_data[target_label]
+            source = edge_data[f"{source_label}_original"]
+            target = edge_data[f"{target_label}_original"]
+            # Add the edge to the graph, optionally including weights
             if self.weight_label is not None and self.weight_label in edge_data:
                 weight = float(edge_data[self.weight_label])
                 G.add_edge(source, target, weight=weight)
             else:
                 G.add_edge(source, target)
 
+            # Ensure nodes exist in the graph and add them if not present
+            if source not in G:
+                G.add_node(source)
+            if target not in G:
+                G.add_node(target)
+
+        # Add node attributes (like label, x, y positions)
+        for node in G.nodes():
+            G.nodes[node]["label"] = node
+            G.nodes[node]["x"] = node_x_positions.get(node, 0)  # Use stored positions
+            G.nodes[node]["y"] = node_y_positions.get(node, 0)  # Use stored positions
+
         # Initialize the graph
         return self._initialize_graph(G)
 
@@ -320,7 +487,6 @@ class NetworkIO:
         print(f"Projection: {'Sphere' if self.compute_sphere else 'Plane'}")
         if self.compute_sphere:
             print(f"Surface depth: {self.surface_depth}")
-        print(f"Edge length threshold: {self.edge_length_threshold}")
         print(f"Edge weight: {'Included' if self.include_edge_weight else 'Excluded'}")
         if self.include_edge_weight:
             print(f"Weight label: {self.weight_label}")

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,
@@ -299,23 +297,23 @@ class NetworkPlotter:
         """
         # Log the plotting parameters
         params.log_plotter(
-            contour_levels=levels,
-            contour_bandwidth=bandwidth,
-            contour_grid_size=grid_size,
-            contour_alpha=alpha,
-            contour_color="custom" if isinstance(color, np.ndarray) else color,
+            subcontour_levels=levels,
+            subcontour_bandwidth=bandwidth,
+            subcontour_grid_size=grid_size,
+            subcontour_alpha=alpha,
+            subcontour_color="custom" if isinstance(color, np.ndarray) else color,
         )
         # 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,
@@ -402,7 +400,7 @@ class NetworkPlotter:
         fontcolor: Union[str, np.ndarray] = "black",
         arrow_linewidth: float = 1,
         arrow_color: Union[str, np.ndarray] = "black",
-        num_words: int = 10,
+        max_words: int = 10,
         min_words: int = 1,
     ) -> None:
         """Annotate the network graph with labels for different domains, positioned around the network for clarity.
@@ -415,7 +413,7 @@ class NetworkPlotter:
             fontcolor (str or np.ndarray, optional): Color of the label text. Can be a string or RGBA array. Defaults to "black".
             arrow_linewidth (float, optional): Line width of the arrows pointing to centroids. Defaults to 1.
             arrow_color (str or np.ndarray, optional): Color of the arrows. Can be a string or RGBA array. Defaults to "black".
-            num_words (int, optional): Maximum number of words in a label. Defaults to 10.
+            max_words (int, optional): Maximum number of words in a label. Defaults to 10.
             min_words (int, optional): Minimum number of words required to display a label. Defaults to 1.
         """
         # Log the plotting parameters
@@ -427,7 +425,7 @@ class NetworkPlotter:
             label_fontcolor="custom" if isinstance(fontcolor, np.ndarray) else fontcolor,
             label_arrow_linewidth=arrow_linewidth,
             label_arrow_color="custom" if isinstance(arrow_color, np.ndarray) else arrow_color,
-            label_num_words=num_words,
+            label_max_words=max_words,
             label_min_words=min_words,
         )
         # Convert color strings to RGBA arrays if necessary
@@ -438,28 +436,38 @@ 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)
 
+        # Initialize empty lists to collect valid indices
+        valid_indices = []
+        filtered_domain_centroids = {}
+        # 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.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
+                valid_indices.append(idx)
+
+        # Now filter fontcolor and arrow_color to keep only the valid indices
+        fontcolor = fontcolor[valid_indices]
+        arrow_color = arrow_color[valid_indices]
+
         # 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
         )
-
-        # Filter out domains with insufficient words for labeling
-        filtered_domains = {
-            domain: centroid
-            for domain, centroid in domain_centroids.items()
-            if len(self.network_graph.trimmed_domain_to_term[domain].split(" ")[:num_words])
-            >= min_words
-        }
         # Calculate the best positions for labels around the perimeter
-        best_label_positions = _best_label_positions(filtered_domains, center, radius, offset)
+        best_label_positions = _best_label_positions(
+            filtered_domain_centroids, center, radius, offset
+        )
         # Annotate the network with labels
         for idx, (domain, pos) in enumerate(best_label_positions.items()):
-            centroid = filtered_domains[domain]
-            annotations = self.network_graph.trimmed_domain_to_term[domain].split(" ")[:num_words]
+            centroid = filtered_domain_centroids[domain]
+            annotations = self.graph.trimmed_domain_to_term[domain].split(" ")[:max_words]
             self.ax.annotate(
                 "\n".join(annotations),
                 xy=centroid,
@@ -473,6 +481,83 @@ class NetworkPlotter:
                 arrowprops=dict(arrowstyle="->", color=arrow_color[idx], linewidth=arrow_linewidth),
             )
 
+    def plot_sublabel(
+        self,
+        nodes: list,
+        label: str,
+        radial_position: float = 0.0,
+        perimeter_scale: float = 1.05,
+        offset: float = 0.10,
+        font: str = "Arial",
+        fontsize: int = 10,
+        fontcolor: str = "black",
+        arrow_linewidth: float = 1,
+        arrow_color: str = "black",
+    ) -> None:
+        """Annotate the network graph with a single label for the given nodes, positioned at a specified radial angle.
+
+        Args:
+            nodes (List[str]): List of node labels to be used for calculating the centroid.
+            label (str): The label to be annotated on the network.
+            radial_position (float, optional): Radial angle for positioning the label, in degrees (0-360). Defaults to 0.0.
+            perimeter_scale (float, optional): Scale factor for positioning the label around the perimeter. Defaults to 1.05.
+            offset (float, optional): Offset distance for the label from the perimeter. Defaults to 0.10.
+            font (str, optional): Font name for the label. Defaults to "Arial".
+            fontsize (int, optional): Font size for the label. Defaults to 10.
+            fontcolor (str, optional): Color of the label text. Defaults to "black".
+            arrow_linewidth (float, optional): Line width of the arrow pointing to the centroid. Defaults to 1.
+            arrow_color (str, optional): Color of the arrow. Defaults to "black".
+        """
+        # Log the plotting parameters
+        params.log_plotter(
+            sublabel_perimeter_scale=perimeter_scale,
+            sublabel_offset=offset,
+            sublabel_font=font,
+            sublabel_fontsize=fontsize,
+            sublabel_fontcolor="custom" if isinstance(fontcolor, np.ndarray) else fontcolor,
+            sublabel_arrow_linewidth=arrow_linewidth,
+            sublabel_arrow_color="custom" if isinstance(arrow_color, np.ndarray) else arrow_color,
+            sublabel_radial_position=radial_position,
+        )
+
+        # Map node labels to IDs
+        node_ids = [
+            self.graph.node_label_to_id_map.get(node)
+            for node in nodes
+            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.graph.node_coordinates, radius_margin=perimeter_scale
+        )
+
+        # Convert radial position to radians, adjusting for a 90-degree rotation
+        radial_radians = np.deg2rad(radial_position - 90)
+        label_position = (
+            center[0] + (radius + offset) * np.cos(radial_radians),
+            center[1] + (radius + offset) * np.sin(radial_radians),
+        )
+
+        # Annotate the network with the label
+        self.ax.annotate(
+            label,
+            xy=centroid,
+            xytext=label_position,
+            textcoords="data",
+            ha="center",
+            va="center",
+            fontsize=fontsize,
+            fontname=font,
+            color=fontcolor,
+            arrowprops=dict(arrowstyle="->", color=arrow_color, linewidth=arrow_linewidth),
+        )
+
     def _calculate_domain_centroid(self, nodes: list) -> tuple:
         """Calculate the most centrally located node in .
 
@@ -483,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
@@ -508,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)
@@ -535,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
@@ -587,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])
@@ -662,12 +747,12 @@ def _calculate_bounding_box(
 
 
 def _best_label_positions(
-    filtered_domains: Dict[str, Any], center: np.ndarray, radius: float, offset: float
+    filtered_domain_centroids: Dict[str, Any], center: np.ndarray, radius: float, offset: float
 ) -> Dict[str, Any]:
     """Calculate and optimize label positions for clarity.
 
     Args:
-        filtered_domains (dict): Centroids of the filtered domains.
+        filtered_domain_centroids (dict): Centroids of the filtered domains.
         center (np.ndarray): The center coordinates for label positioning.
         radius (float): The radius for positioning labels around the center.
         offset (float): The offset distance from the radius for positioning labels.
@@ -675,15 +760,16 @@ def _best_label_positions(
     Returns:
         dict: Optimized positions for labels.
     """
-    num_domains = len(filtered_domains)
+    num_domains = len(filtered_domain_centroids)
     # Calculate equidistant positions around the center for initial label placement
     equidistant_positions = _equidistant_angles_around_center(center, radius, offset, num_domains)
     # Create a mapping of domains to their initial label positions
     label_positions = {
-        domain: position for domain, position in zip(filtered_domains.keys(), equidistant_positions)
+        domain: position
+        for domain, position in zip(filtered_domain_centroids.keys(), equidistant_positions)
     }
     # Optimize the label positions to minimize distance to domain centroids
-    return _optimize_label_positions(label_positions, filtered_domains)
+    return _optimize_label_positions(label_positions, filtered_domain_centroids)
 
 
 def _equidistant_angles_around_center(

risk/risk.py

@@ -27,64 +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,
-        distance_metric: str = "dijkstra",
-        louvain_resolution: float = 0.1,
-        min_edges_per_node: int = 0,
-        edge_length_threshold: float = 0.5,
-        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.
-            distance_metric (str, optional): Distance metric to use in network analysis. Defaults to "dijkstra".
-            louvain_resolution (float, optional): Resolution parameter for Louvain clustering. Defaults to 0.1.
-            min_edges_per_node (int, optional): Minimum number of edges per node. Defaults to 0.
-            edge_length_threshold (float, optional): Edge length threshold for analysis. Defaults to 0.5.
-            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,
-            distance_metric=distance_metric,
-            louvain_resolution=louvain_resolution,
-            min_edges_per_node=min_edges_per_node,
-            edge_length_threshold=edge_length_threshold,
-            include_edge_weight=include_edge_weight,
-            weight_label=weight_label,
-        )
-        # Initialize parent classes
-        NetworkIO.__init__(
-            self,
-            compute_sphere=compute_sphere,
-            surface_depth=surface_depth,
-            distance_metric=distance_metric,
-            louvain_resolution=louvain_resolution,
-            min_edges_per_node=min_edges_per_node,
-            edge_length_threshold=edge_length_threshold,
-            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.distance_metric = distance_metric
-        self.louvain_resolution = louvain_resolution
-        self.min_edges_per_node = min_edges_per_node
-        self.edge_length_threshold = edge_length_threshold
-        self.include_edge_weight = include_edge_weight
-        self.weight_label = weight_label
+        # Initialize the parent classes
+        super().__init__(*args, **kwargs)
 
     @property
     def params(self):
@@ -95,6 +43,9 @@ class RISK(NetworkIO, AnnotationsIO):
         self,
         network: nx.Graph,
         annotations: Dict[str, Any],
+        distance_metric: str = "dijkstra",
+        louvain_resolution: float = 0.1,
+        edge_length_threshold: float = 0.5,
         score_metric: str = "sum",
         null_distribution: str = "network",
         num_permutations: int = 1000,
@@ -106,6 +57,9 @@ class RISK(NetworkIO, AnnotationsIO):
         Args:
             network (nx.Graph): The network graph.
             annotations (pd.DataFrame): The matrix of annotations associated with the network.
+            distance_metric (str, optional): Distance metric for neighborhood analysis. Defaults to "dijkstra".
+            louvain_resolution (float, optional): Resolution parameter for Louvain clustering. Defaults to 0.1.
+            edge_length_threshold (float, optional): Edge length threshold for neighborhood analysis. Defaults to 0.5.
             score_metric (str, optional): Scoring metric for neighborhood significance. Defaults to "sum".
             null_distribution (str, optional): Distribution used for permutation tests. Defaults to "network".
             num_permutations (int, optional): Number of permutations for significance testing. Defaults to 1000.
@@ -118,6 +72,9 @@ class RISK(NetworkIO, AnnotationsIO):
         print_header("Running permutation test")
         # Log neighborhood analysis parameters
         params.log_neighborhoods(
+            distance_metric=distance_metric,
+            louvain_resolution=louvain_resolution,
+            edge_length_threshold=edge_length_threshold,
             score_metric=score_metric,
             null_distribution=null_distribution,
             num_permutations=num_permutations,
@@ -126,17 +83,18 @@ class RISK(NetworkIO, AnnotationsIO):
         )
 
         # Display the chosen distance metric
-        if self.distance_metric == "louvain":
-            for_print_distance_metric = f"louvain (resolution={self.louvain_resolution})"
+        if distance_metric == "louvain":
+            for_print_distance_metric = f"louvain (resolution={louvain_resolution})"
         else:
-            for_print_distance_metric = self.distance_metric
+            for_print_distance_metric = distance_metric
         print(f"Distance metric: '{for_print_distance_metric}'")
+        print(f"Edge length threshold: {edge_length_threshold}")
         # Compute neighborhoods based on the network and distance metric
         neighborhoods = get_network_neighborhoods(
             network,
-            self.distance_metric,
-            self.edge_length_threshold,
-            louvain_resolution=self.louvain_resolution,
+            distance_metric,
+            edge_length_threshold,
+            louvain_resolution=louvain_resolution,
             random_seed=random_seed,
         )
 
@@ -144,6 +102,8 @@ class RISK(NetworkIO, AnnotationsIO):
         print(f"Null distribution: '{null_distribution}'")
         print(f"Neighborhood scoring metric: '{score_metric}'")
         print(f"Number of permutations: {num_permutations}")
+        print(f"Random seed: {random_seed}")
+        print(f"Maximum workers: {max_workers}")
         # Run the permutation test to compute neighborhood significance
         neighborhood_significance = compute_permutation(
             neighborhoods=neighborhoods,

risk/stats/stats.py

@@ -150,14 +150,14 @@ def _run_permutation_test(
             ]
 
             # Start the permutation process in parallel
-            results = pool.starmap_async(_permutation_process_subset, params_list)
+            results = pool.starmap_async(_permutation_process_subset, params_list, chunksize=1)
 
             # Update progress bar based on progress_counter
             # NOTE: Waiting for results to be ready while updating progress bar gives a big improvement
             # in performance, especially for large number of permutations and workers
             while not results.ready():
                 progress.update(progress_counter.value - progress.n)
-                results.wait(1)  # Wait for 1 second
+                results.wait(0.05)  # Wait for 50ms
 
             # Ensure progress bar reaches 100%
             progress.update(total_progress - progress.n)

{risk_network-0.0.3b4.dist-info → risk_network-0.0.4b1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: risk-network
-Version: 0.0.3b4
+Version: 0.0.4b1
 Summary: A Python package for biological network analysis
 Author: Ira Horecka
 Author-email: Ira Horecka <ira89@icloud.com>
@@ -684,14 +684,14 @@ Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
 Classifier: Topic :: Scientific/Engineering :: Information Analysis
 Classifier: Topic :: Scientific/Engineering :: Visualization
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Development Status :: 4 - Beta
-Requires-Python: >=3.7
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: ipywidgets
@@ -716,7 +716,7 @@ Requires-Dist: tqdm
 
 <p align="center">
   <a href="https://pypi.python.org/pypi/risk-network"><img src="https://img.shields.io/pypi/v/risk-network.svg" alt="pypiv"></a>
-  <a href="https://www.python.org/downloads/"><img src="https://img.shields.io/badge/python-3.7+-blue.svg" alt="Python 3.7+"></a>
+  <a href="https://www.python.org/downloads/"><img src="https://img.shields.io/badge/python-3.8+-blue.svg" alt="Python 3.8+"></a>
   <a href="https://raw.githubusercontent.com/irahorecka/chrono24/main/LICENSE"><img src="https://img.shields.io/badge/License-GPLv3-blue.svg" alt="License: GPL v3"></a>
 </p>
 
@@ -736,7 +736,7 @@ RISK is a software tool for visualizing spatial relationships in networks. It ai
 
 *Saccharomyces cerevisiae* proteins oriented by physical interactions discovered through affinity enrichment and mass spectrometry (Michaelis et al., 2023).
 
-![Metabolic Network Demo](./docs/github/network.png)
+![PPI Network Demo](./docs/github/network.png)
 
 ## Installation
 

risk_network-0.0.4b1.dist-info/RECORD

@@ -0,0 +1,26 @@
+risk/__init__.py,sha256=mAHhUWFzKCookp6VYUp1WNQXgQStNGIUXaOZ2QfFtwc,122
+risk/constants.py,sha256=AICk3x5qRQhls_ijTb4VdbdxU6mZ1aLGbAjLEdBwfJI,550
+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=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=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=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.4b1.dist-info/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+risk_network-0.0.4b1.dist-info/METADATA,sha256=YyRQOzpjmA1i506SBsBljqbz2hthqVYMfaSL5xIyz7I,43250
+risk_network-0.0.4b1.dist-info/WHEEL,sha256=Mdi9PDNwEZptOjTlUcAth7XJDFtKrHYaQMPulZeBCiQ,91
+risk_network-0.0.4b1.dist-info/top_level.txt,sha256=NX7C2PFKTvC1JhVKv14DFlFAIFnKc6Lpsu1ZfxvQwVw,5
+risk_network-0.0.4b1.dist-info/RECORD,,

{risk_network-0.0.3b4.dist-info → risk_network-0.0.4b1.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
 

risk_network-0.0.3b4.dist-info/RECORD

@@ -1,26 +0,0 @@
-risk/__init__.py,sha256=7JTz-sr7kIgP1-2x6p8-HirKCr90zZTsy-gIbKdeYMw,122
-risk/constants.py,sha256=AICk3x5qRQhls_ijTb4VdbdxU6mZ1aLGbAjLEdBwfJI,550
-risk/risk.py,sha256=cWpYogZ-vma4ZZjewVNRMzb2TqHv8YABuzP2brXpOqo,16399
-risk/annotations/__init__.py,sha256=vUpVvMRE5if01Ic8QY6M2Ae3EFGJHdugEe9PdEkAW4Y,138
-risk/annotations/annotations.py,sha256=gZ9gihK_eTWaX3eByh08xr97FX4-XKe6MBwCCjasEDU,10368
-risk/annotations/io.py,sha256=ozi7aFn3_geB6G0kt7Ya1qVhNOqP6rB0YISjriSZyNw,7989
-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/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=KmdrsDZe-ZT4O59NYZM_nQd8Ew9qpbzQcqWS_PaE7eA,12559
-risk/network/plot.py,sha256=fy21X677xqJPFkn564Jegxy05C9x0pJXovd5fm3NZ4Q,34554
-risk/stats/__init__.py,sha256=4s9gdJo5B1G_cQc0iMoeIBt5OrQNXkdtNXkAMFQkLxc,103
-risk/stats/permutation.py,sha256=xgaZbaxo57t_FzPlpcb2nsq8oCzc_wj-zAm-xj3P2dA,3404
-risk/stats/stats.py,sha256=Yu9LMSUtCRkg-h0ErJurb-rkajHgTvdzBcymHldJs5k,16007
-risk_network-0.0.3b4.dist-info/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
-risk_network-0.0.3b4.dist-info/METADATA,sha256=_xhdIlmS0XAYJWRI1yjQppksLevhfTX_wFjKzX5hf9Q,43256
-risk_network-0.0.3b4.dist-info/WHEEL,sha256=HiCZjzuy6Dw0hdX5R3LCFPDmFS4BWl8H-8W39XfmgX4,91
-risk_network-0.0.3b4.dist-info/top_level.txt,sha256=NX7C2PFKTvC1JhVKv14DFlFAIFnKc6Lpsu1ZfxvQwVw,5
-risk_network-0.0.3b4.dist-info/RECORD,,