transform messenger to use python logging (#199)

Author: lrntct

src/itzi/itzi.py

@@ -233,6 +233,7 @@ def update_input_arrays(self):
 def sim_runner_worker(conf_file):
     """Run one simulation"""
     msgr.raise_on_error = True
+    msgr._itzi_logger.set_verbosity(msgr.verbosity())
     try:
         # Run the simulation
         msgr.message(f"Starting simulation of {os.path.basename(conf_file)}...")
@@ -262,8 +263,6 @@ def itzi_run_one(conf_file):
 
 def itzi_run(cli_args):
     """Run one or multiple simulations from the command line."""
-    # Do not raise on error when run from CLI
-    msgr.raise_on_error = False
     # set environment variables
     if cli_args.o:
         os.environ["GRASS_OVERWRITE"] = "1"

src/itzi/messenger.py

@@ -13,17 +13,13 @@
 """
 
 import sys
+import logging
 import os
 from datetime import timedelta, datetime
 
 from itzi.itzi_error import ItziFatal
 from itzi.const import VerbosityLevel
 
-OUTPUT = sys.stderr
-FATAL = "ERROR: "
-WARNING = "WARNING: "
-PAD = " " * 20  # Necessary to print a clean line
-
 raise_on_error = True
 
 
@@ -35,14 +31,90 @@ def verbosity():
         return VerbosityLevel.QUIET
 
 
+class ItziLogger:
+    """Custom logger wrapper maintaining backward compatibility"""
+
+    VERBOSE_LEVEL = 15
+    logging.addLevelName(VERBOSE_LEVEL, "VERBOSE")
+
+    def __init__(self):
+        self.logger = logging.getLogger("itzi")
+        self.raise_on_error = True
+        self._setup_handlers()
+
+    def _setup_handlers(self):
+        """Configure console and optional file handlers"""
+        # Console handler (stderr)
+        console_handler = logging.StreamHandler(sys.stderr)
+        console_handler.setFormatter(logging.Formatter("%(message)s"))
+        self.logger.addHandler(console_handler)
+        self.logger.setLevel(logging.DEBUG)
+
+    def add_file_handler(self, filepath, level=logging.DEBUG):
+        """Add file logging capability"""
+        file_handler = logging.FileHandler(filepath)
+        file_handler.setLevel(level)
+        file_handler.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
+        self.logger.addHandler(file_handler)
+
+    def set_verbosity(self, verbosity_level):
+        """Map verbosity to logging level"""
+        mapping = {
+            VerbosityLevel.SUPER_QUIET: logging.ERROR,
+            VerbosityLevel.QUIET: logging.WARNING,
+            VerbosityLevel.MESSAGE: logging.INFO,
+            VerbosityLevel.VERBOSE: self.VERBOSE_LEVEL,
+            VerbosityLevel.DEBUG: logging.DEBUG,
+        }
+        level = mapping.get(verbosity_level, logging.INFO)
+        self.logger.setLevel(level)
+        for handler in self.logger.handlers:
+            if isinstance(handler, logging.StreamHandler) and not isinstance(
+                handler, logging.FileHandler
+            ):
+                handler.setLevel(level)
+
+    def fatal(self, msg):
+        """Log fatal error and raise or exit"""
+        self.logger.error(f"ERROR: {msg}")
+        if raise_on_error:
+            raise ItziFatal(msg)
+        else:
+            sys.exit(f"ERROR: {msg}")
+
+    def warning(self, msg):
+        self.logger.warning(f"WARNING: {msg}")
+
+    def message(self, msg):
+        self.logger.info(msg)
+
+    def verbose(self, msg):
+        self.logger.log(self.VERBOSE_LEVEL, msg)
+
+    def debug(self, msg):
+        self.logger.debug(msg)
+
+
+# Global instance
+_itzi_logger = ItziLogger()
+
+# Backward-compatible module-level interface
+raise_on_error = _itzi_logger.raise_on_error
+fatal = _itzi_logger.fatal
+warning = _itzi_logger.warning
+message = _itzi_logger.message
+verbose = _itzi_logger.verbose
+debug = _itzi_logger.debug
+
+
 def percent(start_time, end_time, sim_time, sim_start_time):
     """Display progress of the simulation"""
     sim_time_s = (sim_time - start_time).total_seconds()
     duration_s = (end_time - start_time).total_seconds()
     advance_perc = sim_time_s / duration_s
 
     if verbosity() == VerbosityLevel.QUIET:
-        print("{:.1%}".format(advance_perc), file=OUTPUT, end="\r")
+        print(f"{advance_perc:.1%}", file=sys.stderr, end="\r")
 
     elif verbosity() >= VerbosityLevel.MESSAGE:
         elapsed_s = (datetime.now() - sim_start_time).total_seconds()
@@ -59,36 +131,4 @@ def percent(start_time, end_time, sim_time, sim_start_time):
             eta=eta,
             pad=" " * 10,
         )
-        print(disp, file=OUTPUT, end="\r")
-
-
-def message(msg):
-    """Display a normal message"""
-    if verbosity() >= VerbosityLevel.MESSAGE:
-        print(msg + PAD, file=OUTPUT)
-
-
-def verbose(msg):
-    """Display a verbose message"""
-    if verbosity() >= VerbosityLevel.VERBOSE:
-        print(msg + PAD, file=OUTPUT)
-
-
-def debug(msg):
-    """Display a debug message"""
-    if verbosity() >= VerbosityLevel.DEBUG:
-        print(msg + PAD, file=OUTPUT)
-
-
-def warning(msg):
-    """Display a warning message"""
-    if verbosity() >= VerbosityLevel.SUPER_QUIET:
-        print(WARNING + msg + PAD, file=OUTPUT)
-
-
-def fatal(msg):
-    """Display a fatal error and (exit or raise)"""
-    if raise_on_error:
-        raise ItziFatal(msg)
-    else:
-        sys.exit(FATAL + msg + PAD)
+        print(disp, file=sys.stderr, end="\r")