""" # Ported from kwutil """ # import os import logging from abc import ABC, abstractmethod import sys from typing import ClassVar from logging import INFO, DEBUG, ERROR, WARNING, CRITICAL # NOQA class _LogBackend(ABC): """ Abstract base class for our logger implementations. """ backend: ClassVar[str] def __init__(self, name): self.name = name @abstractmethod def configure(self, *args, **kwarg): """ Note: Implementations should take the arguments it needs and return the instance. """ @abstractmethod def debug(self, msg, *args, **kwargs): pass @abstractmethod def info(self, msg, *args, **kwargs): pass @abstractmethod def warning(self, msg, *args, **kwargs): pass @abstractmethod def error(self, msg, *args, **kwargs): pass @abstractmethod def critical(self, msg, *args, **kwargs): pass class _PrintLogBackend(_LogBackend): """ A simple print-based logger that falls back to print output if no logging configuration is set up. Example: >>> pl = _PrintLogBackend(name='print', level=INFO) >>> pl.info('Hello %s', 'world') Hello world >>> pl.debug('Should not appear') """ backend = 'print' def __init__(self, name="", level=logging.INFO): super().__init__(name) self.level = level def isEnabledFor(self, level): return level >= self.level def _log(self, level, msg, *args, **kwargs): if self.isEnabledFor(level): # Mimic logging formatting (ignoring extra kwargs for simplicity) print(msg % args) def debug(self, msg, *args, **kwargs): self._log(logging.DEBUG, msg, *args, **kwargs) def info(self, msg, *args, **kwargs): self._log(logging.INFO, msg, *args, **kwargs) def warning(self, msg, *args, **kwargs): self._log(logging.WARNING, msg, *args, **kwargs) def error(self, msg, *args, **kwargs): self._log(logging.ERROR, msg, *args, **kwargs) def critical(self, msg, *args, **kwargs): self._log(logging.CRITICAL, msg, *args, **kwargs) def configure(self, level=None, **_): if level is not None: self.level = level return self class _StdlibLogBackend(_LogBackend): """ A wrapper for Python's standard logging.Logger. The constructor optionally adds a StreamHandler (to stdout) and/or a logging.FileHandler if file is specified. Example: >>> import os >>> import ubelt as ub >>> import logging >>> dpath = ub.Path.appdir('kwutil/test/logging').ensuredir() >>> fpath = (dpath / 'test.log').delete() >>> sl = _StdlibLogBackend('stdlib').configure( >>> level=logging.INFO, >>> stream={ >>> 'format': '%(asctime)s : [stream] %(levelname)s : %(message)s', >>> }, >>> file={ >>> 'path': fpath, >>> 'format': '%(asctime)s : [file] %(levelname)s : %(message)s', >>> } >>> ) >>> sl.info('Hello %s', 'world') >>> # Check that the log file has been written to >>> text = fpath.read_text() >>> print(text) >>> assert text.strip().endswith('Hello world') """ backend = 'stdlib' def __init__(self, name): super().__init__(name) self.logger = logging.getLogger(name) def configure( self, level=None, stream='auto', file=None, **_, ): """ Configure the underlying stdlib logger. Parameters: level: the logging level to set (e.g. logging.INFO) stream: either a dict with configuration or a boolean/'auto' - If dict, expected keys include 'format' - If 'auto', the stream handler is enabled if no handlers are set - If a boolean, True enables the stream handler. file: either a dict with configuration or a path string. - If dict, expected keys include 'path' and 'format' - If a string, it is taken as the file path Note: For special attributes for the ``format`` argument of ``stream`` and ``file`` see https://docs.python.org/3/library/logging.html#logrecord-attributes Returns: self (the configured _StdlibLogBackend instance) """ if level is not None: self.logger.setLevel(level) # Default settings for file and stream handlers fileinfo = { 'path': None, 'format': '%(asctime)s : [file] %(levelname)s : %(message)s' } streaminfo = { '__enable__': None, # will be determined below 'format': '%(levelname)s: %(message)s', } # Update stream info if stream is a dict if isinstance(stream, dict): streaminfo.update(stream) # If not specified otherwise, enable the stream handler. if streaminfo.get('__enable__') is None: streaminfo['__enable__'] = True else: # If stream is not a dict, treat it as a boolean or 'auto' streaminfo['__enable__'] = stream # If stream is 'auto', enable stream only if no handlers are present. if streaminfo['__enable__'] == 'auto': streaminfo['__enable__'] = not bool(self.logger.handlers) # Update file info if file is a dict if isinstance(file, dict): fileinfo.update(file) else: fileinfo['path'] = file # Add a stream handler if enabled if streaminfo['__enable__']: streamformat = streaminfo.get('format') sh = logging.StreamHandler(sys.stdout) sh.setFormatter(logging.Formatter(streamformat)) self.logger.addHandler(sh) # Add a file handler if a valid path is provided path = fileinfo.get('path') if path: fileformat = fileinfo.get('format') fh = logging.FileHandler(path) fh.setFormatter(logging.Formatter(fileformat)) self.logger.addHandler(fh) return self # def _setup_handlers(self, stream, file): # # Only add handlers if none exist, so as not to duplicate logs. # if not self.logger.handlers: def debug(self, msg, *args, **kwargs): kwargs['stacklevel'] = kwargs.get('stacklevel', 1) + 1 self.logger.debug(msg, *args, **kwargs) def info(self, msg, *args, **kwargs): kwargs['stacklevel'] = kwargs.get('stacklevel', 1) + 1 self.logger.info(msg, *args, **kwargs) def warning(self, msg, *args, **kwargs): kwargs['stacklevel'] = kwargs.get('stacklevel', 1) + 1 self.logger.warning(msg, *args, **kwargs) def error(self, msg, *args, **kwargs): kwargs['stacklevel'] = kwargs.get('stacklevel', 1) + 1 self.logger.error(msg, *args, **kwargs) def critical(self, msg, *args, **kwargs): kwargs['stacklevel'] = kwargs.get('stacklevel', 1) + 1 self.logger.critical(msg, *args, **kwargs) class Logger: """ The main Logger class that automatically selects the backend. If backend='auto' and a global logging configuration exists (i.e. logging.getLogger(name) has handlers), it uses _StdlibLogBackend; otherwise, it falls back to _PrintLogBackend. Optional parameters: - verbose: controls log level via an integer (0: CRITICAL, 1: INFO, 2: DEBUG, etc.) - file: if provided, file logging is enabled (only used with _StdlibLogBackend) - stream: if True, a logging.StreamHandler to stdout is added (only used with _StdlibLogBackend) Example: >>> # With no global handlers, defaults to _PrintLogBackend >>> logger = Logger('TestLogger', verbose=2, backend='auto') >>> logger.info('Hello %s', 'world') Hello world >>> # Forcing use of _PrintLogBackend >>> logger = Logger('TestLogger', verbose=2, backend='print') >>> logger.debug('Debug %d', 123) Debug 123 >>> # Forcing use of Stdlib Logger >>> logger = Logger('TestLogger', verbose=2, backend='stdlib') >>> logger.debug('Debug %d', 123) Example: >>> # Forcing use of Stdlib Logger >>> logger = Logger('TestLogger', verbose=2, backend='stdlib').configure( >>> stream={'format': '%(asctime)s : %(pathname)s:%(lineno)d %(funcName)s %(levelname)s : %(message)s'}) >>> logger.debug('Debug %d', 123) >>> logger.info('Hello %d', 123) """ def __init__(self, name="Logger", verbose=1, backend="auto", file=None, stream=True): # Map verbose level to logging levels. If verbose > 1, show DEBUG, else INFO. self.name = name self.configure(verbose=verbose, backend=backend, file=file, stream=stream) def configure(self, backend='auto', verbose=1, file=None, stream=None): name = self.name kwargs = dict(file=file, stream=stream) kwargs['level'] = { 0: logging.CRITICAL, 1: logging.INFO, 2: logging.DEBUG}.get(verbose, logging.DEBUG) if backend == "auto": # Choose _StdlibLogBackend if a logger with handlers exists. if logging.getLogger(name).handlers: backend = 'stdlib' else: backend = 'print' try: Backend = {'print': _PrintLogBackend, 'stdlib': _StdlibLogBackend}[backend] except KeyError: raise ValueError( "Unsupported backend. " "Use 'auto', 'print', or 'stdlib'.") from None self._backend = Backend(name).configure(**kwargs) return self def __getattr__(self, attr): # We should not need to modify stacklevel here as we are directly # returning the backend function and not wrapping it. return getattr(self._backend, attr)