cx-logger/source/logger.py

import time
import pathlib

from .levels import levels
from .handler import handler

class logger(handler):
    def __init__(self, log_file: pathlib.Path | None) -> None:
        super().__init__(log_file)

        self.__debug = False
        self.__time_stamp_format = "%d-%m-%Y %H:%M:%S "

        self.__minimum_stdout = levels.critical.value
        self.__minimum_stderr = levels.warning.value
        self.__minimum_file = levels.warning.value

    async def info(self, *args, **kwargs) -> None:
        await self.log(levels.info, *args, **kwargs)

    async def warning(self, *args, **kwargs) -> None:
        await self.log(levels.warning, *args, **kwargs)

    async def error(self, *args, **kwargs) -> None:
        await self.log(levels.error, *args, **kwargs)

    async def critical(self, *args, **kwargs) -> None:
        await self.log(levels.critical, *args, **kwargs)

    async def log(self, level: levels, *args, **kwargs) -> None:
        value = level.value
        content = self.__generate(*args, **kwargs)

        if value >= self.__minimum_stdout or self.debug:
            await self._to_stdout(content)

        if value >= self.__minimum_stderr or self.debug:
            await self._to_stderr(content)

        if value >= self.__minimum_file or self.debug:
            await self._to_file(content)

    def __generate(self, *args, **kwargs) -> str:
        if len(kwargs) > 0:
            return self.__generate_from_kwargs(*args, **kwargs)

        if len(args) > 0:
            return self.__generate_from_args(*args)
        
        raise RuntimeError("Can not log empty message.")

    def __generate_from_kwargs(self, *args, **kwargs) -> str:
        if len(args) != 1 or type(args[0]) is not str:
            RuntimeError("Can not log with format, when format is not given.")
        
        return self.time_stamp + args[0].format(**kwargs)

    def __generate_from_args(self, *args) -> str:
        mapper = lambda count: count if type(count) is str else repr(count)
        mapped = map(mapper, args)

        return self.time_stamp + str(", ").join(mapped)

    @property
    def time_stamp(self) -> str:
        return time.strftime(self.__time_stamp_format, time.localtime())

    def set_time_stamp(self, target: str) -> None:
            self.__time_stamp_format = target

    @property
    def debug(self) -> bool:
        return self.__debug
    
    def start_debugging() -> None:
        self.__debug = True

    def stop_debugging() -> None:
        self.__debug = False