risk-network 0.0.7b9__tar.gz → 0.0.7b11__tar.gz

{risk_network-0.0.7b9 → risk_network-0.0.7b11}/PKG-INFO

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

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

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

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

@@ -12,7 +12,7 @@ import networkx as nx
 import pandas as pd
 
 from risk.annotations.annotations import load_annotations
-from risk.log import params, print_header
+from risk.log import params, logger, log_header
 
 
 class AnnotationsIO:
@@ -218,7 +218,7 @@ def _log_loading(filetype: str, filepath: str = "") -> None:
         filetype (str): The type of the file being loaded (e.g., 'Cytoscape').
         filepath (str, optional): The path to the file being loaded.
     """
-    print_header("Loading annotations")
-    print(f"Filetype: {filetype}")
+    log_header("Loading annotations")
+    logger.info(f"Filetype: {filetype}")
     if filepath:
-        print(f"Filepath: {filepath}")
+        logger.info(f"Filepath: {filepath}")

{risk_network-0.0.7b9 → risk_network-0.0.7b11}/risk/log/__init__.py

@@ -3,7 +3,7 @@ risk/log
 ~~~~~~~~
 """
 
-from .console import print_header
+from .config import logger, log_header, set_global_verbosity
 from .params import Params
 
 params = Params()

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

@@ -0,0 +1,48 @@
+"""
+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)

{risk_network-0.0.7b9 → risk_network-0.0.7b11}/risk/log/params.py

@@ -12,7 +12,7 @@ from typing import Any, Dict
 
 import numpy as np
 
-from .console import print_header
+from .config import logger, log_header
 
 # Suppress all warnings - this is to resolve warnings from multiprocessing
 warnings.filterwarnings("ignore")
@@ -35,11 +35,11 @@ def _safe_param_export(func):
             filepath = (
                 kwargs.get("filepath") or args[1]
             )  # Assuming filepath is always the second argument
-            print(f"Parameters successfully exported to filepath: {filepath}")
+            logger.info(f"Parameters successfully exported to filepath: {filepath}")
             return result
         except Exception as e:
             filepath = kwargs.get("filepath") or args[1]
-            print(f"An error occurred while exporting parameters to {filepath}: {e}")
+            logger.error(f"An error occurred while exporting parameters to {filepath}: {e}")
             return None
 
     return wrapper
@@ -161,7 +161,7 @@ class Params:
         Returns:
             dict: A dictionary containing the processed parameters.
         """
-        print_header("Loading parameters")
+        log_header("Loading parameters")
         return _convert_ndarray_to_list(
             {
                 "annotations": self.annotations,

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

@@ -15,6 +15,7 @@ from sklearn.metrics import silhouette_score
 
 from risk.annotations import get_description
 from risk.constants import GROUP_LINKAGE_METHODS, GROUP_DISTANCE_METRICS
+from risk.log import logger
 
 
 def define_domains(
@@ -45,10 +46,10 @@ def define_domains(
         )
         # Perform hierarchical clustering
         Z = linkage(m, method=best_linkage, metric=best_metric)
-        print(
+        logger.info(
             f"Linkage criterion: '{linkage_criterion}'\nLinkage method: '{best_linkage}'\nLinkage metric: '{best_metric}'"
         )
-        print(f"Optimal linkage threshold: {round(best_threshold, 3)}")
+        logger.info(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
@@ -58,7 +59,9 @@ def define_domains(
     except ValueError:
         # If a ValueError is encountered, handle it by assigning unique domains
         n_rows = len(top_annotations)
-        print(f"Error encountered. Skipping clustering and assigning {n_rows} unique domains.")
+        logger.error(
+            f"Error encountered. Skipping clustering and assigning {n_rows} unique domains."
+        )
         top_annotations["domain"] = range(1, n_rows + 1)  # Assign unique domains
 
     # Create DataFrames to store domain information

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

@@ -20,6 +20,7 @@ from risk.neighborhoods.community import (
     calculate_spinglass_neighborhoods,
     calculate_walktrap_neighborhoods,
 )
+from risk.log import logger
 
 # Suppress DataConversionWarning
 warnings.filterwarnings(action="ignore", category=DataConversionWarning)
@@ -129,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"]
-    print(f"Imputation depth: {impute_depth}")
+    logger.info(f"Imputation depth: {impute_depth}")
     if impute_depth:
         (
             enrichment_matrix,
@@ -142,7 +143,7 @@ def process_neighborhoods(
             max_depth=impute_depth,
         )
 
-    print(f"Pruning threshold: {prune_threshold}")
+    logger.info(f"Pruning threshold: {prune_threshold}")
     if prune_threshold:
         (
             enrichment_matrix,

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

@@ -16,7 +16,7 @@ import networkx as nx
 import pandas as pd
 
 from risk.network.geometry import assign_edge_lengths
-from risk.log import params, print_header
+from risk.log import params, logger, log_header
 
 
 class NetworkIO:
@@ -57,9 +57,8 @@ class NetworkIO:
             weight_label=weight_label,
         )
 
-    @classmethod
+    @staticmethod
     def load_gpickle_network(
-        cls,
         filepath: str,
         compute_sphere: bool = True,
         surface_depth: float = 0.0,
@@ -80,7 +79,7 @@ class NetworkIO:
         Returns:
             nx.Graph: Loaded and processed network.
         """
-        networkio = cls(
+        networkio = NetworkIO(
             compute_sphere=compute_sphere,
             surface_depth=surface_depth,
             min_edges_per_node=min_edges_per_node,
@@ -109,9 +108,8 @@ class NetworkIO:
         # Initialize the graph
         return self._initialize_graph(G)
 
-    @classmethod
+    @staticmethod
     def load_networkx_network(
-        cls,
         network: nx.Graph,
         compute_sphere: bool = True,
         surface_depth: float = 0.0,
@@ -132,7 +130,7 @@ class NetworkIO:
         Returns:
             nx.Graph: Loaded and processed network.
         """
-        networkio = cls(
+        networkio = NetworkIO(
             compute_sphere=compute_sphere,
             surface_depth=surface_depth,
             min_edges_per_node=min_edges_per_node,
@@ -158,9 +156,8 @@ class NetworkIO:
         # Initialize the graph
         return self._initialize_graph(network)
 
-    @classmethod
+    @staticmethod
     def load_cytoscape_network(
-        cls,
         filepath: str,
         source_label: str = "source",
         target_label: str = "target",
@@ -187,7 +184,7 @@ class NetworkIO:
         Returns:
             nx.Graph: Loaded and processed network.
         """
-        networkio = cls(
+        networkio = NetworkIO(
             compute_sphere=compute_sphere,
             surface_depth=surface_depth,
             min_edges_per_node=min_edges_per_node,
@@ -312,9 +309,8 @@ class NetworkIO:
             if os.path.exists(tmp_dir):
                 shutil.rmtree(tmp_dir)
 
-    @classmethod
+    @staticmethod
     def load_cytoscape_json_network(
-        cls,
         filepath: str,
         source_label: str = "source",
         target_label: str = "target",
@@ -339,7 +335,7 @@ class NetworkIO:
         Returns:
             NetworkX graph: Loaded and processed network.
         """
-        networkio = cls(
+        networkio = NetworkIO(
             compute_sphere=compute_sphere,
             surface_depth=surface_depth,
             min_edges_per_node=min_edges_per_node,
@@ -455,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()
-        print(f"Initial node count: {num_initial_nodes}")
-        print(f"Final node count: {num_final_nodes}")
-        print(f"Initial edge count: {num_initial_edges}")
-        print(f"Final edge count: {num_final_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}")
 
     def _assign_edge_weights(self, G: nx.Graph) -> None:
         """Assign weights to the edges in the graph.
@@ -476,7 +472,7 @@ class NetworkIO:
             )  # Default to 1.0 if 'weight' not present
 
         if self.include_edge_weight and missing_weights:
-            print(f"Total edges missing weights: {missing_weights}")
+            logger.info(f"Total edges missing weights: {missing_weights}")
 
     def _validate_nodes(self, G: nx.Graph) -> None:
         """Validate the graph structure and attributes.
@@ -514,14 +510,14 @@ class NetworkIO:
             filetype (str): The type of the file being loaded (e.g., 'CSV', 'JSON').
             filepath (str, optional): The path to the file being loaded. Defaults to "".
         """
-        print_header("Loading network")
-        print(f"Filetype: {filetype}")
+        log_header("Loading network")
+        logger.info(f"Filetype: {filetype}")
         if filepath:
-            print(f"Filepath: {filepath}")
-        print(f"Edge weight: {'Included' if self.include_edge_weight else 'Excluded'}")
+            logger.info(f"Filepath: {filepath}")
+        logger.info(f"Edge weight: {'Included' if self.include_edge_weight else 'Excluded'}")
         if self.include_edge_weight:
-            print(f"Weight label: {self.weight_label}")
-        print(f"Minimum edges per node: {self.min_edges_per_node}")
-        print(f"Projection: {'Sphere' if self.compute_sphere else 'Plane'}")
+            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'}")
         if self.compute_sphere:
-            print(f"Surface depth: {self.surface_depth}")
+            logger.info(f"Surface depth: {self.surface_depth}")

{risk_network-0.0.7b9 → risk_network-0.0.7b11}/risk/risk.py

@@ -10,7 +10,7 @@ import numpy as np
 import pandas as pd
 
 from risk.annotations import AnnotationsIO, define_top_annotations
-from risk.log import params, print_header
+from risk.log import params, logger, log_header, set_global_verbosity
 from risk.neighborhoods import (
     define_domains,
     get_network_neighborhoods,
@@ -33,16 +33,32 @@ class RISK(NetworkIO, AnnotationsIO):
     and performing network-based statistical analysis, such as neighborhood significance testing.
     """
 
-    def __init__(self, *args, **kwargs):
-        """Initialize the RISK class with configuration settings."""
+    def __init__(self, *args, verbose: bool = True, **kwargs):
+        """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()
-        # Initialize the parent classes
+        # Use super() to call NetworkIO's __init__ with the given arguments and keyword arguments
         super().__init__(*args, **kwargs)
 
     @property
-    def params(self):
-        """Access the logged parameters."""
+    def params(self) -> params:
+        """Access the logged network parameters.
+
+        Returns:
+            Params: An instance of the Params class with logged parameters and methods to access or update them.
+        """
         return params
 
     def load_neighborhoods_by_hypergeom(
@@ -69,7 +85,7 @@ class RISK(NetworkIO, AnnotationsIO):
         Returns:
             dict: Computed significance of neighborhoods.
         """
-        print_header("Running hypergeometric test")
+        log_header("Running hypergeometric test")
         # Log neighborhood analysis parameters
         params.log_neighborhoods(
             distance_metric=distance_metric,
@@ -122,7 +138,7 @@ class RISK(NetworkIO, AnnotationsIO):
         Returns:
             dict: Computed significance of neighborhoods.
         """
-        print_header("Running Poisson test")
+        log_header("Running Poisson test")
         # Log neighborhood analysis parameters
         params.log_neighborhoods(
             distance_metric=distance_metric,
@@ -181,7 +197,7 @@ class RISK(NetworkIO, AnnotationsIO):
         Returns:
             dict: Computed significance of neighborhoods.
         """
-        print_header("Running permutation test")
+        log_header("Running permutation test")
         # Log neighborhood analysis parameters
         params.log_neighborhoods(
             distance_metric=distance_metric,
@@ -205,10 +221,10 @@ class RISK(NetworkIO, AnnotationsIO):
         )
 
         # Log and display permutation test settings
-        print(f"Neighborhood scoring metric: '{score_metric}'")
-        print(f"Null distribution: '{null_distribution}'")
-        print(f"Number of permutations: {num_permutations}")
-        print(f"Maximum workers: {max_workers}")
+        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}")
         # Run permutation test to compute neighborhood significance
         neighborhood_significance = compute_permutation_test(
             neighborhoods=neighborhoods,
@@ -260,7 +276,7 @@ class RISK(NetworkIO, AnnotationsIO):
             NetworkGraph: A fully initialized and processed NetworkGraph object.
         """
         # Log the parameters and display headers
-        print_header("Finding significant neighborhoods")
+        log_header("Finding significant neighborhoods")
         params.log_graph(
             tail=tail,
             pval_cutoff=pval_cutoff,
@@ -274,9 +290,9 @@ class RISK(NetworkIO, AnnotationsIO):
             max_cluster_size=max_cluster_size,
         )
 
-        print(f"p-value cutoff: {pval_cutoff}")
-        print(f"FDR BH cutoff: {fdr_cutoff}")
-        print(
+        logger.info(f"p-value cutoff: {pval_cutoff}")
+        logger.info(f"FDR BH cutoff: {fdr_cutoff}")
+        logger.info(
             f"Significance tail: '{tail}' ({'enrichment' if tail == 'right' else 'depletion' if tail == 'left' else 'both'})"
         )
         # Calculate significant neighborhoods based on the provided parameters
@@ -288,7 +304,7 @@ class RISK(NetworkIO, AnnotationsIO):
             fdr_cutoff=fdr_cutoff,
         )
 
-        print_header("Processing neighborhoods")
+        log_header("Processing neighborhoods")
         # Process neighborhoods by imputing and pruning based on the given settings
         processed_neighborhoods = process_neighborhoods(
             network=network,
@@ -297,9 +313,9 @@ class RISK(NetworkIO, AnnotationsIO):
             prune_threshold=prune_threshold,
         )
 
-        print_header("Finding top annotations")
-        print(f"Min cluster size: {min_cluster_size}")
-        print(f"Max cluster size: {max_cluster_size}")
+        log_header("Finding top annotations")
+        logger.info(f"Min cluster size: {min_cluster_size}")
+        logger.info(f"Max cluster size: {max_cluster_size}")
         # Define top annotations based on processed neighborhoods
         top_annotations = self._define_top_annotations(
             network=network,
@@ -309,7 +325,7 @@ class RISK(NetworkIO, AnnotationsIO):
             max_cluster_size=max_cluster_size,
         )
 
-        print_header("Optimizing distance threshold for domains")
+        log_header("Optimizing distance threshold for domains")
         # Define domains in the network using the specified clustering settings
         domains = self._define_domains(
             neighborhoods=processed_neighborhoods,
@@ -357,7 +373,7 @@ class RISK(NetworkIO, AnnotationsIO):
         Returns:
             NetworkPlotter: A NetworkPlotter object configured with the given parameters.
         """
-        print_header("Loading plotter")
+        log_header("Loading plotter")
         # Log the plotter settings
         params.log_plotter(
             figsize=figsize,
@@ -398,9 +414,9 @@ class RISK(NetworkIO, AnnotationsIO):
         else:
             for_print_distance_metric = distance_metric
         # Log and display neighborhood settings
-        print(f"Distance metric: '{for_print_distance_metric}'")
-        print(f"Edge length threshold: {edge_length_threshold}")
-        print(f"Random seed: {random_seed}")
+        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}")
 
         # Compute neighborhoods based on the network and distance metric
         neighborhoods = get_network_neighborhoods(

{risk_network-0.0.7b9 → risk_network-0.0.7b11}/risk/stats/permutation/test_functions.py

@@ -1,6 +1,6 @@
 """
-risk/stats/permutation/test_function
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+risk/stats/permutation/test_functions
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
 import numpy as np

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

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

{risk_network-0.0.7b9 → risk_network-0.0.7b11}/risk_network.egg-info/SOURCES.txt

@@ -10,7 +10,7 @@ risk/annotations/__init__.py
 risk/annotations/annotations.py
 risk/annotations/io.py
 risk/log/__init__.py
-risk/log/console.py
+risk/log/config.py
 risk/log/params.py
 risk/neighborhoods/__init__.py
 risk/neighborhoods/community.py

risk_network-0.0.7b9/risk/log/console.py

@@ -1,16 +0,0 @@
-"""
-risk/log/console
-~~~~~~~~~~~~~~~~
-"""
-
-
-def print_header(input_string: str) -> None:
-    """Print 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)
-    print(border)
-    print(input_string)
-    print(border)