risk-network 0.0.8b1__py3-none-any.whl → 0.0.8b3__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.1"
+__version__ = "0.0.8-beta.3"

risk/network/graph.py

@@ -148,27 +148,6 @@ class NetworkGraph:
 
         return transformed_colors
 
-    def _get_composite_node_colors(self, domain_colors: np.ndarray) -> np.ndarray:
-        """Generate composite colors for nodes based on domain colors and counts.
-
-        Args:
-            domain_colors (np.ndarray): Array of colors corresponding to each domain.
-
-        Returns:
-            np.ndarray: Array of composite colors for each node.
-        """
-        # Determine the number of nodes
-        num_nodes = len(self.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 self.domain_id_to_node_ids_map.items():
-            color = domain_colors[domain_id]
-            for node in nodes:
-                composite_colors[node] = color
-
-        return composite_colors
-
     def _get_domain_colors(
         self,
         cmap: str = "gist_rainbow",
@@ -193,9 +172,29 @@ class NetworkGraph:
             color=color,
             random_seed=random_seed,
         )
-        self.network, self.domain_id_to_node_ids_map
         return dict(zip(self.domain_id_to_node_ids_map.keys(), domain_colors))
 
+    def _get_composite_node_colors(self, domain_colors: np.ndarray) -> np.ndarray:
+        """Generate composite colors for nodes based on domain colors and counts.
+
+        Args:
+            domain_colors (np.ndarray): Array of colors corresponding to each domain.
+
+        Returns:
+            np.ndarray: Array of composite colors for each node.
+        """
+        # Determine the number of nodes
+        num_nodes = len(self.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 self.domain_id_to_node_ids_map.items():
+            color = domain_colors[domain_id]
+            for node in nodes:
+                composite_colors[node] = color
+
+        return composite_colors
+
 
 def _transform_colors(
     colors: np.ndarray,

risk/network/plot.py

@@ -17,6 +17,8 @@ from scipy.stats import gaussian_kde
 from risk.log import params, logger
 from risk.network.graph import NetworkGraph
 
+TERM_DELIMITER = "::::"  # String used to separate multiple domain terms when constructing composite domain labels
+
 
 class NetworkPlotter:
     """A class for visualizing network graphs with customizable options.
@@ -678,10 +680,10 @@ class NetworkPlotter:
         arrow_base_shrink: float = 0.0,
         arrow_tip_shrink: float = 0.0,
         max_labels: Union[int, None] = None,
-        max_words: int = 10,
-        min_words: int = 1,
-        max_word_length: int = 20,
-        min_word_length: int = 1,
+        max_label_lines: Union[int, None] = None,
+        min_label_lines: int = 1,
+        max_chars_per_line: Union[int, None] = None,
+        min_chars_per_line: int = 1,
         words_to_omit: Union[List, None] = None,
         overlay_ids: bool = False,
         ids_to_keep: Union[List, Tuple, np.ndarray, None] = None,
@@ -703,10 +705,10 @@ class NetworkPlotter:
             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.
             max_labels (int, optional): Maximum number of labels to plot. Defaults to None (no limit).
-            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.
-            max_word_length (int, optional): Maximum number of characters in a word to display. Defaults to 20.
-            min_word_length (int, optional): Minimum number of characters in a word to display. Defaults to 1.
+            max_label_lines (int, optional): Maximum number of lines in a label. Defaults to None (no limit).
+            min_label_lines (int, optional): Minimum number of lines in a label. Defaults to 1.
+            max_chars_per_line (int, optional): Maximum number of characters in a line to display. Defaults to None (no limit).
+            min_chars_per_line (int, optional): Minimum number of characters in a line to display. Defaults to 1.
             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,
@@ -735,28 +737,26 @@ class NetworkPlotter:
             label_arrow_base_shrink=arrow_base_shrink,
             label_arrow_tip_shrink=arrow_tip_shrink,
             label_max_labels=max_labels,
-            label_max_words=max_words,
-            label_min_words=min_words,
-            label_max_word_length=max_word_length,
-            label_min_word_length=min_word_length,
+            label_min_label_lines=min_label_lines,
+            label_max_label_lines=max_label_lines,
+            label_max_chars_per_line=max_chars_per_line,
+            label_min_chars_per_line=min_chars_per_line,
             label_words_to_omit=words_to_omit,
             label_overlay_ids=overlay_ids,
             label_ids_to_keep=ids_to_keep,
             label_ids_to_replace=ids_to_replace,
         )
 
+        # Convert ids_to_keep to a tuple if it is not None
+        ids_to_keep = tuple(ids_to_keep) if ids_to_keep else tuple()
         # Set max_labels to the total number of domains if not provided (None)
         if max_labels is None:
             max_labels = len(self.graph.domain_id_to_node_ids_map)
-
-        # Convert colors to RGBA using the _to_rgba helper function
-        fontcolor = _to_rgba(
-            fontcolor, fontalpha, num_repeats=len(self.graph.domain_id_to_node_ids_map)
-        )
-        arrow_color = _to_rgba(
-            arrow_color, arrow_alpha, num_repeats=len(self.graph.domain_id_to_node_ids_map)
-        )
-
+        # Set max_label_lines and max_chars_per_line to large numbers if not provided (None)
+        if max_label_lines is None:
+            max_label_lines = int(1e6)
+        if max_chars_per_line is None:
+            max_chars_per_line = int(1e6)
         # Normalize words_to_omit to lowercase
         if words_to_omit:
             words_to_omit = set(word.lower() for word in words_to_omit)
@@ -768,81 +768,47 @@ class NetworkPlotter:
                 domain_centroids[domain_id] = self._calculate_domain_centroid(node_ids)
 
         # Initialize dictionaries and lists for valid indices
-        valid_indices = []
-        filtered_domain_centroids = {}
-        filtered_domain_terms = {}
+        valid_indices = []  # List of valid indices to plot colors and arrows
+        filtered_domain_centroids = {}  # Filtered domain centroids to plot
+        filtered_domain_terms = {}  # Filtered domain terms to plot
         # Handle the ids_to_keep logic
         if ids_to_keep:
-            # Convert ids_to_keep to remove accidental duplicates
-            ids_to_keep = set(ids_to_keep)
-            # Check if the number of provided ids_to_keep exceeds max_labels
-            if max_labels is not None and len(ids_to_keep) > max_labels:
-                raise ValueError(
-                    f"Number of provided IDs ({len(ids_to_keep)}) exceeds max_labels ({max_labels})."
-                )
-
-            # Process the specified IDs first
-            for domain in ids_to_keep:
-                if (
-                    domain in self.graph.domain_id_to_domain_terms_map
-                    and domain in domain_centroids
-                ):
-                    # Handle ids_to_replace logic here for ids_to_keep
-                    if ids_to_replace and domain in ids_to_replace:
-                        terms = ids_to_replace[domain].split(" ")
-                    else:
-                        terms = self.graph.domain_id_to_domain_terms_map[domain].split(" ")
-
-                    # Apply words_to_omit, word length constraints, and max_words
-                    if words_to_omit:
-                        terms = [term for term in terms if term.lower() not in words_to_omit]
-                    terms = [
-                        term for term in terms if min_word_length <= len(term) <= max_word_length
-                    ]
-                    terms = terms[:max_words]
-
-                    # Check if the domain passes the word count condition
-                    if len(terms) >= min_words:
-                        filtered_domain_centroids[domain] = domain_centroids[domain]
-                        filtered_domain_terms[domain] = " ".join(terms)
-                        valid_indices.append(
-                            list(domain_centroids.keys()).index(domain)
-                        )  # Track the valid index
+            # Process the ids_to_keep first INPLACE
+            self._process_ids_to_keep(
+                ids_to_keep=ids_to_keep,
+                domain_centroids=domain_centroids,
+                ids_to_replace=ids_to_replace,
+                words_to_omit=words_to_omit,
+                max_labels=max_labels,
+                min_label_lines=min_label_lines,
+                max_label_lines=max_label_lines,
+                min_chars_per_line=min_chars_per_line,
+                max_chars_per_line=max_chars_per_line,
+                filtered_domain_centroids=filtered_domain_centroids,
+                filtered_domain_terms=filtered_domain_terms,
+                valid_indices=valid_indices,
+            )
 
         # Calculate remaining labels to plot after processing ids_to_keep
         remaining_labels = (
-            max_labels - len(ids_to_keep) if ids_to_keep and max_labels else max_labels
+            max_labels - len(valid_indices) if valid_indices and max_labels else max_labels
         )
-        # Process remaining domains to fill in additional labels, if there are slots left
+        # Process remaining domains INPLACE to fill in additional labels, if there are slots left
         if remaining_labels and remaining_labels > 0:
-            for idx, (domain, centroid) in enumerate(domain_centroids.items()):
-                # Check if the domain is NaN and continue if true
-                if pd.isna(domain) or (isinstance(domain, float) and np.isnan(domain)):
-                    continue  # Skip NaN domains
-                if ids_to_keep and domain in ids_to_keep:
-                    continue  # Skip domains already handled by ids_to_keep
-
-                # Handle ids_to_replace logic first
-                if ids_to_replace and domain in ids_to_replace:
-                    terms = ids_to_replace[domain].split(" ")
-                else:
-                    terms = self.graph.domain_id_to_domain_terms_map[domain].split(" ")
-
-                # Apply words_to_omit, word length constraints, and max_words
-                if words_to_omit:
-                    terms = [term for term in terms if term.lower() not in words_to_omit]
-
-                terms = [term for term in terms if min_word_length <= len(term) <= max_word_length]
-                terms = terms[:max_words]
-                # Check if the domain passes the word count condition
-                if len(terms) >= min_words:
-                    filtered_domain_centroids[domain] = centroid
-                    filtered_domain_terms[domain] = " ".join(terms)
-                    valid_indices.append(idx)  # Track the valid index
-
-                # Stop once we've reached the max_labels limit
-                if len(filtered_domain_centroids) >= max_labels:
-                    break
+            self._process_remaining_domains(
+                domain_centroids=domain_centroids,
+                ids_to_keep=ids_to_keep,
+                ids_to_replace=ids_to_replace,
+                words_to_omit=words_to_omit,
+                remaining_labels=remaining_labels,
+                min_chars_per_line=min_chars_per_line,
+                max_chars_per_line=max_chars_per_line,
+                max_label_lines=max_label_lines,
+                min_label_lines=min_label_lines,
+                filtered_domain_centroids=filtered_domain_centroids,
+                filtered_domain_terms=filtered_domain_terms,
+                valid_indices=valid_indices,
+            )
 
         # Calculate the bounding box around the network
         center, radius = _calculate_bounding_box(self.graph.node_coordinates, radius_margin=scale)
@@ -850,11 +816,19 @@ class NetworkPlotter:
         best_label_positions = _calculate_best_label_positions(
             filtered_domain_centroids, center, radius, offset
         )
+        # Convert colors to RGBA using the _to_rgba helper function
+        fontcolor = _to_rgba(
+            fontcolor, fontalpha, num_repeats=len(self.graph.domain_id_to_node_ids_map)
+        )
+        arrow_color = _to_rgba(
+            arrow_color, arrow_alpha, num_repeats=len(self.graph.domain_id_to_node_ids_map)
+        )
 
         # Annotate the network with labels
         for idx, (domain, pos) in zip(valid_indices, best_label_positions.items()):
             centroid = filtered_domain_centroids[domain]
-            annotations = filtered_domain_terms[domain].split(" ")[:max_words]
+            # Split by special key TERM_DELIMITER to split annotation into multiple lines
+            annotations = filtered_domain_terms[domain].split(TERM_DELIMITER)
             self.ax.annotate(
                 "\n".join(annotations),
                 xy=centroid,
@@ -1001,6 +975,204 @@ class NetworkPlotter:
         domain_central_node = node_positions[central_node_idx]
         return domain_central_node
 
+    def _process_ids_to_keep(
+        self,
+        ids_to_keep: Union[List[str], Tuple[str], np.ndarray],
+        domain_centroids: Dict[str, np.ndarray],
+        ids_to_replace: Union[Dict[str, str], None],
+        words_to_omit: Union[List[str], None],
+        max_labels: Union[int, None],
+        min_label_lines: int,
+        max_label_lines: int,
+        min_chars_per_line: int,
+        max_chars_per_line: int,
+        filtered_domain_centroids: Dict[str, np.ndarray],
+        filtered_domain_terms: Dict[str, str],
+        valid_indices: List[int],
+    ) -> None:
+        """Process the ids_to_keep, apply filtering, and store valid domain centroids and terms.
+
+        Args:
+            ids_to_keep (list, tuple, or np.ndarray, optional): IDs of domains that must be labeled.
+            domain_centroids (dict): Mapping of domains to their centroids.
+            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.
+            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.
+            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.
+            filtered_domain_centroids (dict): Dictionary to store filtered domain centroids (output).
+            filtered_domain_terms (dict): Dictionary to store filtered domain terms (output).
+            valid_indices (list): List to store valid indices (output).
+
+        Note:
+            The `filtered_domain_centroids`, `filtered_domain_terms`, and `valid_indices` are modified in-place.
+
+        Raises:
+            ValueError: If the number of provided `ids_to_keep` exceeds `max_labels`.
+        """
+        # Check if the number of provided ids_to_keep exceeds max_labels
+        if max_labels is not None and len(ids_to_keep) > max_labels:
+            raise ValueError(
+                f"Number of provided IDs ({len(ids_to_keep)}) exceeds max_labels ({max_labels})."
+            )
+
+        # Process each domain in ids_to_keep
+        for domain in ids_to_keep:
+            if domain in self.graph.domain_id_to_domain_terms_map and domain in domain_centroids:
+                domain_terms = self._process_terms(
+                    domain=domain,
+                    ids_to_replace=ids_to_replace,
+                    words_to_omit=words_to_omit,
+                    max_label_lines=max_label_lines,
+                    min_chars_per_line=min_chars_per_line,
+                    max_chars_per_line=max_chars_per_line,
+                )
+                num_domain_lines = len(domain_terms.split(TERM_DELIMITER))
+                # Check if the number of lines in the label is greater than or equal to the minimum
+                if num_domain_lines >= min_label_lines:
+                    filtered_domain_terms[domain] = domain_terms
+                    filtered_domain_centroids[domain] = domain_centroids[domain]
+                    valid_indices.append(list(domain_centroids.keys()).index(domain))
+
+    def _process_remaining_domains(
+        self,
+        domain_centroids: Dict[str, np.ndarray],
+        ids_to_keep: Union[List[str], Tuple[str], np.ndarray],
+        ids_to_replace: Union[Dict[str, str], None],
+        words_to_omit: Union[List[str], None],
+        remaining_labels: int,
+        min_label_lines: int,
+        max_label_lines: int,
+        min_chars_per_line: int,
+        max_chars_per_line: int,
+        filtered_domain_centroids: Dict[str, np.ndarray],
+        filtered_domain_terms: Dict[str, str],
+        valid_indices: List[int],
+    ) -> None:
+        """Process remaining domains to fill in additional labels, respecting the remaining_labels limit.
+
+        Args:
+            domain_centroids (dict): Mapping of domains to their centroids.
+            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.
+            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.
+            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.
+            filtered_domain_centroids (dict): Dictionary to store filtered domain centroids (output).
+            filtered_domain_terms (dict): Dictionary to store filtered domain terms (output).
+            valid_indices (list): List to store valid indices (output).
+        """
+        # Counter to track how many labels have been created
+        label_count = 0
+        # Collect domains not in ids_to_keep
+        remaining_domains = {
+            domain: centroid
+            for domain, centroid in domain_centroids.items()
+            if domain not in ids_to_keep and not pd.isna(domain)
+        }
+
+        # Function to calculate distance between two centroids
+        def calculate_distance(centroid1, centroid2):
+            return np.linalg.norm(centroid1 - centroid2)
+
+        # Find the farthest apart domains using centroids
+        if remaining_domains and remaining_labels:
+            selected_domains = []
+            first_domain = next(iter(remaining_domains))  # Pick the first domain to start
+            selected_domains.append(first_domain)
+
+            while len(selected_domains) < remaining_labels:
+                farthest_domain = None
+                max_distance = -1
+                # Find the domain farthest from any already selected domain
+                for candidate_domain, candidate_centroid in remaining_domains.items():
+                    if candidate_domain in selected_domains:
+                        continue
+
+                    # Calculate the minimum distance to any selected domain
+                    min_distance = min(
+                        calculate_distance(candidate_centroid, remaining_domains[dom])
+                        for dom in selected_domains
+                    )
+                    # Update the farthest domain if the minimum distance is greater
+                    if min_distance > max_distance:
+                        max_distance = min_distance
+                        farthest_domain = candidate_domain
+
+                # Add the farthest domain to the selected domains
+                if farthest_domain:
+                    selected_domains.append(farthest_domain)
+                else:
+                    break  # No more domains to select
+
+        # Process the selected domains and add to filtered lists
+        for domain in selected_domains:
+            centroid = remaining_domains[domain]
+            domain_terms = self._process_terms(
+                domain=domain,
+                ids_to_replace=ids_to_replace,
+                words_to_omit=words_to_omit,
+                max_label_lines=max_label_lines,
+                min_chars_per_line=min_chars_per_line,
+                max_chars_per_line=max_chars_per_line,
+            )
+            num_domain_lines = len(domain_terms.split(TERM_DELIMITER))
+            # Check if the number of lines in the label is greater than or equal to the minimum
+            if num_domain_lines >= min_label_lines:
+                filtered_domain_centroids[domain] = centroid
+                filtered_domain_terms[domain] = domain_terms
+                valid_indices.append(list(domain_centroids.keys()).index(domain))
+
+                label_count += 1
+                if label_count >= remaining_labels:
+                    break
+
+    def _process_terms(
+        self,
+        domain: str,
+        ids_to_replace: Union[Dict[str, str], None],
+        words_to_omit: Union[List[str], None],
+        max_label_lines: int,
+        min_chars_per_line: int,
+        max_chars_per_line: int,
+    ) -> List[str]:
+        """Process terms for a domain, applying word length constraints and combining words where appropriate.
+
+        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.
+            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.
+
+        Returns:
+            list: Processed terms, with words combined if necessary to fit within constraints.
+        """
+        # Handle ids_to_replace logic
+        if ids_to_replace and domain in ids_to_replace:
+            terms = ids_to_replace[domain].split(" ")
+        else:
+            terms = self.graph.domain_id_to_domain_terms_map[domain].split(" ")
+
+        # Apply words_to_omit and word length constraints
+        if words_to_omit:
+            terms = [
+                term
+                for term in terms
+                if term.lower() not in words_to_omit and len(term) >= min_chars_per_line
+            ]
+
+        # Use the combine_words function directly to handle word combinations and length constraints
+        compressed_terms = _combine_words(tuple(terms), max_chars_per_line, max_label_lines)
+
+        return compressed_terms
+
     def get_annotated_node_colors(
         self,
         cmap: str = "gist_rainbow",
@@ -1254,7 +1426,9 @@ def _to_rgba(
     # Handle array of colors case (including strings, RGB, and RGBA)
     elif isinstance(color, (list, tuple, np.ndarray)):
         rgba_colors = []
-        for c in color:
+        for i in range(num_repeats):
+            # Reiterate over the colors if the number of repeats exceeds the number of colors
+            c = color[i % len(color)]
             # Ensure each element is either a valid string or a list/tuple of length 3 (RGB) or 4 (RGBA)
             if isinstance(c, str) or (
                 isinstance(c, (list, tuple, np.ndarray)) and len(c) in [3, 4]
@@ -1313,6 +1487,59 @@ def _calculate_bounding_box(
     return center, radius
 
 
+def _combine_words(words: List[str], max_length: int, max_label_lines: int) -> str:
+    """Combine words to fit within the max_length and max_label_lines constraints,
+    and separate the final output by ':' for plotting.
+
+    Args:
+        words (List[str]): List of words to combine.
+        max_length (int): Maximum allowed length for a combined line.
+        max_label_lines (int): Maximum number of lines in a label.
+
+    Returns:
+        str: String of combined words separated by ':' for line breaks.
+    """
+
+    def try_combinations(words_batch: List[str]) -> List[str]:
+        """Try to combine words within a batch and return them with combined words separated by ':'."""
+        combined_lines = []
+        i = 0
+        while i < len(words_batch):
+            current_word = words_batch[i]
+            combined_word = current_word  # Start with the current word
+            # Try to combine more words if possible, and ensure the combination fits within max_length
+            for j in range(i + 1, len(words_batch)):
+                next_word = words_batch[j]
+                if len(combined_word) + len(next_word) + 2 <= max_length:  # +2 for ', '
+                    combined_word = f"{combined_word} {next_word}"
+                    i += 1  # Move past the combined word
+                else:
+                    break  # Stop combining if the length is exceeded
+
+            combined_lines.append(combined_word)  # Add the combined word or single word
+            i += 1  # Move to the next word
+
+            # Stop if we've reached the max_label_lines limit
+            if len(combined_lines) >= max_label_lines:
+                break
+
+        return combined_lines
+
+    # Main logic: start with max_label_lines number of words
+    combined_lines = try_combinations(words[:max_label_lines])
+    remaining_words = words[max_label_lines:]  # Remaining words after the initial batch
+
+    # Continue pulling more words until we fill the lines
+    while remaining_words and len(combined_lines) < max_label_lines:
+        available_slots = max_label_lines - len(combined_lines)
+        words_to_add = remaining_words[:available_slots]
+        remaining_words = remaining_words[available_slots:]
+        combined_lines += try_combinations(words_to_add)
+
+    # Join the final combined lines with TERM_DELIMITER, a special separator for line breaks
+    return TERM_DELIMITER.join(combined_lines[:max_label_lines])
+
+
 def _calculate_best_label_positions(
     filtered_domain_centroids: Dict[str, Any], center: np.ndarray, radius: float, offset: float
 ) -> Dict[str, Any]:

{risk_network-0.0.8b1.dist-info → risk_network-0.0.8b3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: risk-network
-Version: 0.0.8b1
+Version: 0.0.8b3
 Summary: A Python package for biological network analysis
 Author: Ira Horecka
 Author-email: Ira Horecka <ira89@icloud.com>
@@ -709,42 +709,105 @@ Requires-Dist: statsmodels
 Requires-Dist: threadpoolctl
 Requires-Dist: tqdm
 
-<p align="center">
-  <img src="https://i.imgur.com/Fo9EmnK.png" width="400" />
-</p>
+# RISK
 
 <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.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>
+  <img src="https://i.imgur.com/8TleEJs.png" width="50%" />
 </p>
 
-## RISK
+<br>
+
+![Python](https://img.shields.io/badge/python-3.8%2B-yellow)
+[![pypiv](https://img.shields.io/pypi/v/risk-network.svg)](https://pypi.python.org/pypi/risk-network)
+![License](https://img.shields.io/badge/license-GPLv3-purple)
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.xxxxxxx.svg)](https://doi.org/10.5281/zenodo.xxxxxxx)
+![Downloads](https://img.shields.io/pypi/dm/risk-network)
+![Platforms](https://img.shields.io/badge/platform-linux%20%7C%20macos%20%7C%20windows-lightgrey)
+
+**RISK (RISK Infers Spatial Kinships)** is a next-generation tool designed to streamline the analysis of biological and non-biological networks. RISK enhances network analysis with its modular architecture, extensive file format support, and advanced clustering algorithms. It simplifies the creation of publication-quality figures, making it an important tool for researchers across disciplines.
 
-#### RISK Infers Spatial Kinships
+## Documentation and Tutorial
+
+- **Documentation**: Comprehensive documentation is available at [Documentation link].
+- **Tutorial**: An interactive Jupyter notebook tutorial can be found at [Tutorial link].
+We highly recommend new users to consult the documentation and tutorial early on to fully leverage RISK's capabilities.
+
+## Installation
 
-RISK is a software tool for visualizing spatial relationships in networks. It aims to enhance network analysis by integrating advanced network annotation algorithms, such as Louvain and Markov Clustering, to identify key functional modules and pathways.
+RISK is compatible with Python 3.8 and later versions and operates on all major operating systems. Install RISK via pip:
+
+```bash
+pip install risk-network
+```
 
 ## Features
 
-- Spatial analysis of biological networks
-- Functional enrichment detection
-- Optimized performance
+- **Comprehensive Network Analysis**: Analyze biological networks such as protein–protein interaction (PPI) and gene regulatory networks, as well as non-biological networks.
+- **Advanced Clustering Algorithms**: Utilize algorithms like Louvain, Markov Clustering, Spinglass, and more to identify key functional modules.
+- **Flexible Visualization**: Generate clear, publication-quality figures with customizable node and edge attributes, including colors, shapes, sizes, and labels.
+- **Efficient Data Handling**: Optimized for large datasets, supporting multiple file formats such as JSON, CSV, TSV, Excel, Cytoscape, and GPickle.
+- **Statistical Analysis**: Integrated statistical tests, including hypergeometric, permutation, and Poisson tests, to assess the significance of enriched regions.
+- **Cross-Domain Applicability**: Suitable for network analysis across biological and non-biological domains, including social and communication networks.
 
-## Example
+## Example Usage
 
-*Saccharomyces cerevisiae* proteins oriented by physical interactions discovered through affinity enrichment and mass spectrometry (Michaelis et al., 2023).
+We applied RISK to a *Saccharomyces cerevisiae* protein–protein interaction network, revealing both established and novel functional relationships. The visualization below highlights key biological processes such as ribosomal assembly and mitochondrial organization.
 
-![PPI Network Demo](https://i.imgur.com/NnyK6nO.png)
+![RISK Main Figure](https://i.imgur.com/TUVfvfH.jpeg)
 
-## Installation
+RISK successfully detected both known and novel functional clusters within the yeast interactome. Clusters related to Golgi transport and actin nucleation were clearly defined and closely located, showcasing RISK's ability to map well-characterized interactions. Additionally, RISK identified links between mRNA processing pathways and vesicle trafficking proteins, consistent with recent studies demonstrating the role of vesicles in mRNA localization and stability.
+
+## Citation
+
+If you use RISK in your research, please cite the following:
+
+**Horecka**, *et al.*, "RISK: a next-generation tool for biological network annotation and visualization", **[Journal Name]**, 2024. DOI: [10.1234/zenodo.xxxxxxx](https://doi.org/10.1234/zenodo.xxxxxxx)
+
+## Software Architecture and Implementation
 
-Coming soon...
+RISK features a streamlined, modular architecture designed to meet diverse research needs. Each module focuses on a specific task—such as network input/output, statistical analysis, or visualization—ensuring ease of adaptation and extension. This design enhances flexibility and reduces development overhead for users integrating RISK into their workflows.
 
-## Usage
+### Supported Data Formats
 
-Coming soon...
+- **Input/Output**: JSON, CSV, TSV, Excel, Cytoscape, GPickle.
+- **Visualization Outputs**: SVG, PNG, PDF.
+
+### Clustering Algorithms
+
+- **Available Algorithms**:
+  - Greedy Modularity
+  - Label Propagation
+  - Louvain
+  - Markov Clustering
+  - Spinglass
+  - Walktrap
+- **Distance Metrics**: Supports both spherical and Euclidean distance metrics.
+
+### Statistical Tests
+
+- **Hypergeometric Test**
+- **Permutation Test** (single- or multi-process modes)
+- **Poisson Test**
+
+## Performance and Efficiency
+
+In benchmarking tests using the yeast interactome network, RISK demonstrated substantial improvements over previous tools in both computational performance and memory efficiency. RISK processed the dataset approximately **3.25 times faster**, reducing CPU time by **69%**, and required **25% less peak memory usage**, underscoring its efficient utilization of computational resources.
+
+## Contributing
+
+We welcome contributions from the community. Please use the following resources:
+
+- [Issues Tracker](https://github.com/irahorecka/risk/issues)
+- [Source Code](https://github.com/irahorecka/risk/tree/main/risk)
+
+## Support
+
+If you encounter issues or have suggestions for new features, please use the [Issues Tracker](https://github.com/irahorecka/risk/issues) on GitHub.
 
 ## License
 
-This project is licensed under the GPL-3.0 license.
+RISK is freely available as open-source software under the [GNU General Public License v3.0](https://www.gnu.org/licenses/gpl-3.0.en.html).
+
+---
+
+**Note**: For detailed documentation and to access the interactive tutorial, please visit the links provided in the [Documentation and Tutorial](#documentation-and-tutorial) section.

{risk_network-0.0.8b1.dist-info → risk_network-0.0.8b3.dist-info}/RECORD

@@ -1,4 +1,4 @@
-risk/__init__.py,sha256=UNSdF3ch5eG5kY1NsOrjzDZOS-HRak9ASoBVXBkvCAM,112
+risk/__init__.py,sha256=qjjV3tZUr6CjlV98T9q2oJFgjLB5qxwKFQm6MkwQc2s,112
 risk/constants.py,sha256=XInRaH78Slnw_sWgAsBFbUHkyA0h0jL0DKGuQNbOvjM,550
 risk/risk.py,sha256=FaQhDCBZxZSAXJsScH0rSbjjCTNZA5vgf9rJj1GHW44,20924
 risk/annotations/__init__.py,sha256=vUpVvMRE5if01Ic8QY6M2Ae3EFGJHdugEe9PdEkAW4Y,138
@@ -13,9 +13,9 @@ risk/neighborhoods/domains.py,sha256=Ov52EEr-tWqy96y8_0tJ9f1K8FI-8tZQxHR7a59A1k8
 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=_LEoom4EEowGALuJKSXcev9RAAHu2FqIeq3u7mkifW0,16479
+risk/network/graph.py,sha256=EwD4-1THC5YNdP6PY01Oe35k2QYYqtZpxWraPVH6wa4,16426
 risk/network/io.py,sha256=kY7HqmL3wa1NnqHu61_G8IpT21qpBijpAZ4ixmsseJA,22911
-risk/network/plot.py,sha256=9GcLKkH3CMEtraYnfdLXNJCi04rBQCjw4T6Q8k5yNOI,67091
+risk/network/plot.py,sha256=uDRQTza5scBJKFTlcayFgA7nzWfz-c075J_V7k8eyBI,78285
 risk/stats/__init__.py,sha256=WcgoETQ-hS0LQqKRsAMIPtP15xZ-4eul6VUBuUx4Wzc,220
 risk/stats/hypergeom.py,sha256=o6Qnj31gCAKxr2uQirXrbv7XvdDJGEq69MFW-ubx_hA,2272
 risk/stats/poisson.py,sha256=8x9hB4DCukq4gNIlIKO-c_jYG1-BTwTX53oLauFyfj8,1793
@@ -23,8 +23,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.8b1.dist-info/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
-risk_network-0.0.8b1.dist-info/METADATA,sha256=E0T1xFQXaQfe3oH0ZW7fAukDoB3QbvzswcLc0oczpqA,43142
-risk_network-0.0.8b1.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-risk_network-0.0.8b1.dist-info/top_level.txt,sha256=NX7C2PFKTvC1JhVKv14DFlFAIFnKc6Lpsu1ZfxvQwVw,5
-risk_network-0.0.8b1.dist-info/RECORD,,
+risk_network-0.0.8b3.dist-info/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+risk_network-0.0.8b3.dist-info/METADATA,sha256=cUY2Uidk8Bqhj1sWs25aIACjI2QrMXhL42oZQdHSBMo,47450
+risk_network-0.0.8b3.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+risk_network-0.0.8b3.dist-info/top_level.txt,sha256=NX7C2PFKTvC1JhVKv14DFlFAIFnKc6Lpsu1ZfxvQwVw,5
+risk_network-0.0.8b3.dist-info/RECORD,,