Module pyboiler.logging

Threaded logger with color support

"""Threaded logger with color support"""

from .internal.log import Handler, Level, Record, handlers


class logging:

    __slots__ = ("name", "_level", "handlers", "disabled")

    def __init__(self, name, level):
        self.name = name
        self._level = Level.get(level)
        self.handlers = dict()
        self.disabled = False

    @property
    def level(self):
        """Get logging level"""
        return self._level

    @level.setter
    def level(self, level):
        self._level = level

    @staticmethod
    def avail_handlers():
        return list(handlers.keys())

    @staticmethod
    def avail_levels():
        return list(Level)

    def mk_handler(self, handler, *args, **kwargs):  # type: ignore
        """Add a handler"""
        if isinstance(handler, str):
            handler: Handler = handlers[handler.lower()]
        else:
            if issubclass(handler, Handler):
                self.handlers[handler.name()] = handler
                return
        if not issubclass(handler, Handler):  # type: ignore
            raise Exception(f"Invalid handler: {handler}")

        if not handler in self.handlers:
            self.handlers[handler.name()] = handler(*args, **kwargs)

    def rm_handler(self, hdlr):
        """Remove a handler"""
        if isinstance(hdlr, str):
            hdlr = handlers[hdlr]
        self.handlers.pop(hdlr)

    def ls_handlers(self):
        """Return all available handlers"""
        return self.handlers

    def trace(self, msg):
        """Log trace"""
        self._log(Level.TRACE, msg)

    def debug(self, msg):
        """Log debug"""
        self._log(Level.DEBUG, msg)

    def info(self, msg):
        """Log info"""
        self._log(Level.INFO, msg)

    def warn(self, msg):
        """Log warn"""
        self._log(Level.WARN, msg)

    def error(self, msg):
        """Log error"""
        self._log(Level.ERROR, msg)

    def exception(self, msg):
        """Log error and raise an exception"""
        pass

    def log(self, lvl: Level, msg: str):
        """This probably shouldn't be used in your code"""
        self._log(lvl, msg)

    def _log(self, lvl: Level, msg: str):
        """logging internal method"""
        if Level.get(lvl) < self._level:
            return
        record = Record(self.name, lvl, msg, depth=3)
        self.handle(record)

    def handle(self, record: Record):
        if self.disabled:
            return
        for handler in self.handlers.values():
            handler.handle(record)

Classes

class logging (name, level)

Expand source code

class logging:

    __slots__ = ("name", "_level", "handlers", "disabled")

    def __init__(self, name, level):
        self.name = name
        self._level = Level.get(level)
        self.handlers = dict()
        self.disabled = False

    @property
    def level(self):
        """Get logging level"""
        return self._level

    @level.setter
    def level(self, level):
        self._level = level

    @staticmethod
    def avail_handlers():
        return list(handlers.keys())

    @staticmethod
    def avail_levels():
        return list(Level)

    def mk_handler(self, handler, *args, **kwargs):  # type: ignore
        """Add a handler"""
        if isinstance(handler, str):
            handler: Handler = handlers[handler.lower()]
        else:
            if issubclass(handler, Handler):
                self.handlers[handler.name()] = handler
                return
        if not issubclass(handler, Handler):  # type: ignore
            raise Exception(f"Invalid handler: {handler}")

        if not handler in self.handlers:
            self.handlers[handler.name()] = handler(*args, **kwargs)

    def rm_handler(self, hdlr):
        """Remove a handler"""
        if isinstance(hdlr, str):
            hdlr = handlers[hdlr]
        self.handlers.pop(hdlr)

    def ls_handlers(self):
        """Return all available handlers"""
        return self.handlers

    def trace(self, msg):
        """Log trace"""
        self._log(Level.TRACE, msg)

    def debug(self, msg):
        """Log debug"""
        self._log(Level.DEBUG, msg)

    def info(self, msg):
        """Log info"""
        self._log(Level.INFO, msg)

    def warn(self, msg):
        """Log warn"""
        self._log(Level.WARN, msg)

    def error(self, msg):
        """Log error"""
        self._log(Level.ERROR, msg)

    def exception(self, msg):
        """Log error and raise an exception"""
        pass

    def log(self, lvl: Level, msg: str):
        """This probably shouldn't be used in your code"""
        self._log(lvl, msg)

    def _log(self, lvl: Level, msg: str):
        """logging internal method"""
        if Level.get(lvl) < self._level:
            return
        record = Record(self.name, lvl, msg, depth=3)
        self.handle(record)

    def handle(self, record: Record):
        if self.disabled:
            return
        for handler in self.handlers.values():
            handler.handle(record)

Static methods

def avail_handlers()

Expand source code

@staticmethod
def avail_handlers():
    return list(handlers.keys())

def avail_levels()

Expand source code

@staticmethod
def avail_levels():
    return list(Level)

Instance variables

var disabled

Return an attribute of instance, which is of type owner.

var handlers

Return an attribute of instance, which is of type owner.

var level

Get logging level

Expand source code

@property
def level(self):
    """Get logging level"""
    return self._level

var name

Return an attribute of instance, which is of type owner.

Methods

def debug(self, msg)

Log debug

Expand source code

def debug(self, msg):
    """Log debug"""
    self._log(Level.DEBUG, msg)

def error(self, msg)

Log error

Expand source code

def error(self, msg):
    """Log error"""
    self._log(Level.ERROR, msg)

def exception(self, msg)

Log error and raise an exception

Expand source code

def exception(self, msg):
    """Log error and raise an exception"""
    pass

def handle(self, record: Record)

Expand source code

def handle(self, record: Record):
    if self.disabled:
        return
    for handler in self.handlers.values():
        handler.handle(record)

def info(self, msg)

Log info

Expand source code

def info(self, msg):
    """Log info"""
    self._log(Level.INFO, msg)

def log(self, lvl: Level, msg: str)

This probably shouldn't be used in your code

Expand source code

def log(self, lvl: Level, msg: str):
    """This probably shouldn't be used in your code"""
    self._log(lvl, msg)

def ls_handlers(self)

Return all available handlers

Expand source code

def ls_handlers(self):
    """Return all available handlers"""
    return self.handlers

def mk_handler(self, handler, *args, **kwargs)

Add a handler

Expand source code

def mk_handler(self, handler, *args, **kwargs):  # type: ignore
    """Add a handler"""
    if isinstance(handler, str):
        handler: Handler = handlers[handler.lower()]
    else:
        if issubclass(handler, Handler):
            self.handlers[handler.name()] = handler
            return
    if not issubclass(handler, Handler):  # type: ignore
        raise Exception(f"Invalid handler: {handler}")

    if not handler in self.handlers:
        self.handlers[handler.name()] = handler(*args, **kwargs)

def rm_handler(self, hdlr)

Remove a handler

Expand source code

def rm_handler(self, hdlr):
    """Remove a handler"""
    if isinstance(hdlr, str):
        hdlr = handlers[hdlr]
    self.handlers.pop(hdlr)

def trace(self, msg)

Log trace

Expand source code

def trace(self, msg):
    """Log trace"""
    self._log(Level.TRACE, msg)

def warn(self, msg)

Log warn

Expand source code

def warn(self, msg):
    """Log warn"""
    self._log(Level.WARN, msg)