Added basic support for logging

alexandrutomescu · alexandrutomescu · commit bb4e65e75e34 · 2025-04-04T13:28:29.000+03:00
diff --git a/.gitignore b/.gitignore
@@ -34,3 +34,4 @@ MANIFEST
 
 .pytest_cache/
 .DS_Store
+*.log
diff --git a/examples/min_flow_decomp.py b/examples/min_flow_decomp.py
@@ -2,6 +2,13 @@
 import networkx as nx
 
 def main():
+    # Configure logging
+    fp.utils.configure_logging(
+        level=fp.utils.logging.DEBUG,
+        log_to_console=True,
+        log_file="log_mfd_example.log",
+    )
+    
     # Create a simple graph
     graph = nx.DiGraph()
     graph.graph["id"] = "simple_graph"
@@ -17,6 +24,7 @@ def main():
     # We create a Minimum Flow Decomposition solver with default settings,
     # by specifying that the flow value of each edge is in the attribute `flow` of the edges.
     mfd_model = fp.MinFlowDecomp(graph, flow_attr="flow")
+    fp.utils.logger.info("Created the Minimum Flow Decomposition solver")
 
     # We solve it
     mfd_model.solve()
diff --git a/examples/min_path_error_iterative.py b/examples/min_path_error_iterative.py
@@ -2,6 +2,14 @@
 import networkx as nx
 
 def main():
+
+    # Configure logging
+    fp.utils.configure_logging(
+        level=fp.utils.logging.DEBUG,
+        log_to_console=True,
+        log_file="log_mpe_iterative_example.log",
+    )
+
     # Create a simple graph
     graph = nx.DiGraph()
     graph.graph["id"] = "simple_graph"
diff --git a/flowpaths/abstractpathmodeldag.py b/flowpaths/abstractpathmodeldag.py
@@ -1,6 +1,7 @@
 import flowpaths.stdigraph as stdigraph
 from flowpaths.utils import safetypathcovers
 from flowpaths.utils import solverwrapper as sw
+import flowpaths.utils as utils
 import time
 from abc import ABC, abstractmethod
 
@@ -547,8 +548,11 @@ def solve(self) -> bool:
         (either 'kOptimal' (highs) or status code 2 (gurobi)), it sets the solved attribute to True and returns True.
         Otherwise, it sets the solved attribute to False and returns False.
         """
+        utils.logger.info(f"{__name__}: solving...")
+
         # If we already received an external solution, we don't need to solve the model
         if self.external_solution_paths is not None:
+            utils.logger.info(f"{__name__}: no need to solve, we have an external solution.")
             self.__is_solved = True
             return True
 
@@ -568,6 +572,7 @@ def solve(self) -> bool:
             or self.solver.get_model_status() == 2
         ):
             self.__is_solved = True
+            utils.logger.info(f"{__name__}: solved successfully. Objective value: {self.get_objective_value()}")
             return True
 
         self.__is_solved = False
diff --git a/flowpaths/kflowdecomp.py b/flowpaths/kflowdecomp.py
@@ -4,6 +4,7 @@
 import flowpaths.utils.graphutils as gu
 import flowpaths.abstractpathmodeldag as pathmodel
 import flowpaths.utils.safetyflowdecomp as sfd
+import flowpaths.utils as utils
 
 class kFlowDecomp(pathmodel.AbstractPathModelDAG):
     """
@@ -187,6 +188,8 @@ def __init__(
         # The given weights optimization
         self.__encode_given_weights()
 
+        utils.logger.info(f"{__name__}: initialized with graph id = {id(G)}, k = {self.k}")
+
     def __encode_flow_decomposition(self):
         
         # Encodes the flow decomposition constraints for the given graph.
diff --git a/flowpaths/kleastabserrors.py b/flowpaths/kleastabserrors.py
@@ -1,13 +1,14 @@
 import networkx as nx
 import flowpaths.stdigraph as stdigraph
 import flowpaths.abstractpathmodeldag as pathmodel
+import flowpaths.utils as utils
 
 
 class kLeastAbsErrors(pathmodel.AbstractPathModelDAG):
     """
     This class implements the k-LeastAbsoluteErrors, namely it looks for a decomposition of a weighted DAG into 
     k weighted paths (specified by `num_paths`), minimizing the absolute errors on the edges. The error on an edge 
-    is defiened as the absolute value of the difference between the weight of the edge and the sum of the weights of 
+    is defined as the absolute value of the difference between the weight of the edge and the sum of the weights of 
     the paths that go through it.
     """
     def __init__(
@@ -185,6 +186,8 @@ def __init__(
         # This method is called from the current class to add the objective function
         self.__encode_objective()
 
+        utils.logger.info(f"{__name__}: initialized with graph id = {id(G)}, k = {self.k}")
+
     def __encode_leastabserrors_decomposition(self):
 
         # pi vars from https://arxiv.org/pdf/2201.10923 page 14
diff --git a/flowpaths/kminpatherror.py b/flowpaths/kminpatherror.py
@@ -1,6 +1,7 @@
 import networkx as nx
 import flowpaths.stdigraph as stdigraph
 import flowpaths.abstractpathmodeldag as pathmodel
+import flowpaths.utils as utils
 
 
 class kMinPathError(pathmodel.AbstractPathModelDAG):
@@ -221,6 +222,8 @@ def __init__(
         # This method is called from the current class to add the objective function
         self.__encode_objective()
 
+        utils.logger.info(f"{__name__}: initialized with graph id = {id(G)}, k = {self.k}")
+
     def __encode_minpatherror_decomposition(self):
 
         # path weights 
diff --git a/flowpaths/minerrorflow.py b/flowpaths/minerrorflow.py
@@ -1,5 +1,6 @@
 import flowpaths.utils.solverwrapper as sw
 import flowpaths.stdigraph as stdigraph
+import flowpaths.utils as utils
 import networkx as nx
 from copy import deepcopy
 import time
@@ -99,7 +100,9 @@ def __init__(
 
         self.__encode_flow()
 
-        self.__encode_objective()    
+        self.__encode_objective()  
+
+        utils.logger.info(f"{__name__}: initialized with graph id = {id(G)}")  
 
     def __create_solver(self):
         
diff --git a/flowpaths/minflowdecomp.py b/flowpaths/minflowdecomp.py
@@ -5,6 +5,7 @@
 import flowpaths.abstractpathmodeldag as pathmodel
 import flowpaths.utils.graphutils as gu
 import flowpaths.mingenset as mgs
+import flowpaths.utils as utils
 import copy
 import math
 
@@ -129,6 +130,8 @@ def __init__(
         self.__all_subgraph_weights = None
         self.__given_weights_model = None
 
+        utils.logger.info(f"{__name__}: initialized with graph id = {id(G)}")
+
     def solve(self) -> bool:
         """
         Attempts to solve the flow distribution problem using a model with varying number of paths.
@@ -148,7 +151,8 @@ def solve(self) -> bool:
         if self.optimization_options.get("optimize_with_given_weights", MinFlowDecomp.optimize_with_given_weights):            
             self.__solve_with_given_weights()
 
-        for i in range(self.get_lowerbound_k(), self.G.number_of_edges()):            
+        for i in range(self.get_lowerbound_k(), self.G.number_of_edges()):
+            utils.logger.info(f"{__name__}: iteration with k = {i}")
             fd_model = None
             # Checking if we have already found a solution with the same number of paths
             # via the min gen set and given weights approach
@@ -229,6 +233,7 @@ def __solve_with_given_weights(self) -> bool:
 
         if given_weights_kfd_solver.is_solved():
             self.__given_weights_model = given_weights_kfd_solver
+            utils.logger.info(f"{__name__}: found an MFD solution with given weights")
 
     def __get_partition_constraints_for_min_gen_set(
             self, 
@@ -291,7 +296,7 @@ def __get_partition_constraints_for_min_gen_set(
         if limit_num_constraints is not None:
             partition_constraints_list = partition_constraints_list[:limit_num_constraints]
 
-        print("partition_constraints", partition_constraints_list)
+        utils.logger.debug(f"{__name__}: partition_constraints = {partition_constraints_list}")
 
         return partition_constraints_list
     
@@ -324,6 +329,7 @@ def __get_lowerbound_with_min_gen_set(self) -> int:
         if mingenset_model.is_solved():        
             self.__generating_set = mingenset_model.get_solution()
             min_gen_set_lowerbound = len(self.__generating_set)
+            utils.logger.info(f"{__name__}: found a min gen set solution with {min_gen_set_lowerbound} elements ({self.__generating_set})")
         
         self.solve_statistics["min_gen_set_solve_time"] = time.time() - start_time
         
diff --git a/flowpaths/numpathsoptimization.py b/flowpaths/numpathsoptimization.py
@@ -1,5 +1,6 @@
 import time
 import flowpaths.abstractpathmodeldag as pathmodel
+import flowpaths.utils as utils
 
 class NumPathsOptimization(pathmodel.AbstractPathModelDAG): # Note that we inherit from AbstractPathModelDAG to be able to use this class to also compute safe paths, 
     
@@ -106,6 +107,8 @@ def __init__(
         self.__solution = None
         self.solve_statistics = None
 
+        utils.logger.info(f"{__name__}: created NumPathsOptimization with model_type = {model_type}")
+
     def solve(self) -> bool:
         """
         Attempts to solve the optimization problem by iterating over a range of path counts, creating and
@@ -151,29 +154,35 @@ def solve(self) -> bool:
 
         for k in range(max(self.min_num_paths,self.get_lowerbound_k()), self.max_num_paths+1):
             # Create the model
+            utils.logger.info(f"{__name__}: model id = {id(self)}, iteration with k = {k}")
             model = self.model_type(**self.kwargs, k=k)
             model.solve()
             if model.is_solved():
                 found_feasible = True
+                current_solution_objective_value = model.get_objective_value()
+                utils.logger.info(f"{__name__}: model id = {id(self)}, iteration with k = {k}, current_solution_objective_value = {current_solution_objective_value}")
                 if self.stop_on_first_feasible:
                     solve_status = NumPathsOptimization.solved_status_name
                     break
                 if self.stop_on_delta_abs:
                     if previous_solution_objective_value is None:
-                        previous_solution_objective_value = model.get_objective_value()
+                        previous_solution_objective_value = current_solution_objective_value
                     else:
-                        if abs(previous_solution_objective_value - model.get_objective_value()) <= self.stop_on_delta_abs:
+                        if abs(previous_solution_objective_value - current_solution_objective_value) <= self.stop_on_delta_abs:
                             solve_status = NumPathsOptimization.solved_status_name
                             break
                 if self.stop_on_delta_rel:
                     if previous_solution_objective_value is None:
-                        previous_solution_objective_value = model.get_objective_value()
+                        previous_solution_objective_value = current_solution_objective_value
                     else:
-                        if abs(previous_solution_objective_value - model.get_objective_value()) / previous_solution_objective_value <= self.stop_on_delta_rel:
+                        if abs(previous_solution_objective_value - current_solution_objective_value) / previous_solution_objective_value <= self.stop_on_delta_rel:
                             solve_status = NumPathsOptimization.solved_status_name
                             break
+            else:
+                utils.logger.info(f"{__name__}: model id = {id(self)}, iteration with k = {k}, model is not solved")
             if time.time() - start_time > self.time_limit:
                 solve_status = NumPathsOptimization.timeout_status_name
+                utils.logger.info(f"{__name__}: model id = {id(self)}, iteration with k = {k}, time out")
                 break
             
         if solve_status != NumPathsOptimization.timeout_status_name:
diff --git a/flowpaths/utils/__init__.py b/flowpaths/utils/__init__.py
@@ -2,10 +2,14 @@
 from .graphutils import max_bottleneck_path
 from .graphutils import check_flow_conservation
 from .graphutils import draw_solution
+from .logging import configure_logging
+from .logging import logger
 
 __all__ = [
     "min_cost_flow",
     "max_bottleneck_path",
     "check_flow_conservation",
     "draw_solution",
+    "configure_logging",
+    "logger",
 ]
diff --git a/flowpaths/utils/logging.py b/flowpaths/utils/logging.py
@@ -0,0 +1,74 @@
+import logging
+
+# Expose logging levels through fp.utils
+DEBUG = logging.DEBUG
+INFO = logging.INFO
+WARNING = logging.WARNING
+ERROR = logging.ERROR
+CRITICAL = logging.CRITICAL
+
+# Define a logger for the package
+logger = logging.getLogger(__name__)
+logger.addHandler(logging.NullHandler())  # Prevent issues if no handler is set
+
+def configure_logging(
+        level=logging.DEBUG, 
+        log_to_console=True, 
+        log_file=None, 
+        file_mode="w"  # "a" for append, "w" for overwrite
+    ):
+    """
+    Configures logging for the flowpaths package.
+
+    Parameters:
+    -----------
+
+    - `level: int`, optional
+        
+        Logging level (e.g., fp.utils.logging.DEBUG, fp.utils.logging.INFO). 
+        Default is fp.utils.logging.DEBUG.
+
+    - `log_to_console: bool`, optional
+    
+        Whether to log to the console. Default is True.
+
+    - `log_file: str`, optional
+     
+        File path to log to. If None, logging to a file is disabled. Default is None.
+        If a file path is provided, the log will be written to that file.
+        If the file already exists, it will be overwritten unless `file_mode` is set to "a".
+    
+    - `file_mode: str`, optional
+        
+        Mode for the log file. "a" (append) or "w" (overwrite). Default is "w".
+
+    """
+    # Remove existing handlers to avoid duplicate logs
+    for handler in logger.handlers[:]:
+        logger.removeHandler(handler)
+
+    # Set the logger level
+    logger.setLevel(level)
+
+    # Define a formatter
+    formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+
+    # Add console handler if enabled
+    if log_to_console:
+        console_handler = logging.StreamHandler()
+        console_handler.setLevel(level)
+        console_handler.setFormatter(formatter)
+        logger.addHandler(console_handler)
+
+    if file_mode not in ["a", "w"]:
+        raise ValueError("file_mode must be either 'a' (append) or 'w' (overwrite)")
+
+    # Add file handler if a file path is provided
+    if log_file:
+        file_handler = logging.FileHandler(log_file, mode=file_mode)  # Use file_mode
+        file_handler.setLevel(level)
+        file_handler.setFormatter(formatter)
+        logger.addHandler(file_handler)
+
+    logger.info("Logging initialized: level=%s, console=%s, file=%s, mode=%s", 
+                level, log_to_console, log_file, file_mode)
diff --git a/pyproject.toml b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "flowpaths"
-version = "0.1.16" 
+version = "0.1.17" 
 description = "A Python package to quickly decompose weighted graphs into weights paths, under various models."
 readme = "README.md"
 authors = [{name="Graph Algorithms and Bioinformatics Group @ University of Helsinki, and external collaborators"}]

Original file line number	Diff line number	Diff line change
`@@ -34,3 +34,4 @@ MANIFEST`
`34`	`34`
`35`	`35`	`.pytest_cache/`
`36`	`36`	`.DS_Store`
	`37`	`+*.log`