refactor: replace Logger with RunLogger and streamline logging setup

diceplayer/utils/logger.py

@@ -1,72 +1,48 @@
 import logging
+import sys
 from pathlib import Path
+from typing_extensions import TypeVar
+
+H = TypeVar('H', bound=logging.Handler)
 
 
-def valid_logger(func):
-    def wrapper(*args, **kwargs):
-        logger = args[0]
-        assert logger._was_set, "Logger is not set. Please call set_logger() first."
+class RunLogger(logging.Logger):
+    def __init__(self, name, level=logging.INFO, stream=sys.stdout):
+        super().__init__(name, level)
 
-        return func(*args, **kwargs)
+        self.handlers.clear()
 
-    return wrapper
+        self.handlers.append(
+            self._configure_handler(logging.StreamHandler(stream), level)
+        )
 
 
-class Logger:
-    outfile = None
+    def set_output_file(self, outfile: Path, level=logging.INFO):
+        for handler in list(self.handlers):
+            if not isinstance(handler, logging.FileHandler):
+                continue
+            self.handlers.remove(handler)
 
-    _logger = None
+        self.handlers.append(
+            self._create_file_handler(outfile, level)
+        )
 
-    _was_set = False
 
-    def __init__(self, logger_name):
-        if self._logger is None:
-            self._logger = logging.getLogger(logger_name)
 
-    def set_logger(self, outfile="run.log", level=logging.INFO, stream=None):
-        outfile_path = None
-        if outfile is not None and stream is None:
-            outfile_path = Path(outfile)
-            if outfile_path.exists():
-                outfile_path.rename(str(outfile_path) + ".backup")
+    @staticmethod
+    def _create_file_handler(file: str|Path, level) -> logging.FileHandler:
+        file = Path(file)
 
-        if level is not None:
-            self._logger.setLevel(level)
+        if file.exists():
+            file.rename(file.with_suffix('.log.backup'))
 
-        self._create_handlers(outfile_path, stream)
+        handler = logging.FileHandler(file)
+        return RunLogger._configure_handler(handler, level)
 
-        self._was_set = True
 
-    @valid_logger
-    def info(self, message):
-        self._logger.info(message)
-
-    @valid_logger
-    def debug(self, message):
-        self._logger.debug(message)
-
-    @valid_logger
-    def warning(self, message):
-        self._logger.warning(message)
-
-    @valid_logger
-    def error(self, message):
-        self._logger.error(message)
-
-    def _create_handlers(self, outfile_path: Path, stream):
-        handlers = []
-        if outfile_path is not None:
-            handlers.append(logging.FileHandler(outfile_path, mode="a+"))
-        elif stream is not None:
-            handlers.append(logging.StreamHandler(stream))
-        else:
-            handlers.append(logging.StreamHandler())
-
-        for handler in handlers:
-            handler.setFormatter(logging.Formatter("%(message)s"))
-            self._logger.addHandler(handler)
-
-    def close(self):
-        for handler in self._logger.handlers:
-            handler.close()
-            self._logger.removeHandler(handler)
+    @staticmethod
+    def _configure_handler(handler: H, level) -> H:
+        handler.setLevel(level)
+        formatter = logging.Formatter('%(message)s')
+        handler.setFormatter(formatter)
+        return handler