logger-36 2025.18__py3-none-any.whl → 2025.20__py3-none-any.whl

logger_36/api/content.py

@@ -6,7 +6,6 @@ SEE COPYRIGHT NOTICE BELOW
 
 from logger_36.constant.message import LINE_INDENT  # noqa
 from logger_36.task.format.message import MessageWithActualExpected  # noqa
-from logger_36.task.format.rule import Rule, RuleAsText  # noqa
 
 """
 COPYRIGHT NOTICE

logger_36/catalog/config/console_rich.py

@@ -24,7 +24,7 @@ LEVEL_COLOR: dict[int, str | style_t] = {
 }
 ACTUAL_COLOR = LEVEL_COLOR[l.CRITICAL]
 EXPECTED_COLOR = "green3"
-DATE_TIME_COLOR = "sky_blue3"
+RULE_COLOR = "sky_blue3"
 
 ALTERNATIVE_BACKGROUND_FOR_LIGHT = style_t(bgcolor=color_t.from_rgb(230, 230, 230))
 ALTERNATIVE_BACKGROUND_FOR_DARK = style_t(bgcolor=color_t.from_rgb(25, 25, 25))

logger_36/catalog/handler/console.py

@@ -8,7 +8,6 @@ import logging as l
 import sys as s
 import typing as h
 
-from logger_36.task.format.rule import RuleAsText
 from logger_36.type.handler import handler_t as base_t
 
 
@@ -21,18 +20,18 @@ class console_handler_t(base_t):
         name: str | None = None,
         message_width: int = -1,
         level: int = l.NOTSET,
-        formatter: l.Formatter | None = None,
         **_,
     ) -> h.Self:
         """"""
-        return cls(name, message_width, level, formatter)
+        return cls(name, message_width, None, level)
 
     def emit(self, record: l.LogRecord, /) -> None:
         """"""
-        output = self.MessageFromRecord(
-            record, RuleAsText, line_width=self.message_width
-        )
-        s.__stdout__.write(output[0] + "\n")
+        s.__stdout__.write(self.MessageFromRecord(record)[0] + "\n")
+
+    def EmitAsIs(self, message: str, /) -> None:
+        """"""
+        s.__stdout__.write(message + "\n")
 
 
 """

logger_36/catalog/handler/console_rich.py

@@ -10,6 +10,7 @@ import typing as h
 from rich.console import Console as console_t  # noqa
 from rich.console import RenderableType as renderable_t  # noqa
 from rich.markup import escape as EscapedVersion  # noqa
+from rich.rule import Rule as rule_t  # noqa
 from rich.text import Text as text_t  # noqa
 from rich.traceback import install as InstallTracebackHandler  # noqa
 
@@ -17,15 +18,14 @@ from logger_36.catalog.config.console_rich import (
     ACTUAL_COLOR,
     ALTERNATIVE_BACKGROUND_FOR_DARK,
     ALTERNATIVE_BACKGROUND_FOR_LIGHT,
-    DATE_TIME_COLOR,
     EXPECTED_COLOR,
     GRAY_COLOR,
     LEVEL_COLOR,
+    RULE_COLOR,
     WHITE_COLOR,
 )
 from logger_36.config.message import ACTUAL_PATTERNS, EXPECTED_PATTERNS, WHERE_SEPARATOR
 from logger_36.constant.message import CONTEXT_LENGTH
-from logger_36.task.format.rule import Rule
 from logger_36.type.handler import handler_t as base_t
 
 _COMMON_TRACEBACK_ARGUMENTS = ("theme", "width")
@@ -51,12 +51,7 @@ class console_rich_handler_t(base_t):
     """
 
     def __init__(
-        self,
-        name: str | None,
-        message_width: int,
-        level: int,
-        formatter: l.Formatter | None,
-        kwargs,
+        self, name: str | None, message_width: int, level: int, kwargs
     ) -> None:
         """"""
         alternating_logs = kwargs.pop("alternating_logs", 0)
@@ -64,7 +59,7 @@ class console_rich_handler_t(base_t):
 
         assert alternating_logs in (0, 1, 2)
 
-        base_t.__init__(self, name, message_width, level, formatter, kwargs)
+        base_t.__init__(self, name, message_width, EscapedVersion, level, kwargs)
 
         self.console = None  # console_t | None.
         self.alternating_logs = alternating_logs
@@ -96,21 +91,20 @@ class console_rich_handler_t(base_t):
         name: str | None = None,
         message_width: int = -1,
         level: int = l.NOTSET,
-        formatter: l.Formatter | None = None,
         **kwargs,
     ) -> h.Self:
         """"""
-        return cls(name, message_width, level, formatter, kwargs)
+        return cls(name, message_width, level, kwargs)
+
+    def Rule(self, text: str | None, /, *, color: str = "black") -> str | rule_t:
+        """"""
+        if text is None:
+            return rule_t(style=color)
+        return rule_t(title=text_t(text, style=f"bold {color}"), style=color)
 
     def emit(self, record: l.LogRecord, /) -> None:
         """"""
-        message, is_not_a_rule = self.MessageFromRecord(
-            record,
-            Rule,
-            line_width=self.message_width,
-            color=DATE_TIME_COLOR,
-            PreProcessed=EscapedVersion,
-        )
+        message, is_not_a_rule = self.MessageFromRecord(record, rule_color=RULE_COLOR)
         if is_not_a_rule:
             message = HighlightedVersion(
                 self.console,
@@ -126,10 +120,6 @@ class console_rich_handler_t(base_t):
         """"""
         self.console.print(message, crop=False, overflow="ignore")
 
-    def EmitRule(self, /, *, text: str | None = None, color: str = "black") -> None:
-        """"""
-        self.EmitAsIs(Rule(text, color))
-
 
 def HighlightedVersion(
     _: console_t,

logger_36/catalog/handler/file.py

@@ -8,7 +8,6 @@ import logging as l
 import typing as h
 from pathlib import Path as path_t
 
-from logger_36.task.format.rule import RuleAsText
 from logger_36.type.handler import file_handler_t as base_t
 
 
@@ -21,18 +20,15 @@ class file_handler_t(base_t):
         name: str | None = None,
         message_width: int = -1,
         level: int = l.NOTSET,
-        formatter: l.Formatter | None = None,
         path: str | path_t | None = None,
         **_,
     ) -> h.Self:
         """"""
-        return cls(name, message_width, level, formatter, path)
+        return cls(name, message_width, None, level, path)
 
     def emit(self, record: l.LogRecord, /) -> None:
         """"""
-        output = self.MessageFromRecord(
-            record, RuleAsText, line_width=self.message_width
-        )
+        output = self.MessageFromRecord(record)
         self.stream.write(output[0] + "\n")
         self.stream.flush()
 

logger_36/catalog/handler/generic.py

@@ -10,28 +10,21 @@ import typing as h
 from logger_36.catalog.config.optional import RICH_IS_AVAILABLE
 
 if RICH_IS_AVAILABLE:
-    from rich.console import Console as console_t  # noqa
-    from rich.console import ConsoleOptions as console_options_t  # noqa
-    from rich.markup import escape as EscapedForRich  # noqa
-    from rich.terminal_theme import DEFAULT_TERMINAL_THEME  # noqa
+    from rich.console import Console as console_t
+    from rich.markup import escape as EscapedForRich
+    from rich.rule import Rule as rule_t
+    from rich.terminal_theme import DEFAULT_TERMINAL_THEME
+    from rich.text import Text as text_t
 
-    from logger_36.catalog.config.console_rich import DATE_TIME_COLOR
+    from logger_36.catalog.config.console_rich import RULE_COLOR
     from logger_36.catalog.handler.console_rich import HighlightedVersion
 else:
-    DATE_TIME_COLOR = HighlightedVersion = console_t = console_options_t = (
-        EscapedForRich
-    ) = DEFAULT_TERMINAL_THEME = None
+    console_t = EscapedForRich = rule_t = DEFAULT_TERMINAL_THEME = text_t = (
+        RULE_COLOR
+    ) = HighlightedVersion = None
 
-from logger_36.task.format.rule import Rule, RuleAsText
 from logger_36.type.handler import handler_t as base_t
 
-LogAsIs_h = h.Callable[[str | h.Any], None]
-
-
-@h.runtime_checkable
-class EmitRule_p(h.Protocol):
-    def __call__(self, /, *, text: str | None = None, color: str = "white") -> None: ...
-
 
 class generic_handler_t(base_t):
     """
@@ -42,12 +35,7 @@ class generic_handler_t(base_t):
     """
 
     def __init__(
-        self,
-        name: str | None,
-        message_width: int,
-        level: int,
-        formatter: l.Formatter | None,
-        kwargs,
+        self, name: str | None, message_width: int, level: int, kwargs
     ) -> None:
         """
         EmitAsIs: By definition, the generic handler does not know how to output
@@ -59,12 +47,13 @@ class generic_handler_t(base_t):
 
         assert alternating_logs in (0, 1, 2)
 
-        base_t.__init__(self, name, message_width, level, formatter, kwargs)
+        base_t.__init__(self, name, message_width, None, level, kwargs)
 
         if EmitAsIs is not None:
             self.EmitAsIs = EmitAsIs
+        self.is_rich = False
         self.console = None  # console_t | None.
-        self.console_options = None  # console_options_t | None.
+        self.console_options = None  # rich.console.ConsoleOptions | None.
         self.alternating_logs = alternating_logs
         self._log_parity = False
 
@@ -73,11 +62,12 @@ class generic_handler_t(base_t):
     def __post_init_local__(self, supports_html: bool) -> None:
         """"""
         if supports_html and (console_t is not None):
+            self.PreProcessedMessage = EscapedForRich
+            self.is_rich = True
             self.console = console_t(highlight=False, force_terminal=True)
             self.console_options = self.console.options.update(
                 overflow="ignore", no_wrap=True
             )
-            self.EmitRule = self._EmitRichRule
 
     @classmethod
     def New(
@@ -87,25 +77,25 @@ class generic_handler_t(base_t):
         name: str | None = None,
         message_width: int = -1,
         level: int = l.NOTSET,
-        formatter: l.Formatter | None = None,
         **kwargs,
     ) -> h.Self:
         """"""
-        return cls(name, message_width, level, formatter, kwargs)
+        return cls(name, message_width, level, kwargs)
+
+    def Rule(self, text: str | None, /, *, color: str = "black") -> str | rule_t:
+        """"""
+        if self.is_rich:
+            if text is None:
+                return rule_t(style=color)
+            return rule_t(title=text_t(text, style=f"bold {color}"), style=color)
+
+        return base_t.Rule(self, text, color=color)
 
     def emit(self, record: l.LogRecord, /) -> None:
         """"""
-        if self.console is None:
-            message = self.MessageFromRecord(
-                record, RuleAsText, line_width=self.message_width
-            )[0]
-        else:
+        if self.is_rich:
             message, is_not_a_rule = self.MessageFromRecord(
-                record,
-                Rule,
-                line_width=self.message_width,
-                color=DATE_TIME_COLOR,
-                PreProcessed=EscapedForRich,
+                record, rule_color=RULE_COLOR
             )
             if is_not_a_rule:
                 message = HighlightedVersion(
@@ -138,16 +128,12 @@ class generic_handler_t(base_t):
             message = (
                 "<pre style='margin-bottom:0px'>" + "".join(html_segments) + "</pre>"
             )
+        else:
+            message = self.MessageFromRecord(record)[0]
 
         self.EmitAsIs(message)
         self._log_parity = not self._log_parity
 
-    def _EmitRichRule(
-        self, /, *, text: str | None = None, color: str = "black"
-    ) -> None:
-        """"""
-        self.EmitAsIs(Rule(text, color))
-
 
 """
 COPYRIGHT NOTICE

logger_36/{task/format → constant}/rule.py

@@ -4,31 +4,10 @@ Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2023
 SEE COPYRIGHT NOTICE BELOW
 """
 
-from logger_36.catalog.config.optional import RICH_IS_AVAILABLE
-
-
-def RuleAsText(text: str | None, _: None, /) -> str:
-    """"""
-    if text is None:
-        return "---- ---- ---- ---- ---- ---- ---- ---- ----"
-    else:
-        return f"---- ---- ---- ---- {text} ---- ---- ---- ----"
-
-
-if RICH_IS_AVAILABLE:
-    from rich.rule import Rule as rule_t  # noqa
-    from rich.text import Text as text_t  # noqa
-
-    def Rule(text: str | None, color: str, /) -> rule_t | str:
-        """"""
-        if text is None:
-            return rule_t(style=color)
-        else:
-            return rule_t(title=text_t(text, style=f"bold {color}"), style=color)
-
-else:
-    rule_t = text_t = None
-    Rule = lambda _, __: RuleAsText(_, None)
+RULE_CHARACTER = "-"
+MIN_HALF_RULE_LENGTH = 4
+DEFAULT_RULE_LENGTH = 50
+DEFAULT_RULE = DEFAULT_RULE_LENGTH * RULE_CHARACTER
 
 """
 COPYRIGHT NOTICE

logger_36/task/format/message.py

@@ -5,69 +5,10 @@ SEE COPYRIGHT NOTICE BELOW
 """
 
 import difflib as diff
-import logging as l
 import typing as h
 
-from logger_36.config.message import (
-    LEVEL_CLOSING,
-    LEVEL_OPENING,
-    MESSAGE_MARKER,
-    WHERE_SEPARATOR,
-)
 from logger_36.constant.generic import NOT_PASSED
-from logger_36.constant.message import NEXT_LINE_PROLOGUE, expected_op_h
-from logger_36.constant.record import SHOW_W_RULE_ATTR
-from logger_36.extension.line import WrappedLines
-from logger_36.type.message import RuleWithText_h
-
-
-def MessageFromRecord(
-    record: l.LogRecord,
-    RuleWithText: RuleWithText_h,
-    /,
-    *,
-    line_width: int = 0,
-    color: str | None = None,
-    PreProcessed: h.Callable[[str], str] | None = None,
-) -> tuple[str, bool]:
-    """
-    See logger_36.catalog.handler.README.txt.
-
-    The second returned value is is_not_a_rule.
-    """
-    message = record.msg
-
-    if hasattr(record, SHOW_W_RULE_ATTR):
-        return RuleWithText(message, color), False
-
-    if PreProcessed is not None:
-        message = PreProcessed(message)
-    if (line_width <= 0) or (message.__len__() <= line_width):
-        if "\n" in message:
-            message = NEXT_LINE_PROLOGUE.join(message.splitlines())
-    else:
-        if "\n" in message:
-            lines = WrappedLines(message.splitlines(), line_width)
-        else:
-            lines = WrappedLines([message], line_width)
-        message = NEXT_LINE_PROLOGUE.join(lines)
-
-    when_or_elapsed = getattr(record, "when_or_elapsed", None)
-    if when_or_elapsed is None:
-        return message, True
-
-    level_first_letter = getattr(record, "level_first_letter", "")
-
-    if (where := getattr(record, "where", None)) is None:
-        where = ""
-    else:
-        where = f"{NEXT_LINE_PROLOGUE}{WHERE_SEPARATOR} {where}"
-
-    return (
-        f"{when_or_elapsed}"
-        f"{LEVEL_OPENING}{level_first_letter}{LEVEL_CLOSING} "
-        f"{MESSAGE_MARKER} {message}{where}"
-    ), True
+from logger_36.constant.message import expected_op_h
 
 
 def MessageWithActualExpected(

logger_36/type/handler.py

@@ -5,23 +5,38 @@ SEE COPYRIGHT NOTICE BELOW
 """
 
 import logging as l
-import sys as s
 import typing as h
 from pathlib import Path as path_t
 
-from logger_36.config.message import FALLBACK_MESSAGE_WIDTH
-from logger_36.task.format.message import MessageFromRecord
-from logger_36.task.format.rule import RuleAsText
-from logger_36.type.message import MessageFromRecord_h, RuleWithText_h
-
-
-class _base_t:
-    def __init__(self, name: str | None, message_width: int) -> None:
+from logger_36.config.message import (
+    FALLBACK_MESSAGE_WIDTH,
+    LEVEL_CLOSING,
+    LEVEL_OPENING,
+    MESSAGE_MARKER,
+    WHERE_SEPARATOR,
+)
+from logger_36.constant.message import NEXT_LINE_PROLOGUE
+from logger_36.constant.record import SHOW_W_RULE_ATTR
+from logger_36.constant.rule import (
+    DEFAULT_RULE,
+    DEFAULT_RULE_LENGTH,
+    MIN_HALF_RULE_LENGTH,
+    RULE_CHARACTER,
+)
+from logger_36.extension.line import WrappedLines
+
+
+class extension_t:
+    def __init__(
+        self,
+        name: str | None,
+        message_width: int,
+        PreProcessedMessage: h.Callable[[str], str] | None,
+    ) -> None:
         """"""
         self.name = name
         self.message_width = message_width
-        #
-        self.MessageFromRecord: MessageFromRecord_h | None = None
+        self.PreProcessedMessage = PreProcessedMessage
 
         self.__post_init__()
 
@@ -40,37 +55,95 @@ class _base_t:
         """
         raise NotImplementedError
 
+    def MessageFromRecord(
+        self, record: l.LogRecord, /, *, rule_color: str | None = None
+    ) -> tuple[str, bool]:
+        """
+        The second returned value is is_not_a_rule.
+        """
+        message = record.msg  # See logger_36.catalog.handler.README.txt.
+        if self.PreProcessedMessage is not None:
+            message = self.PreProcessedMessage(message)
+
+        if hasattr(record, SHOW_W_RULE_ATTR):
+            return self.Rule(message, color=rule_color), False
+
+        if (self.message_width <= 0) or (message.__len__() <= self.message_width):
+            if "\n" in message:
+                message = NEXT_LINE_PROLOGUE.join(message.splitlines())
+        else:
+            if "\n" in message:
+                lines = WrappedLines(message.splitlines(), self.message_width)
+            else:
+                lines = WrappedLines([message], self.message_width)
+            message = NEXT_LINE_PROLOGUE.join(lines)
+
+        when_or_elapsed = getattr(record, "when_or_elapsed", None)
+        if when_or_elapsed is None:
+            return message, True
+
+        if (where := getattr(record, "where", None)) is None:
+            where = ""
+        else:
+            where = f"{NEXT_LINE_PROLOGUE}{WHERE_SEPARATOR} {where}"
+
+        return (
+            f"{when_or_elapsed}"
+            f"{LEVEL_OPENING}{record.levelname[0]}{LEVEL_CLOSING} "
+            f"{MESSAGE_MARKER} {message}{where}"
+        ), True
+
+    def Rule(self, text: str | None, /, *, color: str = "black") -> str | h.Any:
+        """
+        Return type hint h.Any: For Rich, for example.
+        """
+        if text is None:
+            if self.message_width > 0:
+                return self.message_width * RULE_CHARACTER
+            return DEFAULT_RULE
+
+        if self.message_width > 0:
+            target_width = self.message_width
+        else:
+            target_width = DEFAULT_RULE_LENGTH
+        half_rule_length = max(
+            (target_width - text.__len__() - 2) // 2, MIN_HALF_RULE_LENGTH
+        )
+        half_rule = half_rule_length * RULE_CHARACTER
+
+        return f"{half_rule} {text} {half_rule}"
+
     def EmitAsIs(self, message: str, /) -> None:
         """"""
-        s.__stdout__.write(message + "\n")
+        raise NotImplementedError
 
     def EmitRule(self, /, *, text: str | None = None, color: str = "black") -> None:
         """"""
-        self.EmitAsIs(RuleAsText(text, None))
+        self.EmitAsIs(self.Rule(text, color=color))
 
 
-class handler_t(l.Handler, _base_t):
+class handler_t(l.Handler, extension_t):
     def __init__(
         self,
         name: str | None,
         message_width: int,
+        PreProcessedMessage: h.Callable[[str], str] | None,
         level: int,
-        formatter: l.Formatter | None,
         *_,
     ) -> None:
         """"""
         l.Handler.__init__(self)
-        _base_t.__init__(self, name, message_width)
-        __post_init__(self, level, formatter)
+        extension_t.__init__(self, name, message_width, PreProcessedMessage)
+        __post_init__(self, level)
 
 
-class file_handler_t(l.FileHandler, _base_t):
+class file_handler_t(l.FileHandler, extension_t):
     def __init__(
         self,
         name: str | None,
         message_width: int,
+        PreProcessedMessage: h.Callable[[str], str] | None,
         level: int,
-        formatter: l.Formatter | None,
         path: str | path_t | None,
         *_,
     ) -> None:
@@ -83,38 +156,17 @@ class file_handler_t(l.FileHandler, _base_t):
             raise ValueError(f"File or folder already exists: {path}.")
 
         l.FileHandler.__init__(self, path)
-        _base_t.__init__(self, name, message_width)
-        __post_init__(self, level, formatter)
+        extension_t.__init__(self, name, message_width, PreProcessedMessage)
+        __post_init__(self, level)
 
 
 any_handler_t = handler_t | file_handler_t
 
 
-def __post_init__(
-    handler: any_handler_t, level: int, formatter: l.Formatter | None
-) -> None:
+def __post_init__(handler: any_handler_t, level: int) -> None:
     """"""
     handler.setLevel(level)
 
-    if formatter is None:
-        handler.MessageFromRecord = MessageFromRecord
-    else:
-        handler.setFormatter(formatter)
-        _MessageFromRecordRaw = handler.formatter.format
-
-        def _MessageFromRecord(
-            record: l.LogRecord,
-            _: RuleWithText_h,
-            /,
-            *,
-            line_width: int = 0,
-            PreProcessed: h.Callable[[str], str] | None = None,
-        ) -> tuple[str, bool]:
-            #
-            return _MessageFromRecordRaw(record), False
-
-        handler.MessageFromRecord = _MessageFromRecord
-
 
 """
 COPYRIGHT NOTICE

logger_36/type/logger.py

@@ -38,12 +38,12 @@ from logger_36.constant.memory import UNKNOWN_MEMORY_USAGE
 from logger_36.constant.message import LINE_INDENT, TIME_LENGTH_m_1, expected_op_h
 from logger_36.constant.path import PROJECT_FILE_RELATIVE, USER_FOLDER
 from logger_36.constant.record import SHOW_W_RULE_ATTR, SHOW_WHERE_ATTR
-from logger_36.task.format.message import MessageFromRecord, MessageWithActualExpected
-from logger_36.task.format.rule import RuleAsText
+from logger_36.task.format.message import MessageWithActualExpected
 from logger_36.task.measure.chronos import ElapsedTime
 from logger_36.task.measure.memory import CanCheckUsage as CanCheckMemoryUsage
 from logger_36.task.measure.memory import CurrentUsage as CurrentMemoryUsage
 from logger_36.type.handler import any_handler_t as base_handler_t
+from logger_36.type.handler import extension_t as handler_extension_t
 from logger_36.type.issue import NewIssue, issue_t
 
 if RICH_IS_AVAILABLE:
@@ -98,9 +98,10 @@ class logger_t(base_t):
         init=False, default_factory=dict
     )
     intercepts_exceptions: bool = d.field(init=False, default=False)
-    _on_hold: list[l.LogRecord] = d.field(init=False, default_factory=list)
     _should_hold_messages: bool = d.field(init=False, default=True)
     _should_activate_log_interceptions: bool = d.field(init=False, default=False)
+    _on_hold: list[l.LogRecord] = d.field(init=False, default_factory=list)
+    _recording_handler: handler_extension_t | None = d.field(init=False, default=None)
 
     name_: d.InitVar[str | None] = None
     level_: d.InitVar[int] = l.NOTSET
@@ -164,8 +165,11 @@ class logger_t(base_t):
         self.setLevel(level_)
         self.propagate = False  # Part of base_t.
 
-        for level in l.getLevelNamesMapping().values():
-            self.events[level] = 0
+        if self.should_record_messages:
+            self.ActivateMessageRecording()
+
+        for level_id in l.getLevelNamesMapping().values():
+            self.events[level_id] = 0
 
         if activate_wrn_interceptions:
             self.ToggleWarningInterceptions(True)
@@ -190,35 +194,10 @@ class logger_t(base_t):
         elapsed_time, now = ElapsedTime(should_return_now=True)
 
         if (self._on_hold.__len__() > 0) and not self._should_hold_messages:
-            for held in self._on_hold:
-                if self.should_record_messages:
-                    self.recorded.append(
-                        (held.levelno, MessageFromRecord(held, RuleAsText)[0])
-                    )
-                base_t.handle(self, held)
-            self._on_hold.clear()
+            self._FlushRecordsOnHold()
 
         if (date := now.date()) != self.last_message_date:
-            self.last_message_date = date
-            date_record = l.makeLogRecord(
-                {
-                    "name": self.name,
-                    "levelno": l.INFO,  # For management by logging.Logger.handle.
-                    "msg": f"DATE: {date.strftime(DATE_FORMAT)}",
-                    SHOW_W_RULE_ATTR: True,
-                }
-            )
-            if self._should_hold_messages:
-                self._on_hold.append(date_record)
-            else:
-                if self.should_record_messages:
-                    self.recorded.append(
-                        (
-                            date_record.levelno,
-                            MessageFromRecord(date_record, RuleAsText)[0],
-                        )
-                    )
-                base_t.handle(self, date_record)
+            self._AcknowledgeDateChange(date)
 
         # When.
         if now - self.last_message_now > LONG_ENOUGH:
@@ -246,9 +225,6 @@ class logger_t(base_t):
         else:
             where = None
 
-        # How.
-        record.level_first_letter = record.levelname[0]
-
         # What.
         if not isinstance(record.msg, str):
             record.msg = str(record.msg)
@@ -256,11 +232,11 @@ class logger_t(base_t):
         if self._should_hold_messages:
             self._on_hold.append(record)
         else:
-            if self.should_record_messages:
-                self.recorded.append(
-                    (record.levelno, MessageFromRecord(record, RuleAsText)[0])
-                )
-            base_t.handle(self, record)
+            self._HandleRecord(record)
+        self.events[record.levelno] += 1
+
+        if self.should_watch_memory_usage:
+            self.memory_usages.append((where, CurrentMemoryUsage()))
 
         if (self.exit_on_critical and (record.levelno is l.CRITICAL)) or (
             self.exit_on_error and (record.levelno is l.ERROR)
@@ -269,34 +245,49 @@ class logger_t(base_t):
             # __post_init__ set self.exit_on_critical if self.exit_on_error.
             s.exit(1)
 
-        self.events[record.levelno] += 1
+    def _FlushRecordsOnHold(self) -> None:
+        """"""
+        for held in self._on_hold:
+            self._HandleRecord(held)
 
-        if self.should_watch_memory_usage:
-            self.memory_usages.append((where, CurrentMemoryUsage()))
+        self._on_hold.clear()
 
-    def MakeMonochrome(self) -> None:
+    def _AcknowledgeDateChange(self, date: date_t, /) -> None:
         """"""
-        self.AddHandler(console_handler_t)
+        self.last_message_date = date
+
+        record = l.makeLogRecord(
+            {
+                "name": self.name,
+                "levelno": l.INFO,  # For management by logging.Logger.handle.
+                "msg": f"DATE: {date.strftime(DATE_FORMAT)}",
+                SHOW_W_RULE_ATTR: True,
+            }
+        )
 
-    def MakeRich(self, *, alternating_logs: int = 0) -> None:
+        if self._should_hold_messages:
+            self._on_hold.append(record)
+        else:
+            self._HandleRecord(record)
+
+    def _HandleRecord(self, record: l.LogRecord, /) -> None:
         """"""
-        if MISSING_RICH_MESSAGE is not None:
-            s.__stderr__.write(MISSING_RICH_MESSAGE + "\n")
+        if self.should_record_messages:
+            message = self._recording_handler.MessageFromRecord(record)[0]
+            self.recorded.append((record.levelno, message))
 
-        if console_rich_handler_t is console_handler_t:
-            handler_kwargs = {}
-        else:
-            handler_kwargs = {"alternating_logs": alternating_logs}
-        self.AddHandler(console_rich_handler_t, **handler_kwargs)
+        base_t.handle(self, record)
 
-    def MakePermanent(self, path: str | path_t, /) -> None:
+    def ActivateMessageRecording(self) -> None:
         """"""
-        self.AddHandler(file_handler_t, path=path)
+        self._recording_handler = handler_extension_t("recording_handler", 0, None)
+        self.should_record_messages = True  # Useless if called from __post_init__.
+        self.info(f'Message recording activated for logger "{self.name}"')
 
     def ResetEventCounts(self) -> None:
         """"""
-        for level in self.events:
-            self.events[level] = 0
+        for level_id in self.events:
+            self.events[level_id] = 0
 
     def ToggleWarningInterceptions(self, state: bool, /) -> None:
         """"""
@@ -373,27 +364,17 @@ class logger_t(base_t):
             self.intercepts_exceptions = False
             self.info("Exception Interception: OFF")
 
-    def DealWithException(self, _, exc_value, exc_traceback, /) -> None:
-        """"""
-        exception = exc_value.with_traceback(exc_traceback)
-        self.LogException(exception, level=l.CRITICAL)
-        s.exit(1)
-
-    def DealWithExceptionInThread(
-        self, exc_type, exc_value, exc_traceback, _, /
-    ) -> None:
-        """"""
-        self.DealWithException(exc_type, exc_value, exc_traceback)
-
     def AddHandler(
         self,
-        handler_t: type[base_handler_t],
+        handler_t_or_handler: type[base_handler_t]
+        | base_handler_t
+        | l.Handler
+        | l.FileHandler,
         /,
         *,
         name: str | None = None,
         level: int = l.INFO,
         message_width: int = -1,
-        formatter: l.Formatter | None = None,
         should_still_hold_messages: bool = False,
         **kwargs,
     ) -> None:
@@ -404,13 +385,12 @@ class logger_t(base_t):
 
         self._should_hold_messages = should_still_hold_messages
 
-        handler = handler_t.New(
-            name=name,
-            message_width=message_width,
-            level=level,
-            formatter=formatter,
-            **kwargs,
-        )
+        if isinstance(handler_t_or_handler, type):
+            handler = handler_t_or_handler.New(
+                name=name, message_width=message_width, level=level, **kwargs
+            )
+        else:
+            handler = handler_t_or_handler
         base_t.addHandler(self, handler)
 
         path = getattr(handler, "baseFilename", "")
@@ -421,6 +401,25 @@ class logger_t(base_t):
             f"level {handler.level}={l.getLevelName(handler.level)}{path}"
         )
 
+    def MakeMonochrome(self) -> None:
+        """"""
+        self.AddHandler(console_handler_t)
+
+    def MakeRich(self, *, alternating_logs: int = 0) -> None:
+        """"""
+        if MISSING_RICH_MESSAGE is not None:
+            s.__stderr__.write(MISSING_RICH_MESSAGE + "\n")
+
+        if console_rich_handler_t is console_handler_t:
+            handler_kwargs = {}
+        else:
+            handler_kwargs = {"alternating_logs": alternating_logs}
+        self.AddHandler(console_rich_handler_t, **handler_kwargs)
+
+    def MakePermanent(self, path: str | path_t, /) -> None:
+        """"""
+        self.AddHandler(file_handler_t, path=path)
+
     def __call__(self, *args, **kwargs) -> None:
         """
         For a print-like calling for print-based debugging.
@@ -483,13 +482,26 @@ class logger_t(base_t):
             message = f"Exception of type {type(exception).__name__}\n----\n{formatted}"
         self.log(level, message, extra={SHOW_WHERE_ATTR: False})
 
+    def DealWithException(self, _, exc_value, exc_traceback, /) -> None:
+        """"""
+        exception = exc_value.with_traceback(exc_traceback)
+        self.LogException(exception, level=l.CRITICAL)
+        s.exit(1)
+
+    def DealWithExceptionInThread(
+        self, exc_type, exc_value, exc_traceback, _, /
+    ) -> None:
+        """"""
+        self.DealWithException(exc_type, exc_value, exc_traceback)
+
     def LogAsIs(self, message: str, /, *, indented: bool = False) -> None:
         """"""
         if indented:
             message = text.indent(message, LINE_INDENT)
 
         for handler in self.handlers:
-            handler.EmitAsIs(message)
+            if (EmitAsIs := getattr(handler, "EmitAsIs", None)) is not None:
+                EmitAsIs(message)
 
     info_raw = LogAsIs  # To follow the convention of the logging methods info, error...
 
@@ -498,7 +510,8 @@ class logger_t(base_t):
     ) -> None:
         """"""
         for handler in self.handlers:
-            handler.EmitRule(text=message, color=color)
+            if (EmitRule := getattr(handler, "EmitRule", None)) is not None:
+                EmitRule(text=message, color=color)
 
     def AddContextLevel(self, new_level: str, /) -> None:
         """"""

logger_36/version.py

@@ -4,7 +4,7 @@ Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2023
 SEE COPYRIGHT NOTICE BELOW
 """
 
-__version__ = "2025.18"
+__version__ = "2025.20"
 
 """
 COPYRIGHT NOTICE

{logger_36-2025.18.dist-info → logger_36-2025.20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: logger-36
-Version: 2025.18
+Version: 2025.20
 Summary: Simple logger with a catalog of handlers
 Home-page: https://src.koda.cnrs.fr/eric.debreuve/logger-36/
 Author: Eric Debreuve

{logger_36-2025.18.dist-info → logger_36-2025.20.dist-info}/RECORD

@@ -1,18 +1,18 @@
 logger_36/__init__.py,sha256=mK6AD0eWI2Sk42oxleTvsxzYJ28FbHK5WNkpLgAhnNE,2129
-logger_36/version.py,sha256=IGK2AtFu27rKPgT-azGp5zuAMQXCLFqA56YY96_pPQA,1680
-logger_36/api/content.py,sha256=0pKjxSG1hmxAkf4tBvXXOI_qrtbSx7_4Vyz-9BF_-MQ,1855
+logger_36/version.py,sha256=vDO1d9-QYkQ8yZUGGG46kdG9NRQx6ONSvh6-E6JGHu4,1680
+logger_36/api/content.py,sha256=DuT4UX4r_1DTXzuuRD-tvsTZk5X-Nj11loBKhuWOMw0,1791
 logger_36/api/gpu.py,sha256=NNs1IvQ7bh8Dppm8O8K2YLWbm4rogc3Ie_-D6xzkX3g,1726
 logger_36/api/memory.py,sha256=vOY4cTTrC3u7L0OrKXdPNlsCahYjCrY4h7iqpGZv9kU,2217
 logger_36/api/storage.py,sha256=RYjn2TD-E1zfNTMgm4b2mbYNVtTwsCUMbuPlMbuvgP0,1774
 logger_36/api/system.py,sha256=h-3GfhZPwawv0UKBWKkT1LzxSCZwpA2VIsy03lLYi6w,1725
 logger_36/api/time.py,sha256=JG0vgzPSRZ7UWQyoihnVu4sjPC-okFIKA3ZyNh2GaZo,1798
 logger_36/api/type.py,sha256=eLZ2yuH-sYeh4Z2KnAwTRJEbmkmgzBPMncdqXfFUTG8,1760
-logger_36/catalog/config/console_rich.py,sha256=tHUM1hUg-RTBXamjK_EkNO1Woob9ML2R_o6WBkzwe4A,2335
+logger_36/catalog/config/console_rich.py,sha256=t9p9-AkSgPiLAsm1evAdbz77g7JcVLePhUJ1FzNi3cY,2330
 logger_36/catalog/config/optional.py,sha256=5vabOlEQIFxoT_y4AjP19rpOjBuUJplpuBkLoCIKImA,1872
-logger_36/catalog/handler/console.py,sha256=fJt9zAjEh0XbORO-81mWX4QjPu0bJaf9sCbgTCtcFkY,2390
-logger_36/catalog/handler/console_rich.py,sha256=nGpt3iayFBkOVHqs_oa02W8__QmBykNDZb-QsK_Rrok,6347
-logger_36/catalog/handler/file.py,sha256=pezjcFCaA5zdV3GtHLaU_pfsp_YopvKYGHJAOZ69Vzs,2621
-logger_36/catalog/handler/generic.py,sha256=Gye1wS7VialSK6TbZi1g2yk67tG1bVIk5kWtw__BUlk,6683
+logger_36/catalog/handler/console.py,sha256=OKtRG3PseT06_UwZBtbragNIKvCqa7ZsLphYEsgeq2c,2308
+logger_36/catalog/handler/console_rich.py,sha256=b3B_pQefv0IeQFEj-tZ5-tH8RrcessZI8sI4Tyf17bg,6180
+logger_36/catalog/handler/file.py,sha256=JReN8KruN8eKhBfG9sj72kkHfukHK4-8mdSxNpgFhLU,2455
+logger_36/catalog/handler/generic.py,sha256=0Z4Vm-AAc92szghYEzihkm9CBRzCvqgdUTXH_p98S4o,6314
 logger_36/catalog/logger/chronos.py,sha256=S4m9TMPQy_Ju500mpE1jNzu2gZG-QKdVuvX9RVRKHR8,1911
 logger_36/catalog/logger/gpu.py,sha256=Py5YY0nD_pqJzJsEKQYoOGHcPqyNVJ3J2noOS3hDL6g,2890
 logger_36/catalog/logger/memory.py,sha256=J0ZGKO7j1FZA_aDGxpABtvzDy1RjCDiDmWYh4U98fEI,4253
@@ -30,6 +30,7 @@ logger_36/constant/memory.py,sha256=Q_E5tTWa-cGaNwrE_xmKa3BxQG6oJO6DHczrxc_M4sE,
 logger_36/constant/message.py,sha256=YJOEzdI0ZjUOdHo3CsiS56FVPhrfNoQYvXuUkprH61g,2312
 logger_36/constant/path.py,sha256=OfLh70Jyc8po9Ls34nQh_bRr3PXyQ3kF9ciR9QPhiqI,2213
 logger_36/constant/record.py,sha256=gQCGLxq8Vs789Ty_qaRNKy18mqlyMT_4kyN-T9r_rGE,1734
+logger_36/constant/rule.py,sha256=tBKQgPTt6G_p5eInDdWoEEAvQFz4WMSt5THsS5jvk14,1779
 logger_36/constant/system.py,sha256=pLlLXG5sepQlSUOo3TphaGrHg8xzJBp-GxpL2NPP47k,1904
 logger_36/extension/html_.py,sha256=W9SyiYsaaYHUrHLGAAN2wiJGXUlwOBJ5gzdjmEcnF18,3342
 logger_36/extension/line.py,sha256=joeojQX1bZJM53333mOEU3s-YC5ExGOrN9Cu9Lh5-FU,2617
@@ -38,16 +39,14 @@ logger_36/instance/loggers.py,sha256=inBk4KKrQ-z3szaopQ29-qQwh1iSc842sWo5J6zJoiM
 logger_36/task/inspection.py,sha256=ZgPcrPo3h_kEnM-UpHDLg7PAFfB2fqsLFdfmi6hlPVA,4484
 logger_36/task/storage.py,sha256=KAILmJlF5IULxEX9QRCyXCwcalp5mpunWVh1oXuLvSs,3516
 logger_36/task/format/memory.py,sha256=J1Oy3jw8wjSp2kuiRUm_VFpzXOHX2FOc7nuRrCyrskw,3723
-logger_36/task/format/message.py,sha256=SqVtiWzcuMl5xPI2kmz2wkQP05amX3wKy0C0qdfXB3I,5245
-logger_36/task/format/rule.py,sha256=4wQpeBBbCeF13rXl3Q9UEvvYh4sJOFfk6hOvJHDXYvY,2384
+logger_36/task/format/message.py,sha256=Rm6zymVEEGcgKfmxMPXP7q3PtwZJKlXGhqZ5tnvlwxA,3502
 logger_36/task/measure/chronos.py,sha256=7ijMZgP4EP18HbLV2yCxpNpRS9724Wyk523f-nkbhUM,2529
 logger_36/task/measure/memory.py,sha256=kkPHEIUTUhkCOLrAt01eLJLnsnkl0nFPNhFZdIB_JAw,1991
-logger_36/type/handler.py,sha256=JxUGjFSHFnX-6xM5f5vD00e1OQMPlPlLvopR32qd1kY,4763
+logger_36/type/handler.py,sha256=ChxP1j9PXLmoiNcsOdxI4bYVdr75v7HeCWp_iYJ2WNY,6602
 logger_36/type/issue.py,sha256=QHAYf7QgrjJUtF2D46z6X630qTgeP_0FE5hIwf54RsE,2688
-logger_36/type/logger.py,sha256=UuZt8A4AtWU78k9ryCY6gFe-Q7xzFrDvqbTEX10EgXs,25012
+logger_36/type/logger.py,sha256=tWdexeJT9IrxKK2NQmnHi1WVmN16xR8RNZPMc__SWBs,25447
 logger_36/type/loggers.py,sha256=7EX7Sg_RlduBjdfFlNZmUfNeDloH1xU30Rdkg_-rXh8,3172
-logger_36/type/message.py,sha256=pv9yJKd_GXuctUFWIjvcFoekNrBu0hDg0fqj_KAFwjI,2537
-logger_36-2025.18.dist-info/METADATA,sha256=uUcAg2M2fBGUYwHYNmRvCpM-ShfH-VxsCNbL3oheDK0,6529
-logger_36-2025.18.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-logger_36-2025.18.dist-info/top_level.txt,sha256=sM95BTMWmslEEgR_1pzwZsOeSp8C_QBiu8ImbFr0XLc,10
-logger_36-2025.18.dist-info/RECORD,,
+logger_36-2025.20.dist-info/METADATA,sha256=On7rI0r81M6ehWSyX7ZPiBKYVZoLqMPj-1VJWRuSd50,6529
+logger_36-2025.20.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+logger_36-2025.20.dist-info/top_level.txt,sha256=sM95BTMWmslEEgR_1pzwZsOeSp8C_QBiu8ImbFr0XLc,10
+logger_36-2025.20.dist-info/RECORD,,

logger_36/type/message.py

@@ -1,76 +0,0 @@
-"""
-Copyright CNRS (https://www.cnrs.fr/index.php/en)
-Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2023
-SEE COPYRIGHT NOTICE BELOW
-"""
-
-import logging as l
-import typing as h
-
-from logger_36.catalog.config.optional import RICH_IS_AVAILABLE
-
-
-@h.runtime_checkable
-class _RuleAsText_p(h.Protocol):
-    def __call__(self, text: str | None, color: None, /) -> str: ...
-
-
-if RICH_IS_AVAILABLE:
-    from rich.rule import Rule as rule_t  # noqa
-
-    @h.runtime_checkable
-    class _Rule_p(h.Protocol):
-        def __call__(self, text: str | None, color: str, /) -> rule_t | str: ...
-else:
-    _Rule_p = None
-
-RuleWithText_h = _RuleAsText_p | _Rule_p
-
-
-@h.runtime_checkable
-class _MessageFromRecordPreprocessed_p(h.Protocol):
-    def __call__(
-        self,
-        record: l.LogRecord,
-        RuleWithText: RuleWithText_h,
-        /,
-        *,
-        line_width: int = 0,
-        PreProcessed: h.Callable[[str], str] | None = None,
-    ) -> tuple[str, bool]: ...
-
-
-MessageFromRecord_h = _MessageFromRecordPreprocessed_p
-
-
-"""
-COPYRIGHT NOTICE
-
-This software is governed by the CeCILL  license under French law and
-abiding by the rules of distribution of free software.  You can  use,
-modify and/ or redistribute the software under the terms of the CeCILL
-license as circulated by CEA, CNRS and INRIA at the following URL
-"http://www.cecill.info".
-
-As a counterpart to the access to the source code and  rights to copy,
-modify and redistribute granted by the license, users are provided only
-with a limited warranty  and the software's author,  the holder of the
-economic rights,  and the successive licensors  have only  limited
-liability.
-
-In this respect, the user's attention is drawn to the risks associated
-with loading,  using,  modifying and/or developing or reproducing the
-software by the user in light of its specific status of free software,
-that may mean  that it is complicated to manipulate,  and  that  also
-therefore means  that it is reserved for developers  and  experienced
-professionals having in-depth computer knowledge. Users are therefore
-encouraged to load and test the software's suitability as regards their
-requirements in conditions enabling the security of their systems and/or
-data to be ensured and,  more generally, to use and operate it in the
-same conditions as regards security.
-
-The fact that you are presently reading this means that you have had
-knowledge of the CeCILL license and that you accept its terms.
-
-SEE LICENCE NOTICE: file README-LICENCE-utf8.txt at project source root.
-"""