risk-network 0.0.8b17__py3-none-any.whl → 0.0.8b19__py3-none-any.whl

risk/__init__.py

@@ -7,4 +7,4 @@ RISK: RISK Infers Spatial Kinships
 
 from risk.risk import RISK
 
-__version__ = "0.0.8-beta.17"
+__version__ = "0.0.8-beta.19"

risk/log/params.py

@@ -193,5 +193,5 @@ def _convert_ndarray_to_list(d: Any) -> Any:
         # Convert numpy arrays to lists
         return d.tolist()
     else:
-        # Return the value unchanged if it's not a dict, list, or ndarray
+        # Return the value unchanged if it's not a dict, List, or ndarray
         return d

risk/neighborhoods/domains.py

@@ -76,6 +76,10 @@ def define_domains(
     t_idxmax = node_to_domain.loc[:, 1:].idxmax(axis=1)
     t_idxmax[t_max == 0] = 0
 
+    # Assign all domains where the score is greater than 0
+    node_to_domain["all domains"] = node_to_domain.loc[:, 1:].apply(
+        lambda row: list(row[row > 0].index), axis=1
+    )
     # Assign primary domain
     node_to_domain["primary domain"] = t_idxmax
 
@@ -97,7 +101,7 @@ def trim_domains_and_top_annotations(
         max_cluster_size (int, optional): Maximum size of a cluster to be retained. Defaults to 1000.
 
     Returns:
-        tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]: A tuple containing:
+        Tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]: A tuple containing:
             - Trimmed annotations (pd.DataFrame)
             - Trimmed domains (pd.DataFrame)
             - A DataFrame with domain labels (pd.DataFrame)
@@ -154,7 +158,7 @@ def _optimize_silhouette_across_linkage_and_metrics(
         linkage_metric (str): Linkage metric for clustering.
 
     Returns:
-        tuple[str, str, float]: A tuple containing:
+        Tuple[str, str, float]: A tuple containing:
             - Best linkage method (str)
             - Best linkage metric (str)
             - Best threshold (float)
@@ -208,7 +212,7 @@ def _find_best_silhouette_score(
         resolution (float, optional): Desired resolution for the best threshold. Defaults to 0.001.
 
     Returns:
-        tuple[float, float]: A tuple containing:
+        Tuple[float, float]: A tuple containing:
             - Best threshold (float): The threshold that yields the best silhouette score.
             - Best silhouette score (float): The highest silhouette score achieved.
     """

risk/network/graph.py

@@ -46,6 +46,9 @@ class NetworkGraph:
             trimmed_domains
         )
         self.node_enrichment_sums = node_enrichment_sums
+        self.node_id_to_domain_ids_and_enrichments_map = (
+            self._create_node_id_to_domain_ids_and_enrichments(domains)
+        )
         self.node_id_to_node_label_map = {v: k for k, v in node_label_to_node_id_map.items()}
         self.node_label_to_enrichment_map = dict(
             zip(node_label_to_node_id_map.keys(), node_enrichment_sums)
@@ -92,6 +95,40 @@ class NetworkGraph:
             )
         )
 
+    def _create_node_id_to_domain_ids_and_enrichments(
+        self, domains: pd.DataFrame
+    ) -> Dict[int, Dict]:
+        """Creates a dictionary mapping each node ID to its corresponding domain IDs and enrichment values.
+
+        Args:
+            domains (pd.DataFrame): A DataFrame containing domain information for each node. Assumes the last
+                two columns are 'all domains' and 'primary domain', which are excluded from processing.
+
+        Returns:
+            dict: A dictionary where the key is the node ID (index of the DataFrame), and the value is another dictionary
+                with 'domain' (a list of domain IDs with non-zero enrichment) and 'enrichment'
+                (a dict of domain IDs and their corresponding enrichment values).
+        """
+        # Initialize an empty dictionary to store the result
+        node_id_to_domain_ids_and_enrichments = {}
+        # Get the list of domain columns (excluding 'all domains' and 'primary domain')
+        domain_columns = domains.columns[
+            :-2
+        ]  # The last two columns are 'all domains' and 'primary domain'
+        # Iterate over each row in the dataframe
+        for idx, row in domains.iterrows():
+            # Get the domains (column names) where the enrichment score is greater than 0
+            all_domains = domain_columns[row[domain_columns] > 0].tolist()
+            # Get the enrichment values for those domains
+            enrichment_values = row[all_domains].to_dict()
+            # Store the result in the dictionary with index as the key
+            node_id_to_domain_ids_and_enrichments[idx] = {
+                "domains": all_domains,  # The column names where enrichment > 0
+                "enrichments": enrichment_values,  # The actual enrichment values for those columns
+            }
+
+        return node_id_to_domain_ids_and_enrichments
+
     def _create_domain_id_to_node_labels_map(self) -> Dict[int, List[str]]:
         """Create a map from domain IDs to node labels.
 

risk/network/io.py

@@ -491,7 +491,7 @@ class NetworkIO:
             if "x" not in attrs or "y" not in attrs:
                 if (
                     "pos" in attrs
-                    and isinstance(attrs["pos"], (list, tuple, np.ndarray))
+                    and isinstance(attrs["pos"], (List, Tuple, np.ndarray))
                     and len(attrs["pos"]) >= 2
                 ):
                     attrs["x"], attrs["y"] = attrs["pos"][

risk/network/plot/canvas.py

@@ -34,8 +34,8 @@ class Canvas:
         title_fontsize: int = 20,
         subtitle_fontsize: int = 14,
         font: str = "Arial",
-        title_color: Union[str, list, tuple, np.ndarray] = "black",
-        subtitle_color: Union[str, list, tuple, np.ndarray] = "gray",
+        title_color: Union[str, List, Tuple, np.ndarray] = "black",
+        subtitle_color: Union[str, List, Tuple, np.ndarray] = "gray",
         title_y: float = 0.975,
         title_space_offset: float = 0.075,
         subtitle_offset: float = 0.025,
@@ -48,9 +48,9 @@ class Canvas:
             title_fontsize (int, optional): Font size for the title. Defaults to 20.
             subtitle_fontsize (int, optional): Font size for the subtitle. Defaults to 14.
             font (str, optional): Font family used for both title and subtitle. Defaults to "Arial".
-            title_color (str, list, tuple, or np.ndarray, optional): Color of the title text. Can be a string or an array of colors.
+            title_color (str, List, Tuple, or np.ndarray, optional): Color of the title text. Can be a string or an array of colors.
                 Defaults to "black".
-            subtitle_color (str, list, tuple, or np.ndarray, optional): Color of the subtitle text. Can be a string or an array of colors.
+            subtitle_color (str, List, Tuple, or np.ndarray, optional): Color of the subtitle text. Can be a string or an array of colors.
                 Defaults to "gray".
             title_y (float, optional): Y-axis position of the title. Defaults to 0.975.
             title_space_offset (float, optional): Fraction of figure height to leave for the space above the plot. Defaults to 0.075.
@@ -124,7 +124,7 @@ class Canvas:
             scale (float, optional): Scaling factor for the perimeter diameter. Defaults to 1.0.
             linestyle (str, optional): Line style for the network perimeter circle (e.g., dashed, solid). Defaults to "dashed".
             linewidth (float, optional): Width of the circle's outline. Defaults to 1.5.
-            color (str, list, tuple, or np.ndarray, optional): Color of the network perimeter circle. Defaults to "black".
+            color (str, List, Tuple, or np.ndarray, optional): Color of the network perimeter circle. Defaults to "black".
             outline_alpha (float, None, optional): Transparency level of the circle outline. If provided, it overrides any existing alpha
                 values found in color. Defaults to 1.0.
             fill_alpha (float, None, optional): Transparency level of the circle fill. If provided, it overrides any existing alpha values
@@ -137,7 +137,7 @@ class Canvas:
             perimeter_linestyle=linestyle,
             perimeter_linewidth=linewidth,
             perimeter_color=(
-                "custom" if isinstance(color, (list, tuple, np.ndarray)) else color
+                "custom" if isinstance(color, (List, Tuple, np.ndarray)) else color
             ),  # np.ndarray usually indicates custom colors
             perimeter_outline_alpha=outline_alpha,
             perimeter_fill_alpha=fill_alpha,
@@ -193,7 +193,7 @@ class Canvas:
             levels (int, optional): Number of contour levels. Defaults to 3.
             bandwidth (float, optional): Bandwidth for the KDE. Controls smoothness. Defaults to 0.8.
             grid_size (int, optional): Grid resolution for the KDE. Higher values yield finer contours. Defaults to 250.
-            color (str, list, tuple, or np.ndarray, optional): Color of the network perimeter contour. Defaults to "black".
+            color (str, List, Tuple, or np.ndarray, optional): Color of the network perimeter contour. Defaults to "black".
             linestyle (str, optional): Line style for the network perimeter contour (e.g., dashed, solid). Defaults to "solid".
             linewidth (float, optional): Width of the contour's outline. Defaults to 1.5.
             outline_alpha (float, None, optional): Transparency level of the contour outline. If provided, it overrides any existing
@@ -210,7 +210,7 @@ class Canvas:
             perimeter_grid_size=grid_size,
             perimeter_linestyle=linestyle,
             perimeter_linewidth=linewidth,
-            perimeter_color=("custom" if isinstance(color, (list, tuple, np.ndarray)) else color),
+            perimeter_color=("custom" if isinstance(color, (List, Tuple, np.ndarray)) else color),
             perimeter_outline_alpha=outline_alpha,
             perimeter_fill_alpha=fill_alpha,
         )

risk/network/plot/contour.py

@@ -46,7 +46,7 @@ class Contour:
             levels (int, optional): Number of contour levels to plot. Defaults to 5.
             bandwidth (float, optional): Bandwidth for KDE. Controls the smoothness of the contour. Defaults to 0.8.
             grid_size (int, optional): Resolution of the grid for KDE. Higher values create finer contours. Defaults to 250.
-            color (str, list, tuple, or np.ndarray, optional): Color of the contours. Can be a single color or an array of colors.
+            color (str, List, Tuple, or np.ndarray, optional): Color of the contours. Can be a single color or an array of colors.
                 Defaults to "white".
             linestyle (str, optional): Line style for the contours. Defaults to "solid".
             linewidth (float, optional): Line width for the contours. Defaults to 1.5.
@@ -105,11 +105,11 @@ class Contour:
         """Plot a subcontour for a given set of nodes or a list of node sets using Kernel Density Estimation (KDE).
 
         Args:
-            nodes (list, tuple, or np.ndarray): List of node labels or list of lists of node labels to plot the contour for.
+            nodes (List, Tuple, or np.ndarray): List of node labels or list of lists of node labels to plot the contour for.
             levels (int, optional): Number of contour levels to plot. Defaults to 5.
             bandwidth (float, optional): Bandwidth for KDE. Controls the smoothness of the contour. Defaults to 0.8.
             grid_size (int, optional): Resolution of the grid for KDE. Higher values create finer contours. Defaults to 250.
-            color (str, list, tuple, or np.ndarray, optional): Color of the contour. Can be a string (e.g., 'white') or RGBA array.
+            color (str, List, Tuple, or np.ndarray, optional): Color of the contour. Can be a string (e.g., 'white') or RGBA array.
                 Can be a single color or an array of colors. Defaults to "white".
             linestyle (str, optional): Line style for the contour. Defaults to "solid".
             linewidth (float, optional): Line width for the contour. Defaults to 1.5.
@@ -122,7 +122,7 @@ class Contour:
             ValueError: If no valid nodes are found in the network graph.
         """
         # Check if nodes is a list of lists or a flat list
-        if any(isinstance(item, (list, tuple, np.ndarray)) for item in nodes):
+        if any(isinstance(item, (List, Tuple, np.ndarray)) for item in nodes):
             # If it's a list of lists, iterate over sublists
             node_groups = nodes
             # Convert color to RGBA arrays to match the number of groups
@@ -274,7 +274,9 @@ class Contour:
     def get_annotated_contour_colors(
         self,
         cmap: str = "gist_rainbow",
-        color: Union[str, list, tuple, np.ndarray, None] = None,
+        color: Union[str, List, Tuple, np.ndarray, None] = None,
+        blend_colors: bool = False,
+        blend_gamma: float = 2.2,
         min_scale: float = 0.8,
         max_scale: float = 1.0,
         scale_factor: float = 1.0,
@@ -284,8 +286,10 @@ class Contour:
 
         Args:
             cmap (str, optional): Name of the colormap to use for generating contour colors. Defaults to "gist_rainbow".
-            color (str, list, tuple, np.ndarray, or None, optional): Color to use for the contours. Can be a single color or an array of colors.
+            color (str, List, Tuple, np.ndarray, or None, optional): Color to use for the contours. Can be a single color or an array of colors.
                 If None, the colormap will be used. Defaults to None.
+            blend_colors (bool, optional): Whether to blend colors for nodes with multiple domains. Defaults to False.
+            blend_gamma (float, optional): Gamma correction factor for perceptual color blending. Defaults to 2.2.
             min_scale (float, optional): Minimum intensity scale for the colors generated by the colormap.
                 Controls the dimmest colors. Defaults to 0.8.
             max_scale (float, optional): Maximum intensity scale for the colors generated by the colormap.
@@ -301,6 +305,8 @@ class Contour:
             graph=self.graph,
             cmap=cmap,
             color=color,
+            blend_colors=blend_colors,
+            blend_gamma=blend_gamma,
             min_scale=min_scale,
             max_scale=max_scale,
             scale_factor=scale_factor,

risk/network/plot/labels.py

@@ -66,13 +66,13 @@ class Labels:
                 - If a dictionary, maps specific cases ('lower', 'upper', 'title') to transformations (e.g., 'lower'='upper').
                 - If None, no transformation is applied.
             fontsize (int, optional): Font size for the labels. Defaults to 10.
-            fontcolor (str, list, tuple, or np.ndarray, optional): Color of the label text. Can be a string or RGBA array.
+            fontcolor (str, List, Tuple, or np.ndarray, optional): Color of the label text. Can be a string or RGBA array.
                 Defaults to "black".
             fontalpha (float, None, optional): Transparency level for the font color. If provided, it overrides any existing alpha
                 values found in fontcolor. Defaults to 1.0.
             arrow_linewidth (float, optional): Line width of the arrows pointing to centroids. Defaults to 1.
             arrow_style (str, optional): Style of the arrows pointing to centroids. Defaults to "->".
-            arrow_color (str, list, tuple, or np.ndarray, optional): Color of the arrows. Defaults to "black".
+            arrow_color (str, List, Tuple, or np.ndarray, optional): Color of the arrows. Defaults to "black".
             arrow_alpha (float, None, optional): Transparency level for the arrow color. If provided, it overrides any existing alpha
                 values found in arrow_color. Defaults to 1.0.
             arrow_base_shrink (float, optional): Distance between the text and the base of the arrow. Defaults to 0.0.
@@ -82,9 +82,9 @@ class Labels:
             max_label_lines (int, optional): Maximum number of lines in a label. Defaults to None (no limit).
             min_chars_per_line (int, optional): Minimum number of characters in a line to display. Defaults to 1.
             max_chars_per_line (int, optional): Maximum number of characters in a line to display. Defaults to None (no limit).
-            words_to_omit (list, optional): List of words to omit from the labels. Defaults to None.
+            words_to_omit (List, optional): List of words to omit from the labels. Defaults to None.
             overlay_ids (bool, optional): Whether to overlay domain IDs in the center of the centroids. Defaults to False.
-            ids_to_keep (list, tuple, np.ndarray, or None, optional): IDs of domains that must be labeled. To discover domain IDs,
+            ids_to_keep (List, Tuple, np.ndarray, or None, optional): IDs of domains that must be labeled. To discover domain IDs,
                 you can set `overlay_ids=True`. Defaults to None.
             ids_to_replace (dict, optional): A dictionary mapping domain IDs to custom labels (strings). The labels should be
                 space-separated words. If provided, the custom labels will replace the default domain terms. To discover domain IDs, you
@@ -263,26 +263,26 @@ class Labels:
         """Annotate the network graph with a label for the given nodes, with one arrow pointing to each centroid of sublists of nodes.
 
         Args:
-            nodes (list, tuple, or np.ndarray): List of node labels or list of lists of node labels.
+            nodes (List, Tuple, or np.ndarray): List of node labels or list of lists of node labels.
             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.
             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, list, tuple, or np.ndarray, optional): Color of the label text. Defaults to "black".
+            fontcolor (str, List, Tuple, or np.ndarray, optional): Color of the label text. Defaults to "black".
             fontalpha (float, None, optional): Transparency level for the font color. If provided, it overrides any existing alpha values found
                 in fontalpha. Defaults to 1.0.
             arrow_linewidth (float, optional): Line width of the arrow pointing to the centroid. Defaults to 1.
             arrow_style (str, optional): Style of the arrows pointing to the centroid. Defaults to "->".
-            arrow_color (str, list, tuple, or np.ndarray, optional): Color of the arrow. Defaults to "black".
+            arrow_color (str, List, Tuple, or np.ndarray, optional): Color of the arrow. Defaults to "black".
             arrow_alpha (float, None, optional): Transparency level for the arrow color. If provided, it overrides any existing alpha values
                 found in arrow_alpha. Defaults to 1.0.
             arrow_base_shrink (float, optional): Distance between the text and the base of the arrow. Defaults to 0.0.
             arrow_tip_shrink (float, optional): Distance between the arrow tip and the centroid. Defaults to 0.0.
         """
         # Check if nodes is a list of lists or a flat list
-        if any(isinstance(item, (list, tuple, np.ndarray)) for item in nodes):
+        if any(isinstance(item, (List, Tuple, np.ndarray)) for item in nodes):
             # If it's a list of lists, iterate over sublists
             node_groups = nodes
             # Convert fontcolor and arrow_color to RGBA arrays to match the number of groups
@@ -383,9 +383,9 @@ class Labels:
 
         Args:
             domain_id_to_centroid_map (dict): Mapping of domain IDs to their centroids.
-            ids_to_keep (list, tuple, or np.ndarray, optional): IDs of domains that must be labeled.
+            ids_to_keep (List, Tuple, or np.ndarray, optional): IDs of domains that must be labeled.
             ids_to_replace (dict, optional): A dictionary mapping domain IDs to custom labels. Defaults to None.
-            words_to_omit (list, optional): List of words to omit from the labels. Defaults to None.
+            words_to_omit (List, optional): List of words to omit from the labels. Defaults to None.
             max_labels (int, optional): Maximum number of labels allowed.
             min_label_lines (int): Minimum number of lines in a label.
             max_label_lines (int): Maximum number of lines in a label.
@@ -449,9 +449,9 @@ class Labels:
 
         Args:
             domain_id_to_centroid_map (dict): Mapping of domain IDs to their centroids.
-            ids_to_keep (list, tuple, or np.ndarray, optional): IDs of domains that must be labeled.
+            ids_to_keep (List, Tuple, or np.ndarray, optional): IDs of domains that must be labeled.
             ids_to_replace (dict, optional): A dictionary mapping domain IDs to custom labels. Defaults to None.
-            words_to_omit (list, optional): List of words to omit from the labels. Defaults to None.
+            words_to_omit (List, optional): List of words to omit from the labels. Defaults to None.
             remaining_labels (int): The remaining number of labels that can be generated.
             min_label_lines (int): Minimum number of lines in a label.
             max_label_lines (int): Maximum number of lines in a label.
@@ -607,7 +607,7 @@ class Labels:
         Args:
             domain (str): The domain being processed.
             ids_to_replace (dict, optional): Dictionary mapping domain IDs to custom labels.
-            words_to_omit (list, optional): List of words to omit from the labels.
+            words_to_omit (List, optional): List of words to omit from the labels.
             max_label_lines (int): Maximum number of lines in a label.
             min_chars_per_line (int): Minimum number of characters in a line to display.
             max_chars_per_line (int): Maximum number of characters in a line to display.
@@ -637,7 +637,9 @@ class Labels:
     def get_annotated_label_colors(
         self,
         cmap: str = "gist_rainbow",
-        color: Union[str, list, tuple, np.ndarray, None] = None,
+        color: Union[str, List, Tuple, np.ndarray, None] = None,
+        blend_colors: bool = False,
+        blend_gamma: float = 2.2,
         min_scale: float = 0.8,
         max_scale: float = 1.0,
         scale_factor: float = 1.0,
@@ -647,8 +649,10 @@ class Labels:
 
         Args:
             cmap (str, optional): Name of the colormap to use for generating label colors. Defaults to "gist_rainbow".
-            color (str, list, tuple, np.ndarray, or None, optional): Color to use for the labels. Can be a single color or an array
+            color (str, List, Tuple, np.ndarray, or None, optional): Color to use for the labels. Can be a single color or an array
                 of colors. If None, the colormap will be used. Defaults to None.
+            blend_colors (bool, optional): Whether to blend colors for nodes with multiple domains. Defaults to False.
+            blend_gamma (float, optional): Gamma correction factor for perceptual color blending. Defaults to 2.2.
             min_scale (float, optional): Minimum intensity scale for the colors generated by the colormap.
                 Controls the dimmest colors. Defaults to 0.8.
             max_scale (float, optional): Maximum intensity scale for the colors generated by the colormap.
@@ -664,6 +668,8 @@ class Labels:
             graph=self.graph,
             cmap=cmap,
             color=color,
+            blend_colors=blend_colors,
+            blend_gamma=blend_gamma,
             min_scale=min_scale,
             max_scale=max_scale,
             scale_factor=scale_factor,
@@ -768,7 +774,7 @@ def _calculate_equidistant_positions_around_center(
         num_domains (int): The number of positions (or domains) to calculate.
 
     Returns:
-        list[np.ndarray]: List of positions (as 2D numpy arrays) around the center.
+        List[np.ndarray]: List of positions (as 2D numpy arrays) around the center.
     """
     # Calculate equidistant angles in radians around the center
     angles = np.linspace(0, 2 * np.pi, num_domains, endpoint=False)
@@ -878,28 +884,35 @@ def _apply_str_transformation(
     Returns:
         List[str]: A list of transformed words with no duplicates.
     """
+    # Initialize a list to store transformed words
     transformed_words = []
     for word in words:
-        # Convert the word to a string if it is not already
-        word = str(word)
-        transformed_word = word  # Start with the original word
-        # If transformation is a string, apply it to all words
-        if isinstance(transformation, str):
-            if hasattr(word, transformation):
-                transformed_word = getattr(
-                    word, transformation
-                )()  # Apply the single transformation
-
-        # If transformation is a dictionary, apply case-specific transformations
-        elif isinstance(transformation, dict):
-            for case_type, transform in transformation.items():
-                if case_type == "lower" and word.islower() and transform:
-                    transformed_word = getattr(word, transform)()
-                elif case_type == "upper" and word.isupper() and transform:
-                    transformed_word = getattr(word, transform)()
-                elif case_type == "title" and word.istitle() and transform:
-                    transformed_word = getattr(word, transform)()
-
+        # Split word into subwords by space
+        subwords = word.split(" ")
+        transformed_subwords = []
+        # Apply transformation to each subword
+        for subword in subwords:
+            transformed_subword = subword  # Start with the original subword
+            # If transformation is a string, apply it to all subwords
+            if isinstance(transformation, str):
+                if hasattr(subword, transformation):
+                    transformed_subword = getattr(subword, transformation)()
+
+            # If transformation is a dictionary, apply case-specific transformations
+            elif isinstance(transformation, dict):
+                for case_type, transform in transformation.items():
+                    if case_type == "lower" and subword.islower() and transform:
+                        transformed_subword = getattr(subword, transform)()
+                    elif case_type == "upper" and subword.isupper() and transform:
+                        transformed_subword = getattr(subword, transform)()
+                    elif case_type == "title" and subword.istitle() and transform:
+                        transformed_subword = getattr(subword, transform)()
+
+            # Append the transformed subword to the list
+            transformed_subwords.append(transformed_subword)
+
+        # Rejoin the transformed subwords into a single string to preserve structure
+        transformed_word = " ".join(transformed_subwords)
         # Only append if the transformed word is not already in the list
         if transformed_word not in transformed_words:
             transformed_words.append(transformed_word)

risk/network/plot/network.py

@@ -45,11 +45,11 @@ class Network:
             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.
+            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. Can be a single color or an array of colors.
+            node_edgecolor (str, List, Tuple, or np.ndarray, optional): Color of the node edges. Can be a single color or an array of colors.
                 Defaults to "black".
-            edge_color (str, list, tuple, or np.ndarray, optional): Color of the edges. Can be a single color or an array of colors.
+            edge_color (str, List, Tuple, or np.ndarray, optional): Color of the edges. Can be a single color or an array of colors.
                 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.
@@ -124,14 +124,14 @@ class Network:
         """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.
+            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_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
@@ -141,7 +141,7 @@ class Network:
             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):
+        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
@@ -154,7 +154,7 @@ class Network:
             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)):
+        if not isinstance(node_color, (str, Tuple, np.ndarray)):
             node_color = [
                 node_color[nodes.index(node)]
                 for node in nodes
@@ -196,12 +196,14 @@ class Network:
     def get_annotated_node_colors(
         self,
         cmap: str = "gist_rainbow",
-        color: Union[str, list, tuple, np.ndarray, None] = None,
+        color: Union[str, List, Tuple, np.ndarray, None] = None,
+        blend_colors: bool = False,
+        blend_gamma: float = 2.2,
         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_color: Union[str, List, Tuple, np.ndarray] = "white",
         nonenriched_alpha: Union[float, None] = 1.0,
         random_seed: int = 888,
     ) -> np.ndarray:
@@ -209,14 +211,16 @@ class Network:
 
         Args:
             cmap (str, optional): Colormap to use for coloring the nodes. Defaults to "gist_rainbow".
-            color (str, list, tuple, np.ndarray, or None, optional): Color to use for the nodes. Can be a single color or an array of colors.
+            color (str, List, Tuple, np.ndarray, or None, optional): Color to use for the nodes. Can be a single color or an array of colors.
                 If None, the colormap will be used. Defaults to None.
+            blend_colors (bool, optional): Whether to blend colors for nodes with multiple domains. Defaults to False.
+            blend_gamma (float, optional): Gamma correction factor for perceptual color blending. Defaults to 2.2.
             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. Can be a single color or an array of colors.
+            nonenriched_color (str, List, Tuple, or np.ndarray, optional): Color for non-enriched nodes. Can be a single color or an array of colors.
                 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.
@@ -230,6 +234,8 @@ class Network:
             graph=self.graph,
             cmap=cmap,
             color=color,
+            blend_colors=blend_colors,
+            blend_gamma=blend_gamma,
             min_scale=min_scale,
             max_scale=max_scale,
             scale_factor=scale_factor,

risk/network/plot/plotter.py

@@ -38,8 +38,8 @@ class NetworkPlotter(Canvas, Network, Contour, Labels):
 
         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".
+            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.
@@ -59,7 +59,7 @@ class NetworkPlotter(Canvas, Network, Contour, Labels):
         self,
         graph: NetworkGraph,
         figsize: Tuple,
-        background_color: Union[str, list, tuple, np.ndarray],
+        background_color: Union[str, List, Tuple, np.ndarray],
         background_alpha: Union[float, None],
         pad: float,
     ) -> plt.Axes:
@@ -68,7 +68,7 @@ class NetworkPlotter(Canvas, Network, Contour, Labels):
         Args:
             graph (NetworkGraph): The network data and attributes to be visualized.
             figsize (tuple): Size of the figure in inches (width, height).
-            background_color (str, list, tuple, or np.ndarray): Background color of the plot. Can be a single color or an array of colors.
+            background_color (str, List, Tuple, or np.ndarray): Background color of the plot. Can be a single color or an array of colors.
             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.

risk/network/plot/utils/color.py

@@ -1,6 +1,6 @@
 """
-risk/network/plot/utils/plot
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+risk/network/plot/utils/color
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
 from typing import Any, Dict, List, Tuple, Union
@@ -16,7 +16,9 @@ from risk.network.plot.utils.layout import calculate_centroids
 def get_annotated_domain_colors(
     graph: NetworkGraph,
     cmap: str = "gist_rainbow",
-    color: Union[str, list, tuple, np.ndarray, None] = None,
+    color: Union[str, List, Tuple, np.ndarray, None] = None,
+    blend_colors: bool = False,
+    blend_gamma: float = 2.2,
     min_scale: float = 0.8,
     max_scale: float = 1.0,
     scale_factor: float = 1.0,
@@ -27,8 +29,10 @@ def get_annotated_domain_colors(
     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, list, tuple, np.ndarray, or None, optional): Color to use for the domains. Can be a single color or an array of colors.
+        color (str, List, Tuple, np.ndarray, or None, optional): Color to use for the domains. Can be a single color or an array of colors.
             If None, the colormap will be used. Defaults to None.
+        blend_colors (bool, optional): Whether to blend colors for nodes with multiple domains. Defaults to False.
+        blend_gamma (float, optional): Gamma correction factor for perceptual color blending. Defaults to 2.2.
         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
@@ -43,6 +47,8 @@ def get_annotated_domain_colors(
         graph=graph,
         cmap=cmap,
         color=color,
+        blend_colors=blend_colors,
+        blend_gamma=blend_gamma,
         min_scale=min_scale,
         max_scale=max_scale,
         scale_factor=scale_factor,
@@ -68,7 +74,9 @@ def get_annotated_domain_colors(
 def get_domain_colors(
     graph: NetworkGraph,
     cmap: str = "gist_rainbow",
-    color: Union[str, list, tuple, np.ndarray, None] = None,
+    color: Union[str, List, Tuple, np.ndarray, None] = None,
+    blend_colors: bool = False,
+    blend_gamma: float = 2.2,
     min_scale: float = 0.8,
     max_scale: float = 1.0,
     scale_factor: float = 1.0,
@@ -79,8 +87,10 @@ def get_domain_colors(
     Args:
         graph (NetworkGraph): The network data and attributes to be visualized.
         cmap (str, optional): Name of the colormap to use for generating domain colors. Defaults to "gist_rainbow".
-        color (str, list, tuple, np.ndarray, or None, optional): A specific color or array of colors to use for all domains.
+        color (str, List, Tuple, np.ndarray, or None, optional): A specific color or array of colors to use for all domains.
             If None, the colormap will be used. Defaults to None.
+        blend_colors (bool, optional): Whether to blend colors for nodes with multiple domains. Defaults to False.
+        blend_gamma (float, optional): Gamma correction factor for perceptual color blending. Defaults to 2.2.
         min_scale (float, optional): Minimum intensity scale for the colors generated by the colormap. Controls the dimmest colors.
             Defaults to 0.8.
         max_scale (float, optional): Maximum intensity scale for the colors generated by the colormap. Controls the brightest colors.
@@ -95,7 +105,9 @@ def get_domain_colors(
     # Get colors for each domain
     domain_colors = _get_domain_colors(graph=graph, cmap=cmap, color=color, random_seed=random_seed)
     # Generate composite colors for nodes
-    node_colors = _get_composite_node_colors(graph=graph, domain_colors=domain_colors)
+    node_colors = _get_composite_node_colors(
+        graph=graph, domain_colors=domain_colors, blend_colors=blend_colors, blend_gamma=blend_gamma
+    )
     # Transform colors to ensure proper alpha values and intensity
     transformed_colors = _transform_colors(
         node_colors,
@@ -110,7 +122,7 @@ def get_domain_colors(
 def _get_domain_colors(
     graph: NetworkGraph,
     cmap: str = "gist_rainbow",
-    color: Union[str, list, tuple, np.ndarray, None] = None,
+    color: Union[str, List, Tuple, np.ndarray, None] = None,
     random_seed: int = 888,
 ) -> Dict[str, Any]:
     """Get colors for each domain.
@@ -118,7 +130,7 @@ def _get_domain_colors(
     Args:
         graph (NetworkGraph): The network data and attributes to be visualized.
         cmap (str, optional): The name of the colormap to use. Defaults to "gist_rainbow".
-        color (str, list, tuple, np.ndarray, or None, optional): A specific color or array of colors to use for the domains.
+        color (str, List, Tuple, np.ndarray, or None, optional): A specific color or array of colors to use for the domains.
             If None, the colormap will be used. Defaults to None.
         random_seed (int, optional): Seed for random number generation. Defaults to 888.
 
@@ -136,12 +148,17 @@ def _get_domain_colors(
     return dict(zip(graph.domain_id_to_node_ids_map.keys(), domain_colors))
 
 
-def _get_composite_node_colors(graph: NetworkGraph, domain_colors: np.ndarray) -> np.ndarray:
-    """Generate composite colors for nodes based on domain colors and counts.
+def _get_composite_node_colors(
+    graph, domain_colors: np.ndarray, blend_colors: bool = False, blend_gamma: float = 2.2
+) -> np.ndarray:
+    """Generate composite colors for nodes based on domain colors and enrichment values, with optional color blending.
 
     Args:
         graph (NetworkGraph): The network data and attributes to be visualized.
-        domain_colors (np.ndarray): Array of colors corresponding to each domain.
+        domain_colors (np.ndarray): Array or list of RGBA colors corresponding to each domain.
+        blend_colors (bool): Whether to blend colors for nodes with multiple domains. Defaults to False.
+        blend_gamma (float, optional): Gamma correction factor to be used for perceptual color blending.
+            This parameter is only relevant if blend_colors is True. Defaults to 2.2.
 
     Returns:
         np.ndarray: Array of composite colors for each node.
@@ -150,11 +167,38 @@ def _get_composite_node_colors(graph: NetworkGraph, domain_colors: np.ndarray) -
     num_nodes = len(graph.node_coordinates)
     # Initialize composite colors array with shape (number of nodes, 4) for RGBA
     composite_colors = np.zeros((num_nodes, 4))
-    # Assign colors to nodes based on domain_colors
-    for domain_id, nodes in graph.domain_id_to_node_ids_map.items():
-        color = domain_colors[domain_id]
-        for node in nodes:
-            composite_colors[node] = color
+
+    # If blending is not required, directly assign domain colors to nodes
+    if not blend_colors:
+        for domain_id, nodes in graph.domain_id_to_node_ids_map.items():
+            color = domain_colors[domain_id]
+            for node in nodes:
+                composite_colors[node] = color
+
+    # If blending is required
+    else:
+        for node, node_info in graph.node_id_to_domain_ids_and_enrichments_map.items():
+            domains = node_info["domains"]  # List of domain IDs
+            enrichments = node_info["enrichments"]  # List of enrichment values
+            # Filter domains and enrichments to keep only those with corresponding colors in domain_colors
+            filtered_domains_enrichments = [
+                (domain_id, enrichment)
+                for domain_id, enrichment in zip(domains, enrichments)
+                if domain_id in domain_colors
+            ]
+            # If no valid domains exist, skip this node
+            if not filtered_domains_enrichments:
+                continue
+
+            # Unpack filtered domains and enrichments
+            filtered_domains, filtered_enrichments = zip(*filtered_domains_enrichments)
+            # Get the colors corresponding to the valid filtered domains
+            colors = [domain_colors[domain_id] for domain_id in filtered_domains]
+            # Blend the colors using the given gamma (default is 2.2 if None)
+            gamma = blend_gamma if blend_gamma is not None else 2.2
+            composite_color = _blend_colors_perceptually(colors, filtered_enrichments, gamma)
+            # Assign the composite color to the node
+            composite_colors[node] = composite_color
 
     return composite_colors
 
@@ -163,7 +207,7 @@ def _get_colors(
     network,
     domain_id_to_node_ids_map,
     cmap: str = "gist_rainbow",
-    color: Union[str, list, tuple, np.ndarray, None] = None,
+    color: Union[str, List, Tuple, np.ndarray, None] = None,
     random_seed: int = 888,
 ) -> List[Tuple]:
     """Generate a list of RGBA colors based on domain centroids, ensuring that domains
@@ -173,7 +217,7 @@ def _get_colors(
         network (NetworkX graph): The graph representing the network.
         domain_id_to_node_ids_map (dict): Mapping from domain IDs to lists of node IDs.
         cmap (str, optional): The name of the colormap to use. Defaults to "gist_rainbow".
-        color (str, list, tuple, np.ndarray, or None, optional): A specific color or array of colors to use for the domains.
+        color (str, List, Tuple, np.ndarray, or None, optional): A specific color or array of colors to use for the domains.
             If None, the colormap will be used. Defaults to None.
         random_seed (int, optional): Seed for random number generation. Defaults to 888.
 
@@ -237,6 +281,33 @@ def _assign_distant_colors(dist_matrix, num_colors_to_generate):
     return color_positions
 
 
+def _blend_colors_perceptually(
+    colors: Union[List, Tuple, np.ndarray], enrichments: List[float], gamma: float = 2.2
+) -> Tuple[float, float, float, float]:
+    """Blends a list of RGBA colors using gamma correction for perceptually uniform color mixing.
+
+    Args:
+        colors (List, Tuple, np.ndarray): List of RGBA colors. Can be a list, tuple, or NumPy array of RGBA values.
+        enrichments (List[float]): Corresponding list of enrichment values.
+        gamma (float, optional): Gamma correction factor, default is 2.2 (typical for perceptual blending).
+
+    Returns:
+        Tuple[float, float, float, float]: The blended RGBA color.
+    """
+    # Normalize enrichments so they sum up to 1 (proportions)
+    total_enrichment = sum(enrichments)
+    proportions = [enrichment / total_enrichment for enrichment in enrichments]
+    # Convert colors to gamma-corrected space (apply gamma correction to RGB channels)
+    gamma_corrected_colors = [[channel**gamma for channel in color[:3]] for color in colors]
+    # Blend the colors in gamma-corrected space
+    blended_color = np.dot(proportions, gamma_corrected_colors)
+    # Convert back from gamma-corrected space to linear space (by applying inverse gamma correction)
+    blended_color = [channel ** (1 / gamma) for channel in blended_color]
+    # Average the alpha channel separately (no gamma correction on alpha)
+    alpha = np.dot(proportions, [color[3] for color in colors])
+    return tuple(blended_color + [alpha])
+
+
 def _transform_colors(
     colors: np.ndarray,
     enrichment_sums: np.ndarray,
@@ -283,14 +354,14 @@ def _transform_colors(
 
 
 def to_rgba(
-    color: Union[str, list, tuple, np.ndarray],
+    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 (str, list, tuple, np.ndarray): The color(s) to convert. Can be a string (e.g., 'red'), a list or tuple of RGB/RGBA values,
+        color (str, List, Tuple, np.ndarray): The color(s) to convert. Can be a string (e.g., 'red'), a list or tuple of RGB/RGBA values,
             or an `np.ndarray` of colors.
         alpha (float, None, optional): Alpha value (transparency) to apply. If provided, it overrides any existing alpha values found
             in color.
@@ -306,7 +377,7 @@ def 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]:
+        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:
@@ -325,8 +396,8 @@ def to_rgba(
     # Handle a single color (string or RGB/RGBA list/tuple)
     if (
         isinstance(color, str)
-        or isinstance(color, (list, tuple, np.ndarray))
-        and not any(isinstance(c, (str, list, tuple, np.ndarray)) for c in color)
+        or isinstance(color, (List, Tuple, np.ndarray))
+        and not any(isinstance(c, (str, List, Tuple, np.ndarray)) for c in color)
     ):
         rgba_color = convert_to_rgba(color)
         if num_repeats:
@@ -336,7 +407,7 @@ def to_rgba(
         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)):
+    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

risk/risk.py

@@ -362,7 +362,7 @@ class RISK(NetworkIO, AnnotationsIO):
 
         Args:
             graph (NetworkGraph): The graph to plot.
-            figsize (tuple, optional): Size of the figure. Defaults to (10, 10).
+            figsize (Tuple, optional): Size of the figure. Defaults to (10, 10).
             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.

{risk_network-0.0.8b17.dist-info → risk_network-0.0.8b19.dist-info}/METADATA

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

{risk_network-0.0.8b17.dist-info → risk_network-0.0.8b19.dist-info}/RECORD

@@ -1,27 +1,27 @@
-risk/__init__.py,sha256=pF-sA0CxulV6zIC6axfgeXWkkQGyVZGuoGF_u4RgoQM,113
+risk/__init__.py,sha256=jShwk2Z-jTDhGp_Y0GZIkJ1BoZFHOBTRGSKtBnS4Re0,113
 risk/constants.py,sha256=XInRaH78Slnw_sWgAsBFbUHkyA0h0jL0DKGuQNbOvjM,550
-risk/risk.py,sha256=slJXca_a726_D7oXwe765HaKTv3ZrOvhttyrWdCGPkA,21231
+risk/risk.py,sha256=FQp5269IsCh-flmSWIpV7sBmvbGHjlrSy89SkImkxCE,21231
 risk/annotations/__init__.py,sha256=vUpVvMRE5if01Ic8QY6M2Ae3EFGJHdugEe9PdEkAW4Y,138
 risk/annotations/annotations.py,sha256=7ilzXxrlHqN75J3q8WeHz0n79D-jAtUQx5czvC9wfIM,11303
 risk/annotations/io.py,sha256=TTXVJQgUGAlKpnGBcx7Dow146IGyozA03nSbl3S7M5M,9475
 risk/log/__init__.py,sha256=aDUz5LMFQsz0UlsQI2EdXtiBKRLfml1UMeZKC7QQIGU,134
 risk/log/config.py,sha256=m8pzj-hN4vI_2JdJUfyOoSvzT8_lhoIfBt27sKbnOes,4535
-risk/log/params.py,sha256=DUmsqPo9hi3rQHFgLTunP14I-vVoyQSFZbx5aSYmVts,6363
+risk/log/params.py,sha256=lgwhtO_pQWLd2_Cpu0T7BMwH5NiA4GFW0aP6d1_rJTE,6363
 risk/neighborhoods/__init__.py,sha256=tKKEg4lsbqFukpgYlUGxU_v_9FOqK7V0uvM9T2QzoL0,206
 risk/neighborhoods/community.py,sha256=stYYBXeZlGLMV-k8ckQeIqThT6v9y-S3hETobAo9590,6817
-risk/neighborhoods/domains.py,sha256=D5MUIghbwyKKCAE8PN_HXvsO9NxLTGejQmyEqetD1Bk,10743
+risk/neighborhoods/domains.py,sha256=DbhUFsvbr8wuvrNr7a0PaAJO-cdv6U3-T4CXB4-j5Qw,10930
 risk/neighborhoods/neighborhoods.py,sha256=M-wL4xB_BUTlSZg90swygO5NdrZ6hFUFqs6jsiZaqHk,18260
 risk/network/__init__.py,sha256=iEPeJdZfqp0toxtbElryB8jbz9_t_k4QQ3iDvKE8C_0,126
 risk/network/geometry.py,sha256=H1yGVVqgbfpzBzJwEheDLfvGLSA284jGQQTn612L4Vc,6759
-risk/network/graph.py,sha256=x5cur1meitkR0YuE5vGxX0s_IFa5wkx8z44f_C1vK7U,6509
-risk/network/io.py,sha256=u0PPcKjp6Xze--7eDOlvalYkjQ9S2sjiC-ac2476PUI,22942
+risk/network/graph.py,sha256=X63SNlWIov3oz0aMBMZfbHdmckbLqakZli5HP2Y5OdU,8519
+risk/network/io.py,sha256=w_9fUcZUVXAPRKGhLBc7xhIJs8l83szHiBQTdaNN0gk,22942
 risk/network/plot/__init__.py,sha256=MfmaXJgAZJgXZ2wrhK8pXwzETlcMaLChhWXKAozniAo,98
-risk/network/plot/canvas.py,sha256=JnjPQaryRb_J6LP36BT2-rlsbJO3T4tTBornL8Oqqbs,10778
-risk/network/plot/contour.py,sha256=8uwJ7K-Z6VMyr_uQ5VUyoQSqDHA7zDvR_nYAmLn60-I,14647
-risk/network/plot/labels.py,sha256=Gt2HIbYsC5QZNZa_Mk29hijDVv0_V0pXEl1IILaNKkY,44016
-risk/network/plot/network.py,sha256=9blVFeCp5x5XoGhPwOOdADegXC4gC72c2vrM2u4QPe0,13235
-risk/network/plot/plotter.py,sha256=lN-_GDXRk9V3IFu8q7QmPjJGBZiP0QYwSvU6dVVDV2E,5770
-risk/network/plot/utils/color.py,sha256=4W4EoQ_Fs4tmbngdczXnFkkAjvyYP5EV_P2Vu-TCCwY,15573
+risk/network/plot/canvas.py,sha256=hdrmGd2TCuii8wn6jDQfyJTI5YXDNGYFLiU4TyqAYbE,10778
+risk/network/plot/contour.py,sha256=ecmqNpyq512Koa14OGa58Z7EP_oUOxYfS4CuU1P9ras,15027
+risk/network/plot/labels.py,sha256=hoW6AL1dAUUt2WhWOEDu-Q28L_ojf13NkuxeqfHtqWc,44848
+risk/network/plot/network.py,sha256=nfTmQxx1YwS3taXwq8WSCfu6nfKFOyxj7T5605qLXVM,13615
+risk/network/plot/plotter.py,sha256=6534tKpOb2ZXn1imu_CDM_BkLaThi50eaRsJQyjsm84,5770
+risk/network/plot/utils/color.py,sha256=Y_AUIoj_zKzChz_aC-WoYqiZ5P4qil3k7lmm4MHDaPY,19606
 risk/network/plot/utils/layout.py,sha256=znssSqe2VZzzSz47hLZtTuXwMTpHR9b8lkQPL0BX7OA,1950
 risk/stats/__init__.py,sha256=WcgoETQ-hS0LQqKRsAMIPtP15xZ-4eul6VUBuUx4Wzc,220
 risk/stats/hypergeom.py,sha256=o6Qnj31gCAKxr2uQirXrbv7XvdDJGEq69MFW-ubx_hA,2272
@@ -30,8 +30,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.8b17.dist-info/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
-risk_network-0.0.8b17.dist-info/METADATA,sha256=HmkNnAzSs7IdEGzYirOsrzy0euWVd0Ezn4OztCtXhnE,47498
-risk_network-0.0.8b17.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
-risk_network-0.0.8b17.dist-info/top_level.txt,sha256=NX7C2PFKTvC1JhVKv14DFlFAIFnKc6Lpsu1ZfxvQwVw,5
-risk_network-0.0.8b17.dist-info/RECORD,,
+risk_network-0.0.8b19.dist-info/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+risk_network-0.0.8b19.dist-info/METADATA,sha256=zRIBsg3MXtdrk10GQ2Byns8YWleTkv0taFT67hCrBl4,47498
+risk_network-0.0.8b19.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
+risk_network-0.0.8b19.dist-info/top_level.txt,sha256=NX7C2PFKTvC1JhVKv14DFlFAIFnKc6Lpsu1ZfxvQwVw,5
+risk_network-0.0.8b19.dist-info/RECORD,,