risk-network 0.0.7b11__tar.gz → 0.0.8b0__tar.gz

{risk_network-0.0.7b11 → risk_network-0.0.8b0}/PKG-INFO

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

{risk_network-0.0.7b11 → risk_network-0.0.8b0}/risk/__init__.py

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

{risk_network-0.0.7b11 → risk_network-0.0.8b0}/risk/annotations/annotations.py

@@ -4,7 +4,7 @@ risk/annotations/annotations
 """
 
 from collections import Counter
-from itertools import compress, permutations
+from itertools import compress
 from typing import Any, Dict, List, Set
 
 import networkx as nx

{risk_network-0.0.7b11 → risk_network-0.0.8b0}/risk/annotations/io.py

@@ -25,12 +25,12 @@ class AnnotationsIO:
     def __init__(self):
         pass
 
-    def load_json_annotation(self, filepath: str, network: nx.Graph) -> Dict[str, Any]:
+    def load_json_annotation(self, network: nx.Graph, filepath: str) -> Dict[str, Any]:
         """Load annotations from a JSON file and convert them to a DataFrame.
 
         Args:
-            filepath (str): Path to the JSON annotations file.
             network (NetworkX graph): The network to which the annotations are related.
+            filepath (str): Path to the JSON annotations file.
 
         Returns:
             dict: A dictionary containing ordered nodes, ordered annotations, and the annotations matrix.
@@ -49,8 +49,8 @@ class AnnotationsIO:
 
     def load_excel_annotation(
         self,
-        filepath: str,
         network: nx.Graph,
+        filepath: str,
         label_colname: str = "label",
         nodes_colname: str = "nodes",
         sheet_name: str = "Sheet1",
@@ -59,8 +59,8 @@ class AnnotationsIO:
         """Load annotations from an Excel file and associate them with the network.
 
         Args:
-            filepath (str): Path to the Excel annotations file.
             network (nx.Graph): The NetworkX graph to which the annotations are related.
+            filepath (str): Path to the Excel annotations file.
             label_colname (str): Name of the column containing the labels (e.g., GO terms).
             nodes_colname (str): Name of the column containing the nodes associated with each label.
             sheet_name (str, optional): The name of the Excel sheet to load (default is 'Sheet1').
@@ -87,8 +87,8 @@ class AnnotationsIO:
 
     def load_csv_annotation(
         self,
-        filepath: str,
         network: nx.Graph,
+        filepath: str,
         label_colname: str = "label",
         nodes_colname: str = "nodes",
         nodes_delimiter: str = ";",
@@ -96,8 +96,8 @@ class AnnotationsIO:
         """Load annotations from a CSV file and associate them with the network.
 
         Args:
-            filepath (str): Path to the CSV annotations file.
             network (nx.Graph): The NetworkX graph to which the annotations are related.
+            filepath (str): Path to the CSV annotations file.
             label_colname (str): Name of the column containing the labels (e.g., GO terms).
             nodes_colname (str): Name of the column containing the nodes associated with each label.
             nodes_delimiter (str, optional): Delimiter used to separate multiple nodes within the nodes column (default is ';').
@@ -121,8 +121,8 @@ class AnnotationsIO:
 
     def load_tsv_annotation(
         self,
-        filepath: str,
         network: nx.Graph,
+        filepath: str,
         label_colname: str = "label",
         nodes_colname: str = "nodes",
         nodes_delimiter: str = ";",
@@ -130,8 +130,8 @@ class AnnotationsIO:
         """Load annotations from a TSV file and associate them with the network.
 
         Args:
-            filepath (str): Path to the TSV annotations file.
             network (nx.Graph): The NetworkX graph to which the annotations are related.
+            filepath (str): Path to the TSV annotations file.
             label_colname (str): Name of the column containing the labels (e.g., GO terms).
             nodes_colname (str): Name of the column containing the nodes associated with each label.
             nodes_delimiter (str, optional): Delimiter used to separate multiple nodes within the nodes column (default is ';').
@@ -153,12 +153,12 @@ class AnnotationsIO:
         # Load the annotations into the provided network
         return load_annotations(network, annotations_input)
 
-    def load_dict_annotation(self, content: Dict[str, Any], network: nx.Graph) -> Dict[str, Any]:
+    def load_dict_annotation(self, network: nx.Graph, content: Dict[str, Any]) -> Dict[str, Any]:
         """Load annotations from a provided dictionary and convert them to a dictionary annotation.
 
         Args:
-            content (dict): The annotations dictionary to load.
             network (NetworkX graph): The network to which the annotations are related.
+            content (dict): The annotations dictionary to load.
 
         Returns:
             dict: A dictionary containing ordered nodes, ordered annotations, and the annotations matrix.
@@ -219,6 +219,6 @@ def _log_loading(filetype: str, filepath: str = "") -> None:
         filepath (str, optional): The path to the file being loaded.
     """
     log_header("Loading annotations")
-    logger.info(f"Filetype: {filetype}")
+    logger.debug(f"Filetype: {filetype}")
     if filepath:
-        logger.info(f"Filepath: {filepath}")
+        logger.debug(f"Filepath: {filepath}")

risk_network-0.0.8b0/risk/log/config.py

@@ -0,0 +1,139 @@
+"""
+risk/log/config
+~~~~~~~~~~~~~~~
+"""
+
+import logging
+
+
+def in_jupyter():
+    """Check if the code is running in a Jupyter notebook environment.
+
+    Returns:
+        bool: True if running in a Jupyter notebook or QtConsole, False otherwise.
+    """
+    try:
+        shell = get_ipython().__class__.__name__
+        if shell == "ZMQInteractiveShell":  # Jupyter Notebook or QtConsole
+            return True
+        elif shell == "TerminalInteractiveShell":  # Terminal running IPython
+            return False
+    except NameError:
+        return False  # Not in Jupyter
+
+
+# Define the MockLogger class to replicate logging behavior with print statements in Jupyter
+class MockLogger:
+    """MockLogger: A lightweight logger replacement using print statements in Jupyter.
+
+    The MockLogger class replicates the behavior of a standard logger using print statements
+    to display messages. This is primarily used in a Jupyter environment to show outputs
+    directly in the notebook. The class supports logging levels such as `info`, `debug`,
+    `warning`, and `error`, while the `verbose` attribute controls whether to display non-error messages.
+    """
+
+    def __init__(self, verbose: bool = True):
+        """Initialize the MockLogger with verbosity settings.
+
+        Args:
+            verbose (bool): If True, display all log messages (info, debug, warning).
+                If False, only display error messages. Defaults to True.
+        """
+        self.verbose = verbose
+
+    def info(self, message: str) -> None:
+        """Display an informational message.
+
+        Args:
+            message (str): The informational message to be printed.
+        """
+        if self.verbose:
+            print(message)
+
+    def debug(self, message: str) -> None:
+        """Display a debug message.
+
+        Args:
+            message (str): The debug message to be printed.
+        """
+        if self.verbose:
+            print(message)
+
+    def warning(self, message: str) -> None:
+        """Display a warning message.
+
+        Args:
+            message (str): The warning message to be printed.
+        """
+        print(message)
+
+    def error(self, message: str) -> None:
+        """Display an error message.
+
+        Args:
+            message (str): The error message to be printed.
+        """
+        print(message)
+
+    def setLevel(self, level: int) -> None:
+        """Adjust verbosity based on the logging level.
+
+        Args:
+            level (int): Logging level to control message display.
+                - logging.DEBUG sets verbose to True (show all messages).
+                - logging.WARNING sets verbose to False (show only warning, error, and critical messages).
+        """
+        if level == logging.DEBUG:
+            self.verbose = True  # Show all messages
+        elif level == logging.WARNING:
+            self.verbose = False  # Suppress all except warning, error, and critical messages
+
+
+# Set up logger based on environment
+if not in_jupyter():
+    # Set up logger normally for .py files or terminal environments
+    logger = logging.getLogger("risk_logger")
+    logger.setLevel(logging.DEBUG)
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(logging.DEBUG)
+    console_handler.setFormatter(logging.Formatter("%(message)s"))
+
+    if not logger.hasHandlers():
+        logger.addHandler(console_handler)
+else:
+    # If in Jupyter, use the MockLogger
+    logger = MockLogger()
+
+
+def set_global_verbosity(verbose):
+    """Set the global verbosity level for the logger.
+
+    Args:
+        verbose (bool): Whether to display all log messages (True) or only error messages (False).
+
+    Returns:
+        None
+    """
+    if not isinstance(logger, MockLogger):
+        # For the regular logger, adjust logging levels
+        if verbose:
+            logger.setLevel(logging.DEBUG)  # Show all messages
+            console_handler.setLevel(logging.DEBUG)
+        else:
+            logger.setLevel(logging.WARNING)  # Show only warning, error, and critical messages
+            console_handler.setLevel(logging.WARNING)
+    else:
+        # For the MockLogger, set verbosity directly
+        logger.setLevel(logging.DEBUG if verbose else logging.WARNING)
+
+
+def log_header(input_string: str) -> None:
+    """Log the input string as a header with a line of dashes above and below it.
+
+    Args:
+        input_string (str): The string to be printed as a header.
+    """
+    border = "-" * len(input_string)
+    logger.info(border)
+    logger.info(input_string)
+    logger.info(border)

{risk_network-0.0.7b11 → risk_network-0.0.8b0}/risk/neighborhoods/domains.py

@@ -46,10 +46,10 @@ def define_domains(
         )
         # Perform hierarchical clustering
         Z = linkage(m, method=best_linkage, metric=best_metric)
-        logger.info(
+        logger.warning(
             f"Linkage criterion: '{linkage_criterion}'\nLinkage method: '{best_linkage}'\nLinkage metric: '{best_metric}'"
         )
-        logger.info(f"Optimal linkage threshold: {round(best_threshold, 3)}")
+        logger.debug(f"Optimal linkage threshold: {round(best_threshold, 3)}")
         # Calculate the optimal threshold for clustering
         max_d_optimal = np.max(Z[:, 2]) * best_threshold
         # Assign domains to the annotations matrix

{risk_network-0.0.7b11 → risk_network-0.0.8b0}/risk/neighborhoods/neighborhoods.py

@@ -130,7 +130,7 @@ def process_neighborhoods(
     enrichment_matrix = neighborhoods["enrichment_matrix"]
     binary_enrichment_matrix = neighborhoods["binary_enrichment_matrix"]
     significant_enrichment_matrix = neighborhoods["significant_enrichment_matrix"]
-    logger.info(f"Imputation depth: {impute_depth}")
+    logger.debug(f"Imputation depth: {impute_depth}")
     if impute_depth:
         (
             enrichment_matrix,
@@ -143,7 +143,7 @@ def process_neighborhoods(
             max_depth=impute_depth,
         )
 
-    logger.info(f"Pruning threshold: {prune_threshold}")
+    logger.debug(f"Pruning threshold: {prune_threshold}")
     if prune_threshold:
         (
             enrichment_matrix,

{risk_network-0.0.7b11 → risk_network-0.0.8b0}/risk/network/io.py

@@ -451,10 +451,10 @@ class NetworkIO:
         # Log the number of nodes and edges before and after cleaning
         num_final_nodes = G.number_of_nodes()
         num_final_edges = G.number_of_edges()
-        logger.info(f"Initial node count: {num_initial_nodes}")
-        logger.info(f"Final node count: {num_final_nodes}")
-        logger.info(f"Initial edge count: {num_initial_edges}")
-        logger.info(f"Final edge count: {num_final_edges}")
+        logger.debug(f"Initial node count: {num_initial_nodes}")
+        logger.debug(f"Final node count: {num_final_nodes}")
+        logger.debug(f"Initial edge count: {num_initial_edges}")
+        logger.debug(f"Final edge count: {num_final_edges}")
 
     def _assign_edge_weights(self, G: nx.Graph) -> None:
         """Assign weights to the edges in the graph.
@@ -472,7 +472,7 @@ class NetworkIO:
             )  # Default to 1.0 if 'weight' not present
 
         if self.include_edge_weight and missing_weights:
-            logger.info(f"Total edges missing weights: {missing_weights}")
+            logger.debug(f"Total edges missing weights: {missing_weights}")
 
     def _validate_nodes(self, G: nx.Graph) -> None:
         """Validate the graph structure and attributes.
@@ -511,13 +511,13 @@ class NetworkIO:
             filepath (str, optional): The path to the file being loaded. Defaults to "".
         """
         log_header("Loading network")
-        logger.info(f"Filetype: {filetype}")
+        logger.debug(f"Filetype: {filetype}")
         if filepath:
-            logger.info(f"Filepath: {filepath}")
-        logger.info(f"Edge weight: {'Included' if self.include_edge_weight else 'Excluded'}")
+            logger.debug(f"Filepath: {filepath}")
+        logger.debug(f"Edge weight: {'Included' if self.include_edge_weight else 'Excluded'}")
         if self.include_edge_weight:
-            logger.info(f"Weight label: {self.weight_label}")
-        logger.info(f"Minimum edges per node: {self.min_edges_per_node}")
-        logger.info(f"Projection: {'Sphere' if self.compute_sphere else 'Plane'}")
+            logger.debug(f"Weight label: {self.weight_label}")
+        logger.debug(f"Minimum edges per node: {self.min_edges_per_node}")
+        logger.debug(f"Projection: {'Sphere' if self.compute_sphere else 'Plane'}")
         if self.compute_sphere:
-            logger.info(f"Surface depth: {self.surface_depth}")
+            logger.debug(f"Surface depth: {self.surface_depth}")

{risk_network-0.0.7b11 → risk_network-0.0.8b0}/risk/network/plot.py

@@ -10,10 +10,11 @@ import matplotlib.pyplot as plt
 import networkx as nx
 import numpy as np
 import pandas as pd
+from scipy import linalg
 from scipy.ndimage import label
 from scipy.stats import gaussian_kde
 
-from risk.log import params
+from risk.log import params, logger
 from risk.network.graph import NetworkGraph
 
 
@@ -86,6 +87,83 @@ class NetworkPlotter:
 
         return ax
 
+    def plot_title(
+        self,
+        title: Union[str, None] = None,
+        subtitle: Union[str, None] = None,
+        title_fontsize: int = 20,
+        subtitle_fontsize: int = 14,
+        font: str = "Arial",
+        title_color: str = "black",
+        subtitle_color: str = "gray",
+        title_y: float = 0.975,
+        title_space_offset: float = 0.075,
+        subtitle_offset: float = 0.025,
+    ) -> None:
+        """Plot title and subtitle on the network graph with customizable parameters.
+
+        Args:
+            title (str, optional): Title of the plot. Defaults to None.
+            subtitle (str, optional): Subtitle of the plot. Defaults to None.
+            title_fontsize (int, optional): Font size for the title. Defaults to 16.
+            subtitle_fontsize (int, optional): Font size for the subtitle. Defaults to 12.
+            font (str, optional): Font family used for both title and subtitle. Defaults to "Arial".
+            title_color (str, optional): Color of the title text. Defaults to "black".
+            subtitle_color (str, optional): Color of the subtitle text. 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.
+            subtitle_offset (float, optional): Offset factor to position the subtitle below the title. Defaults to 0.025.
+        """
+        # Log the title and subtitle parameters
+        params.log_plotter(
+            title=title,
+            subtitle=subtitle,
+            title_fontsize=title_fontsize,
+            subtitle_fontsize=subtitle_fontsize,
+            title_subtitle_font=font,
+            title_color=title_color,
+            subtitle_color=subtitle_color,
+            subtitle_offset=subtitle_offset,
+            title_y=title_y,
+            title_space_offset=title_space_offset,
+        )
+
+        # Get the current figure and axis dimensions
+        fig = self.ax.figure
+        # Use a tight layout to ensure that title and subtitle do not overlap with the original plot
+        fig.tight_layout(
+            rect=[0, 0, 1, 1 - title_space_offset]
+        )  # Leave space above the plot for title
+
+        # Plot title if provided
+        if title:
+            # Set the title using figure's suptitle to ensure centering
+            self.ax.figure.suptitle(
+                title,
+                fontsize=title_fontsize,
+                color=title_color,
+                fontname=font,
+                x=0.5,  # Center the title horizontally
+                ha="center",
+                va="top",
+                y=title_y,
+            )
+
+        # Plot subtitle if provided
+        if subtitle:
+            # Calculate the subtitle's y position based on title's position and subtitle_offset
+            subtitle_y_position = title_y - subtitle_offset
+            self.ax.figure.text(
+                0.5,  # Ensure horizontal centering for subtitle
+                subtitle_y_position,
+                subtitle,
+                ha="center",
+                va="top",
+                fontname=font,
+                fontsize=subtitle_fontsize,
+                color=subtitle_color,
+            )
+
     def plot_circle_perimeter(
         self,
         scale: float = 1.0,
@@ -510,26 +588,52 @@ class NetworkPlotter:
         # Extract the positions of the specified nodes
         points = np.array([pos[n] for n in nodes])
         if len(points) <= 1:
-            return  # Not enough points to form a contour
+            return None  # Not enough points to form a contour
 
+        # Check if the KDE forms a single connected component
         connected = False
+        z = None  # Initialize z to None to avoid UnboundLocalError
         while not connected and bandwidth <= 100.0:
-            # Perform KDE on the points with the given bandwidth
-            kde = gaussian_kde(points.T, bw_method=bandwidth)
-            xmin, ymin = points.min(axis=0) - bandwidth
-            xmax, ymax = points.max(axis=0) + bandwidth
-            x, y = np.mgrid[
-                xmin : xmax : complex(0, grid_size), ymin : ymax : complex(0, grid_size)
-            ]
-            z = kde(np.vstack([x.ravel(), y.ravel()])).reshape(x.shape)
-            # Check if the KDE forms a single connected component
-            connected = _is_connected(z)
-            if not connected:
-                bandwidth += 0.05  # Increase bandwidth slightly and retry
+            try:
+                # Perform KDE on the points with the given bandwidth
+                kde = gaussian_kde(points.T, bw_method=bandwidth)
+                xmin, ymin = points.min(axis=0) - bandwidth
+                xmax, ymax = points.max(axis=0) + bandwidth
+                x, y = np.mgrid[
+                    xmin : xmax : complex(0, grid_size), ymin : ymax : complex(0, grid_size)
+                ]
+                z = kde(np.vstack([x.ravel(), y.ravel()])).reshape(x.shape)
+                # Check if the KDE forms a single connected component
+                connected = _is_connected(z)
+                if not connected:
+                    bandwidth += 0.05  # Increase bandwidth slightly and retry
+            except linalg.LinAlgError:
+                bandwidth += 0.05  # Increase bandwidth and retry
+            except Exception as e:
+                # Catch any other exceptions and log them
+                logger.error(f"Unexpected error when drawing KDE contour: {e}")
+                return None
+
+        # If z is still None, the KDE computation failed
+        if z is None:
+            logger.error("Failed to compute KDE. Skipping contour plot for these nodes.")
+            return None
 
         # Define contour levels based on the density
         min_density, max_density = z.min(), z.max()
+        if min_density == max_density:
+            logger.warning(
+                "Contour levels could not be created due to lack of variation in density."
+            )
+            return None
+
+        # Create contour levels based on the density values
         contour_levels = np.linspace(min_density, max_density, levels)[1:]
+        if len(contour_levels) < 2 or not np.all(np.diff(contour_levels) > 0):
+            logger.error("Contour levels must be strictly increasing. Skipping contour plot.")
+            return None
+
+        # Set the contour color and linestyle
         contour_colors = [color for _ in range(levels - 1)]
         # Plot the filled contours using fill_alpha for transparency
         if fill_alpha > 0:
@@ -554,6 +658,7 @@ class NetworkPlotter:
             linewidths=linewidth,
             alpha=alpha,
         )
+
         # Set linewidth for the contour lines to 0 for levels other than the base level
         for i in range(1, len(contour_levels)):
             c.collections[i].set_linewidth(0)
@@ -1090,14 +1195,16 @@ class NetworkPlotter:
         return np.array(annotated_colors)
 
     @staticmethod
-    def savefig(*args, **kwargs) -> None:
-        """Save the current plot to a file.
+    def savefig(*args, pad_inches: float = 0.5, dpi: int = 100, **kwargs) -> None:
+        """Save the current plot to a file with additional export options.
 
         Args:
             *args: Positional arguments passed to `plt.savefig`.
+            pad_inches (float, optional): Padding around the figure when saving. Defaults to 0.5.
+            dpi (int, optional): Dots per inch (DPI) for the exported image. Defaults to 300.
             **kwargs: Keyword arguments passed to `plt.savefig`, such as filename and format.
         """
-        plt.savefig(*args, bbox_inches="tight", **kwargs)
+        plt.savefig(*args, bbox_inches="tight", pad_inches=pad_inches, dpi=dpi, **kwargs)
 
     @staticmethod
     def show(*args, **kwargs) -> None:

{risk_network-0.0.7b11 → risk_network-0.0.8b0}/risk/risk.py

@@ -33,24 +33,17 @@ class RISK(NetworkIO, AnnotationsIO):
     and performing network-based statistical analysis, such as neighborhood significance testing.
     """
 
-    def __init__(self, *args, verbose: bool = True, **kwargs):
+    def __init__(self, verbose: bool = True):
         """Initialize the RISK class with configuration settings.
 
         Args:
             verbose (bool): If False, suppresses all log messages to the console. Defaults to True.
-            *args: Variable length argument list.
-            **kwargs: Arbitrary keyword arguments.
-
-        Note:
-            - All *args and **kwargs are passed to NetworkIO's __init__ method.
-            - AnnotationsIO does not take any arguments and is initialized without them.
         """
         # Set global verbosity for logging
         set_global_verbosity(verbose)
         # Initialize and log network parameters
         params.initialize()
-        # Use super() to call NetworkIO's __init__ with the given arguments and keyword arguments
-        super().__init__(*args, **kwargs)
+        super().__init__()
 
     @property
     def params(self) -> params:
@@ -221,10 +214,10 @@ class RISK(NetworkIO, AnnotationsIO):
         )
 
         # Log and display permutation test settings
-        logger.info(f"Neighborhood scoring metric: '{score_metric}'")
-        logger.info(f"Null distribution: '{null_distribution}'")
-        logger.info(f"Number of permutations: {num_permutations}")
-        logger.info(f"Maximum workers: {max_workers}")
+        logger.debug(f"Neighborhood scoring metric: '{score_metric}'")
+        logger.debug(f"Null distribution: '{null_distribution}'")
+        logger.debug(f"Number of permutations: {num_permutations}")
+        logger.debug(f"Maximum workers: {max_workers}")
         # Run permutation test to compute neighborhood significance
         neighborhood_significance = compute_permutation_test(
             neighborhoods=neighborhoods,
@@ -290,9 +283,9 @@ class RISK(NetworkIO, AnnotationsIO):
             max_cluster_size=max_cluster_size,
         )
 
-        logger.info(f"p-value cutoff: {pval_cutoff}")
-        logger.info(f"FDR BH cutoff: {fdr_cutoff}")
-        logger.info(
+        logger.debug(f"p-value cutoff: {pval_cutoff}")
+        logger.debug(f"FDR BH cutoff: {fdr_cutoff}")
+        logger.debug(
             f"Significance tail: '{tail}' ({'enrichment' if tail == 'right' else 'depletion' if tail == 'left' else 'both'})"
         )
         # Calculate significant neighborhoods based on the provided parameters
@@ -314,8 +307,8 @@ class RISK(NetworkIO, AnnotationsIO):
         )
 
         log_header("Finding top annotations")
-        logger.info(f"Min cluster size: {min_cluster_size}")
-        logger.info(f"Max cluster size: {max_cluster_size}")
+        logger.debug(f"Min cluster size: {min_cluster_size}")
+        logger.debug(f"Max cluster size: {max_cluster_size}")
         # Define top annotations based on processed neighborhoods
         top_annotations = self._define_top_annotations(
             network=network,
@@ -414,9 +407,9 @@ class RISK(NetworkIO, AnnotationsIO):
         else:
             for_print_distance_metric = distance_metric
         # Log and display neighborhood settings
-        logger.info(f"Distance metric: '{for_print_distance_metric}'")
-        logger.info(f"Edge length threshold: {edge_length_threshold}")
-        logger.info(f"Random seed: {random_seed}")
+        logger.debug(f"Distance metric: '{for_print_distance_metric}'")
+        logger.debug(f"Edge length threshold: {edge_length_threshold}")
+        logger.debug(f"Random seed: {random_seed}")
 
         # Compute neighborhoods based on the network and distance metric
         neighborhoods = get_network_neighborhoods(

{risk_network-0.0.7b11 → risk_network-0.0.8b0}/risk/stats/permutation/permutation.py

@@ -133,6 +133,7 @@ def _run_permutation_test(
                     observed_neighborhood_scores,
                     neighborhood_score_func,
                     subset_size + (1 if i < remainder else 0),
+                    num_permutations,
                     progress_counter,
                     max_workers,
                     rng,  # Pass the random number generator to each worker
@@ -144,11 +145,9 @@ def _run_permutation_test(
             results = pool.starmap_async(_permutation_process_subset, params_list, chunksize=1)
 
             # Update progress bar based on progress_counter
-            # NOTE: Waiting for results to be ready while updating progress bar gives a big improvement
-            # in performance, especially for large number of permutations and workers
             while not results.ready():
                 progress.update(progress_counter.value - progress.n)
-                results.wait(0.05)  # Wait for 50ms
+                results.wait(0.1)  # Wait for 100ms
             # Ensure progress bar reaches 100%
             progress.update(total_progress - progress.n)
 
@@ -167,6 +166,7 @@ def _permutation_process_subset(
     observed_neighborhood_scores: np.ndarray,
     neighborhood_score_func: Callable,
     subset_size: int,
+    num_permutations: int,
     progress_counter: ValueProxy,
     max_workers: int,
     rng: np.random.Generator,
@@ -180,6 +180,7 @@ def _permutation_process_subset(
         observed_neighborhood_scores (np.ndarray): Observed neighborhood scores.
         neighborhood_score_func (Callable): Function to calculate neighborhood scores.
         subset_size (int): Number of permutations to run in this subset.
+        num_permutations (int): Number of total permutations across all subsets.
         progress_counter (multiprocessing.managers.ValueProxy): Shared counter for tracking progress.
         max_workers (int): Number of workers for multiprocessing.
         rng (np.random.Generator): Random number generator object.
@@ -190,11 +191,15 @@ def _permutation_process_subset(
     # Initialize local count matrices for this worker
     local_counts_depletion = np.zeros(observed_neighborhood_scores.shape)
     local_counts_enrichment = np.zeros(observed_neighborhood_scores.shape)
+
     # NOTE: Limit the number of threads used by NumPy's BLAS implementation to 1 when more than one worker is used.
-    # This can help prevent oversubscription of CPU resources during multiprocessing, ensuring that each process
-    # doesn't use more than one CPU core.
     limits = None if max_workers == 1 else 1
     with threadpool_limits(limits=limits, user_api="blas"):
+        # Initialize a local counter for batched progress updates
+        local_progress = 0
+        # Calculate the modulo value based on total permutations for 1/100th frequency updates
+        modulo_value = max(1, num_permutations // 100)
+
         for _ in range(subset_size):
             # Permute the annotation matrix using the RNG
             annotation_matrix_permut = annotation_matrix[rng.permutation(idxs)]
@@ -212,7 +217,15 @@ def _permutation_process_subset(
                 local_counts_enrichment,
                 permuted_neighborhood_scores >= observed_neighborhood_scores,
             )
-            # Update the shared progress counter
-            progress_counter.value += 1
+
+            # Update local progress counter
+            local_progress += 1
+            # Update shared progress counter every 1/100th of total permutations
+            if local_progress % modulo_value == 0:
+                progress_counter.value += modulo_value
+
+        # Final progress update for any remaining iterations
+        if local_progress % modulo_value != 0:
+            progress_counter.value += modulo_value
 
     return local_counts_depletion, local_counts_enrichment

{risk_network-0.0.7b11 → risk_network-0.0.8b0}/risk_network.egg-info/PKG-INFO

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

risk_network-0.0.7b11/risk/log/config.py

@@ -1,48 +0,0 @@
-"""
-risk/log/config
-~~~~~~~~~~~~~~~
-"""
-
-import logging
-
-# Create and configure the global logger
-logger = logging.getLogger("risk_logger")
-logger.setLevel(logging.INFO)
-# Create and configure the console handler
-console_handler = logging.StreamHandler()
-console_handler.setLevel(logging.INFO)
-# Set the output format for the logger
-formatter = logging.Formatter("%(message)s")
-console_handler.setFormatter(formatter)
-# Add the console handler to the logger if not already attached
-if not logger.hasHandlers():
-    logger.addHandler(console_handler)
-
-
-def set_global_verbosity(verbose):
-    """Set the global verbosity level for the logger.
-
-    Args:
-        verbose (bool): Whether to display all log messages (True) or only error messages (False).
-
-    Returns:
-        None
-    """
-    if verbose:
-        logger.setLevel(logging.INFO)  # Show all messages
-        console_handler.setLevel(logging.INFO)
-    else:
-        logger.setLevel(logging.ERROR)  # Show only error messages
-        console_handler.setLevel(logging.ERROR)
-
-
-def log_header(input_string: str) -> None:
-    """Log the input string as a header with a line of dashes above and below it.
-
-    Args:
-        input_string (str): The string to be printed as a header.
-    """
-    border = "-" * len(input_string)
-    logger.info(border)
-    logger.info(input_string)
-    logger.info(border)