From 8857166e67bb4b5cc9e402591167eefeaecd6d6f Mon Sep 17 00:00:00 2001 From: shenjack <3695888@qq.com> Date: Thu, 2 Nov 2023 23:52:56 +0800 Subject: [PATCH] sync lib-not-dr --- libs/lib_not_dr/logger/formatter/__init__.py | 61 ++++- libs/lib_not_dr/logger/formatter/colors.py | 266 ++++++++++++------- libs/lib_not_dr/logger/structers.py | 3 + libs/utils/logger-old.py | 9 +- 4 files changed, 235 insertions(+), 104 deletions(-) diff --git a/libs/lib_not_dr/logger/formatter/__init__.py b/libs/lib_not_dr/logger/formatter/__init__.py index 28b72ac..ad22a21 100644 --- a/libs/lib_not_dr/logger/formatter/__init__.py +++ b/libs/lib_not_dr/logger/formatter/__init__.py @@ -74,6 +74,16 @@ class BaseFormatter(Options): message = formatter._format(message) return message + @property + def template(self) -> str: + return self.default_template + + @template.setter + def template(self, template: str) -> None: + if not isinstance(template, str): + raise TypeError(f'The template must be str, not {type(template)}') + self.default_template = template + class TimeFormatter(BaseFormatter): name = 'TimeFormatter' @@ -135,14 +145,14 @@ class LevelFormatter(BaseFormatter): else: if self.level_get_higher: for level in self.name_level_map: - if message[0].level < self.name_level_map[level]: + if message[0].level <= self.name_level_map[level]: level_tag = level break else: level_tag = 'FATAL' else: for level in self.name_level_map: - if message[0].level > self.name_level_map[level]: + if message[0].level >= self.name_level_map[level]: level_tag = level break else: @@ -156,11 +166,11 @@ class TraceFormatter(BaseFormatter): @classmethod def _info(cls) -> str: - info = cls.add_info('logging file', 'log_source', 'the logging file name') + info = cls.add_info('log_source', 'logging file', 'the logging file name') info += '\n' - info += cls.add_info('logging line', 'log_line', 'the logging line number') + info += cls.add_info('log_line', 'logging line', 'the logging line number') info += '\n' - info += cls.add_info('logging function', 'log_function', 'the logging function name') + info += cls.add_info('log_function', 'logging function', 'the logging function name') return info def _format(self, message: FormattingMessage) -> FormattingMessage: @@ -175,19 +185,32 @@ class TraceFormatter(BaseFormatter): class StdFormatter(BaseFormatter): name = 'StdFormatter' + enable_color: bool = True + sub_formatter = [TimeFormatter(), LevelFormatter(), TraceFormatter()] - from lib_not_dr.logger.formatter.colors import LevelColorFormatter, LoggerColorFormatter, TimeColorFormatter + from lib_not_dr.logger.formatter.colors import (LevelColorFormatter, + LoggerColorFormatter, + TimeColorFormatter, + TraceColorFormatter, + MessageColorFormatter) color_formatters = [LevelColorFormatter(), LoggerColorFormatter(), - TimeColorFormatter()] + TimeColorFormatter(), + TraceColorFormatter(), + MessageColorFormatter()] def _format(self, message: FormattingMessage) -> FormattingMessage: super()._format(message) + + if not self.enable_color: + return message + for formatter in self.color_formatters: message = formatter._format(message) + return message @classmethod @@ -199,7 +222,7 @@ if __name__ == '__main__': import inspect log_message = LogMessage(messages=['Hello World!'], - level=10, + level=7, stack_trace=inspect.currentframe(), logger_tag='tester', logger_name='test') @@ -215,3 +238,25 @@ if __name__ == '__main__': print(StdFormatter.info()) print(StdFormatter().format_message(log_message)) + + std_format = StdFormatter() + std_format.default_template = "${log_time}|${logger_name}|${logger_tag}|${log_source}:${log_line}|${log_function}|${level}|${messages}" + + test_levels = (0, 2, 5, 7, 10, 30, 50, 90) + + print("with color") + + for test_level in test_levels: + log_message.level = test_level + print(std_format.format_message(log_message), end='') + + print("without color") + + std_format.enable_color = False + + for test_level in test_levels: + log_message.level = test_level + print(std_format.format_message(log_message), end='') + + print(std_format.as_markdown()) + diff --git a/libs/lib_not_dr/logger/formatter/colors.py b/libs/lib_not_dr/logger/formatter/colors.py index 9812eae..c1878ef 100644 --- a/libs/lib_not_dr/logger/formatter/colors.py +++ b/libs/lib_not_dr/logger/formatter/colors.py @@ -12,8 +12,13 @@ from lib_not_dr.logger.structers import FormattingMessage __all__ = [ 'BaseColorFormatter', + 'LevelColorFormatter', 'LoggerColorFormatter', + 'TimeColorFormatter', + 'TraceColorFormatter', + 'MessageColorFormatter', + 'RESET_COLOR' ] @@ -22,59 +27,56 @@ RESET_COLOR = '\033[0m' class BaseColorFormatter(BaseFormatter): name = 'BaseColorFormatter' - + # TODO 迁移老 logger 颜色 color = { - # Notset: just black - 0: '', - # Trace: blue - 2: '\033[0;34m', - # Fine: green - 5: '\033[0;32m', - # Debug: cyan - 7: '\033[0;36m', - # Info: white - 10: '\033[0;37m', - # Warn: yellow - 30: '\033[0;33m', - # Error: red - 50: '\033[0;31m', - # Fatal: red background - 90: '\033[0;41m' + # Notset: just black + 0: '', + # Trace: blue + 2: '\033[0;34m', + # Fine: green + 5: '\033[0;32m', + # Debug: cyan + 7: '\033[0;36m', + # Info: white + 10: '\033[0;37m', + # Warn: yellow + 30: '\033[0;33m', + # Error: red + 50: '\033[0;31m', + # Fatal: red background + 90: '\033[0;41m' } - @classmethod - def get_level(cls, message: FormattingMessage) -> int: - for level in cls.color: - if message[0].level < level: + def get_color(self, message: FormattingMessage) -> str: + for level in self.color: + if message[0].level <= level: break else: level = 90 - return level + return self.color[level] class LevelColorFormatter(BaseColorFormatter): name = 'LevelColorFormatter' - - @staticmethod - def _default_color() -> Dict[int, str]: - return { - # Notset: just black - 0: '', - # Trace: blue - 2: '\033[0;34m', - # Fine: green - 5: '\033[0;32m', - # Debug: cyan - 7: '\033[0;36m', - # Info: white - 10: '\033[0;37m', - # Warn: yellow - 30: '\033[0;33m', - # Error: red - 50: '\033[0;31m', - # Fatal: red background - 90: '\033[0;41m' - } + # TODO 迁移老 logger 颜色 + color = { + # Notset: just black + 0: '', + # Trace: blue + 2: '\033[0;34m', + # Fine: green + 5: '\033[0;32m', + # Debug: cyan + 7: '\033[0;36m', + # Info: white + 10: '\033[0;37m', + # Warn: yellow + 30: '\033[0;33m', + # Error: red + 50: '\033[0;31m', + # Fatal: red background + 90: '\033[0;41m' + } @classmethod def _info(cls) -> str: @@ -83,38 +85,36 @@ class LevelColorFormatter(BaseColorFormatter): def _format(self, message: FormattingMessage) -> FormattingMessage: if isinstance(message[1].get('level'), int): return message - # 向上寻找等级 - level = self.get_level(message) # 获取颜色 - color = self.color[level] + color = self.get_color(message) # 添加颜色 + if color == '' or color == RESET_COLOR: + return message message[1]['level'] = f'{color}{message[1]["level"]}{RESET_COLOR}' return message class LoggerColorFormatter(BaseColorFormatter): name = 'LoggerColorFormatter' - - @staticmethod - def _default_color() -> Dict[int, str]: - return { - # Notset: just black - 0: '', - # Trace: blue - 2: '\033[0;34m', - # Fine: green - 5: '\033[0;32m', - # Debug: cyan - 7: '\033[0;36m', - # Info: white - 10: '\033[0;37m', - # Warn: yellow - 30: '\033[0;33m', - # Error: red - 50: '\033[0;31m', - # Fatal: red background - 90: '\033[0;41m', - } + # TODO 迁移老 logger 颜色 + color = { + # Notset: just black + 0: '', + # Trace: blue + 2: '\033[0;34m', + # Fine: green + 5: '\033[0;32m', + # Debug: cyan + 7: '\033[0;36m', + # Info: white + 10: '\033[0;37m', + # Warn: yellow + 30: '\033[0;33m', + # Error: red + 50: '\033[0;31m', + # Fatal: red background + 90: '\033[38;2;245;189;230m', + } @classmethod def _info(cls) -> str: @@ -123,11 +123,11 @@ class LoggerColorFormatter(BaseColorFormatter): def _format(self, message: FormattingMessage) -> FormattingMessage: if message[1].get('logger_name') is None: return message - # 向上寻找等级 - level = self.get_level(message) # 获取颜色 - color = self.color[level] + color = self.get_color(message) # 添加颜色 + if color == '' or color == RESET_COLOR: + return message message[1]['logger_name'] = f'{color}{message[1]["logger_name"]}{RESET_COLOR}' if message[1].get('logger_tag') is not None and message[1].get('logger_tag') != ' ': message[1]['logger_tag'] = f'{color}{message[1]["logger_tag"]}{RESET_COLOR}' @@ -136,24 +136,24 @@ class LoggerColorFormatter(BaseColorFormatter): class TimeColorFormatter(BaseColorFormatter): name = 'TimeColorFormatter' - + # TODO 迁移老 logger 颜色 color = { - # Notset: just black - 0: '', - # Trace: blue - 2: '\033[0;34m', - # Fine: green - 5: '\033[0;32m', - # Debug: cyan - 7: '\033[0;36m', - # Info: white - 10: '\033[0;37m', - # Warn: yellow - 30: '\033[0;33m', - # Error: red - 50: '\033[0;31m', - # Fatal: red background - 90: '\033[0;41m', + # Notset: just black + 0: '', + # Trace: blue + 2: '\033[0;34m', + # Fine: green + 5: '\033[0;32m', + # Debug: cyan + 7: '\033[0;36m', + # Info: white + 10: '\033[0;37m', + # Warn: yellow + 30: '\033[0;33m', + # Error: red + 50: '\033[0;31m', + # Fatal: red background + 90: '\033[0;41m', } @classmethod @@ -163,10 +163,96 @@ class TimeColorFormatter(BaseColorFormatter): def _format(self, message: FormattingMessage) -> FormattingMessage: if message[1].get('log_time') is None: return message - # 向上寻找等级 - level = self.get_level(message) # 获取颜色 - color = self.color[level] + color = self.get_color(message) # 添加颜色 + if color == '' or color == RESET_COLOR: + return message message[1]['log_time'] = f'{color}{message[1]["log_time"]}{RESET_COLOR}' return message + + +class TraceColorFormatter(BaseColorFormatter): + name = 'TraceColorFormatter' + # TODO 迁移老 logger 颜色 + color = { + # Notset: just black + 0: '\033[38;2;0;255;180m', + # Trace: blue + 2: '\033[38;2;0;255;180m', + # Fine: green + 5: '\033[38;2;0;255;180m', + # Debug: cyan + 7: '\033[38;2;0;255;180m', + # Info: white + 10: '\033[38;2;0;255;180m', + # Warn: yellow + 30: '\033[38;2;0;255;180m', + # Error: red + 50: '\033[38;2;0;255;180m', + # Fatal: red background + 90: '\033[38;2;0;255;180m', + } + + @classmethod + def _info(cls) -> str: + info = cls.add_info('colored logging file', 'log_source', 'A colored logging file name') + info += '\n' + info += cls.add_info('colored logging line', 'log_line', 'A colored logging line number') + info += '\n' + info += cls.add_info('colored logging function', 'log_function', 'A colored logging function name') + return info + + def _format(self, message: FormattingMessage) -> FormattingMessage: + if message[0].stack_trace is None: + return message + # 获取颜色 + color = self.get_color(message) + # 添加颜色 + if color == '' or color == RESET_COLOR: + return message + message[1]['log_source'] = f'{color}{message[1]["log_source"]}{RESET_COLOR}' + message[1]['log_line'] = f'{color}{message[1]["log_line"]}{RESET_COLOR}' + message[1]['log_function'] = f'{color}{message[1]["log_function"]}{RESET_COLOR}' + return message + + +class MessageColorFormatter(BaseColorFormatter): + name = 'MessageColorFormatter' + + color = { + # Notset: just black + 0: '', + # Trace: blue + 2: '\033[38;2;138;173;244m', + # Fine: blue + 5: '\033[38;2;138;173;244m', + # Debug: blue + 7: '\033[38;2;138;173;244m', + # Info: no color + 10: '', + # Warn: yellow + 30: '\033[0;33m', + # Error: red + 50: '\033[0;31m', + # Fatal: red background + 90: '\033[38;2;255;255;0;48;2;120;10;10m', + } + + @classmethod + def _info(cls) -> str: + return cls.add_info('colored message', 'message', 'A colored message') + + def _format(self, message: FormattingMessage) -> FormattingMessage: + if message[1].get('messages') is None: + return message + # 获取颜色 + color = self.get_color(message) + # 添加颜色 + if color == '' or color == RESET_COLOR: + return message + if message[1]['messages'][-1] == '\n': + message[1]['messages'] = f'{color}{message[1]["messages"][:-1]}{RESET_COLOR}\n' + else: + message[1]['messages'] = f'{color}{message[1]["messages"]}{RESET_COLOR}' + return message diff --git a/libs/lib_not_dr/logger/structers.py b/libs/lib_not_dr/logger/structers.py index abcb4be..af2f713 100644 --- a/libs/lib_not_dr/logger/structers.py +++ b/libs/lib_not_dr/logger/structers.py @@ -55,3 +55,6 @@ class LogMessage(Options): FormattingMessage = Tuple[LogMessage, Dict[str, str]] + +if __name__ == '__main__': + print(LogMessage().as_markdown()) diff --git a/libs/utils/logger-old.py b/libs/utils/logger-old.py index 51b4813..86e74a9 100644 --- a/libs/utils/logger-old.py +++ b/libs/utils/logger-old.py @@ -1086,9 +1086,6 @@ def test_logger(the_logger: Logger): the_logger.debug('debugging') the_logger.info("Hello World!!") the_logger.info("Hello World!!") - the_logger.info("Hello World!!") - the_logger.info("Hello World!!") - the_logger.info("Hello World!!") the_logger.warn('warning') the_logger.warn('warning') the_logger.error('error haaaa') @@ -1111,9 +1108,9 @@ if __name__ == "__main__": a_logger.error('error haaaa') a_logger.fatal('oh no') logger.info('my name is:', logger.name) - for _ in range(5): - test_logger(logger) - test_logger(a_logger) + # for _ in range(5): + test_logger(logger) + test_logger(a_logger) print(Message_content(log_time=time.time(), text='aaa', level=4, marker='abc', end='abc', flush=False, frame=inspect.currentframe())) print(ColorCodeEnum.code_line.name)