logger-36 2025.13__py3-none-any.whl → 2025.14__py3-none-any.whl

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.constant.record import SHOW_W_RULE_ATTR
 from logger_36.task.format.rule import RuleAsText
 from logger_36.type.handler import handler_t as base_t
 
@@ -26,29 +25,25 @@ class console_handler_t(base_t):
         message_width: int = -1,
         level: int = l.NOTSET,
         formatter: l.Formatter | None = None,
-        **unused,
+        **_,
     ) -> h.Self:
         """"""
         return cls(name, should_store_memory_usage, message_width, level, formatter)
 
     def emit(self, record: l.LogRecord, /) -> None:
         """"""
-        if hasattr(record, SHOW_W_RULE_ATTR):
-            message = RuleAsText(record.msg)
-        else:
-            message = self.MessageFromRecord(record, line_width=self.message_width)
-        s.__stdout__.write(message + "\n")
+        message = self.MessageFromRecord(
+            record, RuleAsText, line_width=self.message_width
+        )
+        s.__stdout__.write(message[0] + "\n")
 
     def LogAsIs(self, message: str, /) -> None:
-        """
-        See documentation of
-        logger_36.catalog.handler.generic.generic_handler_t.LogAsIs.
-        """
+        """"""
         s.__stdout__.write(message + "\n")
 
-    def DisplayRule(self, /, *, text: str | None = None, color: str = "white") -> None:
+    def DisplayRule(self, /, *, text: str | None = None, color: str = "black") -> None:
         """"""
-        self.LogAsIs(RuleAsText(text))
+        self.LogAsIs(RuleAsText(text, None))
 
 
 """

logger_36/catalog/handler/console_rich.py

@@ -25,7 +25,6 @@ from logger_36.catalog.config.console_rich import (
 )
 from logger_36.config.message import ACTUAL_PATTERNS, EXPECTED_PATTERNS, WHERE_SEPARATOR
 from logger_36.constant.message import CONTEXT_LENGTH
-from logger_36.constant.record import SHOW_W_RULE_ATTR
 from logger_36.task.format.rule import Rule
 from logger_36.type.handler import handler_t as base_t
 
@@ -53,33 +52,36 @@ class console_rich_handler_t(base_t):
 
     kind: h.ClassVar[str] = "c"
 
-    @classmethod
-    def New(
-        cls,
-        /,
-        *,
-        name: str | None = None,
-        should_store_memory_usage: bool = False,
-        message_width: int = -1,
-        level: int = l.NOTSET,
-        formatter: l.Formatter | None = None,
-        **kwargs,
-    ) -> h.Self:
+    def __init__(
+        self,
+        name: str | None,
+        should_store_memory_usage: bool,
+        message_width: int,
+        level: int,
+        formatter: l.Formatter | None,
+        kwargs,
+    ) -> None:
         """"""
         alternating_logs = kwargs.pop("alternating_logs", 0)
         should_install_traceback = kwargs.pop("should_install_traceback", False)
 
         assert alternating_logs in (0, 1, 2)
 
-        output = cls(name, should_store_memory_usage, message_width, level, formatter)
+        base_t.__init__(
+            self,
+            name,
+            should_store_memory_usage,
+            message_width,
+            level,
+            formatter,
+            kwargs,
+        )
 
-        output.console = None  # console_t | None.
-        output.alternating_logs = alternating_logs
-        output.log_parity = False
+        self.console = None  # console_t | None.
+        self.alternating_logs = alternating_logs
+        self._log_parity = False
 
-        output.__post_init_local__(should_install_traceback, **kwargs)
-
-        return output
+        self.__post_init_local__(should_install_traceback, **kwargs)
 
     def __post_init_local__(self, should_install_traceback: bool, **kwargs) -> None:
         """"""
@@ -97,32 +99,48 @@ class console_rich_handler_t(base_t):
             traceback_kwargs["console"] = self.console
             InstallTracebackHandler(**traceback_kwargs)
 
+    @classmethod
+    def New(
+        cls,
+        /,
+        *,
+        name: str | None = None,
+        should_store_memory_usage: bool = False,
+        message_width: int = -1,
+        level: int = l.NOTSET,
+        formatter: l.Formatter | None = None,
+        **kwargs,
+    ) -> h.Self:
+        """"""
+        return cls(
+            name, should_store_memory_usage, message_width, level, formatter, kwargs
+        )
+
     def emit(self, record: l.LogRecord, /) -> None:
         """"""
-        if hasattr(record, SHOW_W_RULE_ATTR):
-            richer = Rule(record.msg, DATE_TIME_COLOR)
-        else:
-            message = self.MessageFromRecord(
-                record, line_width=self.message_width, PreProcessed=EscapedVersion
-            )
-            richer = HighlightedVersion(
+        message, is_not_a_rule = self.MessageFromRecord(
+            record,
+            Rule,
+            line_width=self.message_width,
+            color=DATE_TIME_COLOR,
+            PreProcessed=EscapedVersion,
+        )
+        if is_not_a_rule:
+            message = HighlightedVersion(
                 self.console,
                 message,
                 record.levelno,
                 self.alternating_logs,
-                self.log_parity,
+                self._log_parity,
             )
-        self.console.print(richer, crop=False, overflow="ignore")
-        self.log_parity = not self.log_parity
+        self.console.print(message, crop=False, overflow="ignore")
+        self._log_parity = not self._log_parity
 
     def LogAsIs(self, message: str | renderable_t, /) -> None:
-        """
-        See documentation of
-        logger_36.catalog.handler.generic.generic_handler_t.LogAsIs.
-        """
+        """"""
         self.console.print(message, crop=False, overflow="ignore")
 
-    def DisplayRule(self, /, *, text: str | None = None, color: str = "white") -> None:
+    def DisplayRule(self, /, *, text: str | None = None, color: str = "black") -> None:
         """"""
         self.LogAsIs(Rule(text, color))
 

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.constant.record import SHOW_W_RULE_ATTR
 from logger_36.task.format.rule import RuleAsText
 from logger_36.type.handler import file_handler_t as base_t
 
@@ -27,7 +26,7 @@ class file_handler_t(base_t):
         level: int = l.NOTSET,
         formatter: l.Formatter | None = None,
         path: str | path_t | None = None,
-        **unused,
+        **_,
     ) -> h.Self:
         """"""
         return cls(
@@ -36,24 +35,20 @@ class file_handler_t(base_t):
 
     def emit(self, record: l.LogRecord, /) -> None:
         """"""
-        if hasattr(record, SHOW_W_RULE_ATTR):
-            message = RuleAsText(record.msg)
-        else:
-            message = self.MessageFromRecord(record, line_width=self.message_width)
-        self.stream.write(message + "\n")
+        message = self.MessageFromRecord(
+            record, RuleAsText, line_width=self.message_width
+        )
+        self.stream.write(message[0] + "\n")
         self.stream.flush()
 
     def LogAsIs(self, message: str, /) -> None:
-        """
-        See documentation of
-        logger_36.catalog.handler.generic.generic_handler_t.LogAsIs.
-        """
+        """"""
         self.stream.write(message + "\n")
         self.stream.flush()
 
-    def DisplayRule(self, /, *, text: str | None = None, color: str = "white") -> None:
+    def DisplayRule(self, /, *, text: str | None = None, color: str = "black") -> None:
         """"""
-        self.LogAsIs(RuleAsText(text))
+        self.LogAsIs(RuleAsText(text, None))
 
 
 """

logger_36/catalog/handler/generic.py

@@ -22,8 +22,7 @@ else:
         EscapedForRich
     ) = DEFAULT_TERMINAL_THEME = None
 
-from logger_36.constant.record import SHOW_W_RULE_ATTR
-from logger_36.task.format.rule import Rule, RuleAsText
+from logger_36.task.format.rule import Rule, RuleAsText, rule_t
 from logger_36.type.handler import handler_t as base_t
 
 LogAsIs_h = h.Callable[[str | h.Any], None]
@@ -54,18 +53,15 @@ class generic_handler_t(base_t):
 
     kind: h.ClassVar[str] = "g"
 
-    @classmethod
-    def New(
-        cls,
-        /,
-        *,
-        name: str | None = None,
-        should_store_memory_usage: bool = False,
-        message_width: int = -1,
-        level: int = l.NOTSET,
-        formatter: l.Formatter | None = None,
-        **kwargs,
-    ) -> h.Self:
+    def __init__(
+        self,
+        name: str | None,
+        should_store_memory_usage: bool,
+        message_width: int,
+        level: int,
+        formatter: l.Formatter | None,
+        kwargs,
+    ) -> None:
         """"""
         alternating_logs = kwargs.pop("alternating_logs", 0)
         LogAsIs = kwargs.pop("LogAsIs", lambda _, indented=False: print(_))
@@ -73,18 +69,24 @@ class generic_handler_t(base_t):
 
         assert alternating_logs in (0, 1, 2)
 
-        output = cls(name, should_store_memory_usage, message_width, level, formatter)
-
-        output.LogAsIs = LogAsIs
-        output.console = None  # console_t | None.
-        output.console_options = None  # console_options_t | None.
-        output.alternating_logs = alternating_logs
-        output.log_parity = False
-        output.DisplayRule = None  # DisplayRule_p | None.
-
-        output.__post_init_local__(supports_html)
-
-        return output
+        base_t.__init__(
+            self,
+            name,
+            should_store_memory_usage,
+            message_width,
+            level,
+            formatter,
+            kwargs,
+        )
+
+        self.LogAsIs = LogAsIs
+        self.DisplayRule = None  # DisplayRule_p | None.
+        self.console = None  # console_t | None.
+        self.console_options = None  # console_options_t | None.
+        self.alternating_logs = alternating_logs
+        self._log_parity = False
+
+        self.__post_init_local__(supports_html)
 
     def __post_init_local__(self, supports_html: bool) -> None:
         """"""
@@ -97,28 +99,46 @@ class generic_handler_t(base_t):
         else:
             self.DisplayRule = self._DisplayRuleAsText
 
+    @classmethod
+    def New(
+        cls,
+        /,
+        *,
+        name: str | None = None,
+        should_store_memory_usage: bool = False,
+        message_width: int = -1,
+        level: int = l.NOTSET,
+        formatter: l.Formatter | None = None,
+        **kwargs,
+    ) -> h.Self:
+        """"""
+        return cls(
+            name, should_store_memory_usage, message_width, level, formatter, kwargs
+        )
+
     def emit(self, record: l.LogRecord, /) -> None:
         """"""
         if self.console is None:
-            if hasattr(record, SHOW_W_RULE_ATTR):
-                message = RuleAsText(record.msg)
-            else:
-                message = self.MessageFromRecord(record, line_width=self.message_width)
+            message = self.MessageFromRecord(
+                record, RuleAsText, line_width=self.message_width
+            )[0]
         else:
-            if hasattr(record, SHOW_W_RULE_ATTR):
-                richer = Rule(record.msg, DATE_TIME_COLOR)
-            else:
-                message = self.MessageFromRecord(
-                    record, line_width=self.message_width, PreProcessed=EscapedForRich
-                )
-                richer = HighlightedVersion(
+            message, is_not_a_rule = self.MessageFromRecord(
+                record,
+                Rule,
+                line_width=self.message_width,
+                color=DATE_TIME_COLOR,
+                PreProcessed=EscapedForRich,
+            )
+            if is_not_a_rule:
+                message = HighlightedVersion(
                     self.console,
                     message,
                     record.levelno,
                     self.alternating_logs,
-                    self.log_parity,
+                    self._log_parity,
                 )
-            segments = self.console.render(richer, options=self.console_options)
+            segments = self.console.render(message, options=self.console_options)
 
             # Inspired from the code of: rich.console.export_html.
             html_segments = []
@@ -143,13 +163,13 @@ class generic_handler_t(base_t):
             )
 
         self.LogAsIs(message)
-        self.log_parity = not self.log_parity
+        self._log_parity = not self._log_parity
 
     def _DisplayRuleAsText(
         self, /, *, text: str | None = None, color: str = "white"
     ) -> None:
         """"""
-        self.LogAsIs(RuleAsText(text))
+        self.LogAsIs(RuleAsText(text, None))
 
     def _DisplayRule(self, /, *, text: str | None = None, color: str = "white") -> None:
         """"""

logger_36/config/message.py

@@ -11,6 +11,7 @@ LEVEL_CLOSING = ")"
 MESSAGE_MARKER = "|"
 WHERE_SEPARATOR = "@"
 ELAPSED_TIME_SEPARATOR = "+"
+FALLBACK_MESSAGE_WIDTH = 5
 
 DATE_FORMAT = "%Y-%m-%d"
 TIME_FORMAT = "%H:%M:%S"

logger_36/constant/html.py

@@ -0,0 +1,70 @@
+"""
+Copyright CNRS/Inria/UniCA
+Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2023
+SEE COPYRIGHT NOTICE BELOW
+"""
+
+TITLE_PLACEHOLDER = "TITLE"
+BODY_PLACEHOLDER = "BODY"
+
+MINIMAL_HTML = f"""
+    <!DOCTYPE html>
+    <html lang="en">
+        <head>
+            <meta charset="utf-8">
+            <title>{TITLE_PLACEHOLDER}</title>
+        </head>
+        <body>
+            <pre>
+{BODY_PLACEHOLDER}
+            </pre>
+        </body>
+    </html>
+"""
+
+
+"""
+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.
+
+This software is being developed by Eric Debreuve, a CNRS employee and
+member of team Morpheme.
+Team Morpheme is a joint team between Inria, CNRS, and UniCA.
+It is hosted by the Centre Inria d'Université Côte d'Azur, Laboratory
+I3S, and Laboratory iBV.
+
+CNRS: https://www.cnrs.fr/index.php/en
+Inria: https://www.inria.fr/en/
+UniCA: https://univ-cotedazur.eu/
+Centre Inria d'Université Côte d'Azur: https://www.inria.fr/en/centre/sophia/
+I3S: https://www.i3s.unice.fr/en/
+iBV: http://ibv.unice.fr/
+Team Morpheme: https://team.inria.fr/morpheme/
+"""

logger_36/task/format/message.py

@@ -5,10 +5,69 @@ 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 expected_op_h
+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
 
 
 def MessageWithActualExpected(

logger_36/task/format/rule.py

@@ -7,7 +7,7 @@ SEE COPYRIGHT NOTICE BELOW
 from logger_36.catalog.config.optional import RICH_IS_AVAILABLE
 
 
-def RuleAsText(text: str | None, /) -> str:
+def RuleAsText(text: str | None, _: None, /) -> str:
     """"""
     if text is None:
         return "---- ---- ---- ---- ---- ---- ---- ---- ----"
@@ -27,7 +27,8 @@ if RICH_IS_AVAILABLE:
             return rule_t(title=text_t(text, style=f"bold {color}"), style=color)
 
 else:
-    Rule = lambda _, __: RuleAsText(_)
+    rule_t = text_t = None
+    Rule = lambda _, __: RuleAsText(_, None)
 
 """
 COPYRIGHT NOTICE

logger_36/task/storage.py

@@ -8,6 +8,7 @@ import logging as l
 from io import IOBase as io_base_t
 from pathlib import Path as path_t
 
+from logger_36.constant.html import BODY_PLACEHOLDER, MINIMAL_HTML, TITLE_PLACEHOLDER
 from logger_36.instance.logger import L
 
 
@@ -35,19 +36,39 @@ def SaveLOGasHTML(path: str | path_t | io_base_t | None = None) -> None:
         path = path_t(path)
 
     actual_file = isinstance(path, path_t)
+
     if actual_file and path.exists():
         L.warning(f'{cannot_save}: File "{path}" already exists.')
         return
 
-    html = "\n".join(L.recorded)
-    if html is None:
-        L.warning(f"{cannot_save}: No handler could provide an HTML output.")
+    body = "\n".join(map(_HighlightedEvent, L.recorded))
+    html = MINIMAL_HTML.replace(TITLE_PLACEHOLDER, L.name).replace(
+        BODY_PLACEHOLDER, body
+    )
+    if actual_file:
+        with open(path, "w") as accessor:
+            accessor.write(html)
     else:
-        if actual_file:
-            with open(path, "w") as accessor:
-                accessor.write(html)
-        else:
-            path.write(html)
+        path.write(html)
+
+
+def _HighlightedEvent(event: tuple[int, str], /) -> str:
+    """"""
+    level, message = event
+    if level == l.DEBUG:
+        color = "BlueViolet"
+    elif level == l.INFO:
+        color = "black"
+    elif level == l.WARNING:
+        color = "gold"
+    elif level == l.ERROR:
+        color = "orange"
+    elif level == l.CRITICAL:
+        color = "red"
+    else:
+        color = "black"
+
+    return f'<span style="color:{color}">{message}</span>'
 
 
 """

logger_36/type/handler.py

@@ -9,12 +9,13 @@ 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.constant.error import MEMORY_MEASURE_ERROR
 from logger_36.constant.handler import HANDLER_KINDS
-from logger_36.task.format.message import MessageWithActualExpected
+from logger_36.task.format.message import MessageFromRecord, MessageWithActualExpected
 from logger_36.task.measure.chronos import TimeStamp
 from logger_36.task.measure.memory import CanCheckUsage as CanCheckMemoryUsage
-from logger_36.type.message import MessageFromRecord, MessageFromRecord_h
+from logger_36.type.message import MessageFromRecord_h, RuleWithText_h
 
 _MEMORY_MEASURE_ERROR = MEMORY_MEASURE_ERROR
 
@@ -56,8 +57,8 @@ class _base_t:
                 s.__stderr__.write(_MEMORY_MEASURE_ERROR + "\n")
                 _MEMORY_MEASURE_ERROR = None
 
-        if 0 < self.message_width < 5:
-            self.message_width = 5
+        if 0 < self.message_width < FALLBACK_MESSAGE_WIDTH:
+            self.message_width = FALLBACK_MESSAGE_WIDTH
 
     @classmethod
     def New(cls, **kwargs) -> h.Self:
@@ -66,6 +67,17 @@ class _base_t:
         """
         raise NotImplementedError
 
+    def LogAsIs(self, message: str, /) -> None:
+        """
+        See documentation of
+        logger_36.catalog.handler.generic.generic_handler_t.LogAsIs.
+        """
+        raise NotImplementedError
+
+    def DisplayRule(self, /, *, text: str | None = None, color: str = "black") -> None:
+        """"""
+        raise NotImplementedError
+
 
 class handler_t(l.Handler, _base_t):
     def __init__(
@@ -75,11 +87,12 @@ class handler_t(l.Handler, _base_t):
         message_width: int,
         level: int,
         formatter: l.Formatter | None,
+        *_,
     ) -> None:
         """"""
         l.Handler.__init__(self)
         _base_t.__init__(self, name, should_store_memory_usage, message_width)
-        _HandlerPostInit(self, level, formatter)
+        __post_init__(self, level, formatter)
 
 
 class file_handler_t(l.FileHandler, _base_t):
@@ -91,6 +104,7 @@ class file_handler_t(l.FileHandler, _base_t):
         level: int,
         formatter: l.Formatter | None,
         path: str | path_t | None,
+        *_,
     ) -> None:
         """"""
         if path is None:
@@ -102,13 +116,13 @@ class file_handler_t(l.FileHandler, _base_t):
 
         l.FileHandler.__init__(self, path)
         _base_t.__init__(self, name, should_store_memory_usage, message_width)
-        _HandlerPostInit(self, level, formatter)
+        __post_init__(self, level, formatter)
 
 
 any_handler_t = handler_t | file_handler_t
 
 
-def _HandlerPostInit(
+def __post_init__(
     handler: any_handler_t, level: int, formatter: l.Formatter | None
 ) -> None:
     """"""
@@ -122,13 +136,14 @@ def _HandlerPostInit(
 
         def _MessageFromRecord(
             record: l.LogRecord,
+            _: RuleWithText_h,
             /,
             *,
             line_width: int = 0,
             PreProcessed: h.Callable[[str], str] | None = None,
-        ) -> str:
+        ) -> tuple[str, bool]:
             #
-            return _MessageFromRecordRaw(record)
+            return _MessageFromRecordRaw(record), False
 
         handler.MessageFromRecord = _MessageFromRecord
 

logger_36/type/logger.py

@@ -44,13 +44,12 @@ from logger_36.constant.record import (
     STORE_MEMORY_ATTR,
 )
 from logger_36.extension.exception import OverrideExceptionFormat
-from logger_36.task.format.message import MessageWithActualExpected
+from logger_36.task.format.message import MessageFromRecord, MessageWithActualExpected
 from logger_36.task.format.rule import RuleAsText
 from logger_36.task.measure.chronos import ElapsedTime
 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.issue import NewIssue, issue_t
-from logger_36.type.message import MessageFromRecord
 
 if RICH_IS_AVAILABLE:
     from logger_36.catalog.handler.console_rich import console_rich_handler_t
@@ -75,23 +74,23 @@ class logger_t(base_t):
     intercepted_wrn_handle: When warning interception is on, this stores the original
         "handle" method of the Python warning logger.
 
-    should_activate_log_interceptions: Loggers instantiated after a logger_t logger will
+    _should_activate_log_interceptions: Loggers instantiated after a logger_t logger will
     be missed by an early call of ToggleLogInterceptions. Therefore, passing True for
-    activate_log_interceptions only sets should_activate_log_interceptions to True,
+    activate_log_interceptions only sets _should_activate_log_interceptions to True,
     which is later checked in AddHandler to effectively call ToggleLogInterceptions if
-    should_hold_messages is False (which normally indicates that the handler about to be
+    _should_hold_messages is False (which normally indicates that the handler about to be
     added is the last one).
+
+    _should_hold_messages: Must not be False until at least one handler has been added.
     """
 
-    # Must not be False until at least one handler has been added.
-    should_hold_messages: bool = True
     should_record_messages: bool = False
     exit_on_error: bool = False  # Implies exit_on_critical.
     exit_on_critical: bool = False
 
-    on_hold: list[l.LogRecord] = d.field(init=False, default_factory=list)
-    recorded: list[str] = d.field(init=False, default_factory=list)
     events: dict[int, int] = d.field(init=False, default_factory=dict)
+    recorded: list[tuple[int, str]] = d.field(init=False, default_factory=list)
+
     last_message_now: date_time_t = d.field(init=False, default=_DATE_TIME_ORIGIN)
     last_message_date: date_t = d.field(init=False, default=_DATE_ORIGIN)
     any_handler_stores_memory: bool = d.field(init=False, default=False)
@@ -102,7 +101,9 @@ class logger_t(base_t):
     intercepted_log_handles: dict[str, logger_handle_h] = d.field(
         init=False, default_factory=dict
     )
-    should_activate_log_interceptions: bool = 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)
 
     name_: d.InitVar[str] = LOGGER_NAME
     level_: d.InitVar[int] = l.NOTSET
@@ -167,7 +168,7 @@ class logger_t(base_t):
         if activate_wrn_interceptions:
             self.ToggleWarningInterceptions(True)
         if activate_log_interceptions:
-            self.should_activate_log_interceptions = True
+            self._should_activate_log_interceptions = True
 
         if self.exit_on_error:
             self.exit_on_critical = True
@@ -176,12 +177,14 @@ 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._on_hold.__len__() > 0) and not self._should_hold_messages:
+            for held in self._on_hold:
                 if self.should_record_messages:
-                    self.recorded.append(MessageFromRecord(held))
+                    self.recorded.append(
+                        (held.levelno, MessageFromRecord(held, RuleAsText)[0])
+                    )
                 base_t.handle(self, held)
-            self.on_hold.clear()
+            self._on_hold.clear()
 
         if (date := now.date()) != self.last_message_date:
             self.last_message_date = date
@@ -194,11 +197,16 @@ class logger_t(base_t):
                     SHOW_W_RULE_ATTR: True,
                 }
             )
-            if self.should_hold_messages:
-                self.on_hold.append(date_record)
+            if self._should_hold_messages:
+                self._on_hold.append(date_record)
             else:
                 if self.should_record_messages:
-                    self.recorded.append(MessageFromRecord(date_record))
+                    self.recorded.append(
+                        (
+                            date_record.levelno,
+                            MessageFromRecord(date_record, RuleAsText)[0],
+                        )
+                    )
                 base_t.handle(self, date_record)
 
         # When.
@@ -238,11 +246,13 @@ class logger_t(base_t):
         if not isinstance(record.msg, str):
             record.msg = str(record.msg)
 
-        if self.should_hold_messages:
-            self.on_hold.append(record)
+        if self._should_hold_messages:
+            self._on_hold.append(record)
         else:
             if self.should_record_messages:
-                self.recorded.append(MessageFromRecord(record))
+                self.recorded.append(
+                    (record.levelno, MessageFromRecord(record, RuleAsText)[0])
+                )
             base_t.handle(self, record)
 
         if (self.exit_on_critical and (record.levelno is l.CRITICAL)) or (
@@ -381,11 +391,11 @@ class logger_t(base_t):
         **kwargs,
     ) -> None:
         """"""
-        if (not should_still_hold_messages) and self.should_activate_log_interceptions:
+        if (not should_still_hold_messages) and self._should_activate_log_interceptions:
             self.ToggleLogInterceptions(True)
-            self.should_activate_log_interceptions = False
+            self._should_activate_log_interceptions = False
 
-        self.should_hold_messages = should_still_hold_messages
+        self._should_hold_messages = should_still_hold_messages
         handler = handler_t.New(
             name=name,
             should_store_memory_usage=should_store_memory_usage,
@@ -415,6 +425,13 @@ class logger_t(base_t):
             f"level {handler.level}={l.getLevelName(handler.level)}{path}"
         )
 
+    def __call__(self, *args, **kwargs) -> None:
+        """
+        For a print-like calling.
+        """
+        separator = kwargs.get("separator", " ")
+        self.info(separator.join(map(str, args)))
+
     def Log(
         self,
         message: str,
@@ -463,10 +480,7 @@ class logger_t(base_t):
         self.log(level, message)
 
     def LogAsIs(self, message: str, /, *, indented: bool = False) -> None:
-        """
-        See documentation of
-        logger_36.catalog.handler.generic.generic_handler_t.LogAsIs.
-        """
+        """"""
         if indented:
             message = text.indent(message, LINE_INDENT)
 
@@ -476,7 +490,7 @@ class logger_t(base_t):
             else:
                 LogAsIs(message)
 
-    raw_info = LogAsIs  # To follow the convention of the logging methods info, error...
+    info_raw = LogAsIs  # To follow the convention of the logging methods info, error...
 
     def DisplayRule(
         self, /, *, message: str | None = None, color: str = "white"
@@ -484,7 +498,7 @@ class logger_t(base_t):
         """"""
         for handler in self.handlers:
             if (DisplayRule := getattr(handler, "DisplayRule", None)) is None:
-                self.info(RuleAsText(message))
+                self.info(RuleAsText(message, None))
             else:
                 DisplayRule(text=message, color=color)
 

logger_36/type/message.py

@@ -7,14 +7,24 @@ SEE COPYRIGHT NOTICE BELOW
 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.message import NEXT_LINE_PROLOGUE
-from logger_36.extension.line import WrappedLines
+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
@@ -22,58 +32,17 @@ 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,
-    ) -> str: ...
+    ) -> tuple[str, bool]: ...
 
 
 MessageFromRecord_h = _MessageFromRecordPreprocessed_p
 
 
-def MessageFromRecord(
-    record: l.LogRecord,
-    /,
-    *,
-    line_width: int = 0,
-    PreProcessed: h.Callable[[str], str] | None = None,
-) -> str:
-    """
-    See logger_36.catalog.handler.README.txt.
-    """
-    message = record.msg
-
-    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
-
-    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}"
-    )
-
-
 """
 COPYRIGHT NOTICE
 

logger_36/version.py

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

{logger_36-2025.13.dist-info → logger_36-2025.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: logger-36
-Version: 2025.13
+Version: 2025.14
 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.13.dist-info → logger_36-2025.14.dist-info}/RECORD

@@ -1,5 +1,5 @@
 logger_36/__init__.py,sha256=UhKxuQLS1Pfgt5H0K_7BaDAPejOUR8byD5BYRCnHQMQ,2655
-logger_36/version.py,sha256=8Q08zB-7T6p-P0RQlBl_Y5-Y1kdpyPxTtxJ5OyfjwMU,2206
+logger_36/version.py,sha256=puslblEld2sLwTmqWreV3vMyhNnL0uc4l3B-pcUa2hg,2206
 logger_36/api/content.py,sha256=clHYYUKa8n4qef6PVlUV4mFHRRf6fnm9wEd2fu9oagA,2381
 logger_36/api/exception.py,sha256=QKIkNJA0N6FvVHLTApiH3ymhVQoSYU08t2RkyufQPIw,2291
 logger_36/api/gpu.py,sha256=BOumedCAPWvCo7J-KJ3XE-jr5S0KSmgcFv_S4QKRPO8,2252
@@ -10,21 +10,22 @@ logger_36/api/time.py,sha256=Uw1jQtY1njsRuIPRAXX44v4nPOo84MSBu_WK_YCRzQs,2324
 logger_36/api/type.py,sha256=4m5fZGI6LOQvFakEStFv6HTP4FY9nyFpNNlK34rCfQw,2286
 logger_36/catalog/config/console_rich.py,sha256=lAa5Ev5BhXvmQzfIt1FNihMNUQJFlXaIzNanAMdgtd0,2861
 logger_36/catalog/config/optional.py,sha256=HaN6mbx7gHBBppNvUw1ckhYTOrlYqb-b_r0mzPcHPjM,2398
-logger_36/catalog/handler/console.py,sha256=2scmBhoZdTVEiepgnfcgrLwhm11mjIQuVYPmQqDKKvk,3516
-logger_36/catalog/handler/console_rich.py,sha256=7F7qyztTMuQt5zy9ml3BZFFdi3WoGbJ_S9E58TKsLF8,6903
-logger_36/catalog/handler/file.py,sha256=FjnkppbFgsieULfoWD1tRD5jIoC1qZLKE3gtSdNYseE,3661
-logger_36/catalog/handler/generic.py,sha256=AaGnnfiuKgzsTyMTtY7UYkzthXQ20Vyv_cnaMAPXefo,7946
+logger_36/catalog/handler/console.py,sha256=5F_JFsGm5ERFh0_1rh8Jae51VwAJMg7d7bRLZkOK4DY,3283
+logger_36/catalog/handler/console_rich.py,sha256=U4hD8qF88dpDALKkeOvwnrJpUbUpG5egq1JfImU4pFg,7168
+logger_36/catalog/handler/file.py,sha256=4Du9f-UNJsZrcNV9jCVLLCklA0T4HYX_jKjxSie-deM,3428
+logger_36/catalog/handler/generic.py,sha256=8xQA0ETIMmdhmip0wcaD21h4ZGz-52gk0hgoUJYxbn8,8258
 logger_36/catalog/logger/chronos.py,sha256=ocY13f98EfknU7wZCv0FS9Xb7pTNaWCPSusXFIEvEd4,2437
 logger_36/catalog/logger/gpu.py,sha256=ybn7Q8exiqoigvNpzEhg0Zp027WogypuNJwfsQ1pRY4,3416
 logger_36/catalog/logger/memory.py,sha256=CWhr2J4BqArJxzH6tS-ZThr-rYPAQGtuLn0pP7Iryfg,4685
 logger_36/catalog/logger/system.py,sha256=3VWbceSAknZwmRhEfd8pkuLwU2B8zPhCGNGQE0h5KLo,3065
 logger_36/config/issue.py,sha256=G-i5p6lhZCLAOa-VTMyL9ZonvGCvhdoQ5KZdSWgP-FU,2267
 logger_36/config/memory.py,sha256=yCX5phsB_KJMr5xHpVUeOHFhAA7p_8yahP3X28VndOY,2217
-logger_36/config/message.py,sha256=yfbMO_Jk1IbWvT6Lp6hVpID2Tr99cuiJ-ZaMBesIFXw,2527
+logger_36/config/message.py,sha256=mgPcMS7qWBuqP2w5NoHw1df32kcVToVhisozb32_EII,2554
 logger_36/config/system.py,sha256=HD8ZuwsXhEAExeZrww8YoDkQGMs4T5RDqQMb1W4qVgc,2477
 logger_36/constant/error.py,sha256=LzsS_P1IoH3ct_ifNWi9LzJ-X_Y5DN1naTLwwIFzDQA,2827
 logger_36/constant/generic.py,sha256=t6aRb66_NHwMhR1p7BZ4QXTU2jpLz-H5YAL4PuMtKx8,2244
 logger_36/constant/handler.py,sha256=PQUehMK9Yg0_rBDcMc8xpUbAsCauCLy_eS_ntiWew1Y,2378
+logger_36/constant/html.py,sha256=-m1CDyDN0kkurloEtJeqBsyxy9nXCImIMGLwEIF33M0,2515
 logger_36/constant/issue.py,sha256=01l8itRPWGS5F6gXtsXUJgGR-4lS1Eu3_YeKC-khKLw,2315
 logger_36/constant/logger.py,sha256=2qRkteblpbHrq9x0aiw9MPquyXrSRd6_yMQnPEhFp2U,2468
 logger_36/constant/memory.py,sha256=ZL1MwbdtNsrCrOwzEyfTsfOoOsRBTJtbbf3otHGnxXo,2343
@@ -38,18 +39,18 @@ logger_36/extension/line.py,sha256=3MJ3B5PXJn18RHxBUcWnNBLEYzb7VTcEAufn7ULdYfY,3
 logger_36/instance/logger.py,sha256=oTw5svRzKRJKvGrrZUtutJIOjp5UISft3fl0Ze7DOBE,2241
 logger_36/instance/loggers.py,sha256=RCWpC1NPAf6vXnFc9NqsSALv-x-FEzcH6k_OlxTxeQk,2251
 logger_36/task/inspection.py,sha256=VR9ESSa2iAAiQggwzHzV2A3-rRr6VgMqR1HvclhK2Xc,5010
-logger_36/task/storage.py,sha256=mBUzUw884tSPcWLjlNPjDmwxJ6QXV2tnrfjKDZLQwJg,3504
+logger_36/task/storage.py,sha256=Y88934cVcen1i8qruskmCMQYA5-dl1wI8EaJFCv49Q0,4042
 logger_36/task/format/memory.py,sha256=ZipL1f-Bqv4ugFvXZfNrj49rdIMXjEKcVz1OvgMaZXI,4249
-logger_36/task/format/message.py,sha256=siQ3crsaw0846-lEKEC1bc29Exmxw7qMBdBF91fncpc,4028
-logger_36/task/format/rule.py,sha256=1cm1d1h9fEv15A-tYVwXy5XzKmkFnXF5kKXFBdNCmNc,2868
+logger_36/task/format/message.py,sha256=5mR9CZaARy9q-JtIX68IyY-DKTepkxyRV7juByqBH7c,5771
+logger_36/task/format/rule.py,sha256=CtR7d2X-pZFKdqG6Y2_3b5AMKg_J274Jq69kht0N6xs,2910
 logger_36/task/measure/chronos.py,sha256=1kVhu6jZlNAtNWQQh8ZVuRwZIAC9gGz3_ul1tn0t4Yw,3055
 logger_36/task/measure/memory.py,sha256=OjU5EYFH8SnzlCQKAoiXvauUlwQYOrH34jFXTVYF0jE,2517
-logger_36/type/handler.py,sha256=saGN7S1XgADzbgwbuycJwjdaar-bRgsfW5gMM2JA2PA,6040
+logger_36/type/handler.py,sha256=6oxW-Y_kuAEfoXsMr-KXspv0czYiwe8rDzMAMrshFmw,6567
 logger_36/type/issue.py,sha256=2rGsFqaQJCbeml9xN08mN_nK79L8qscaS_0ws36Y0bI,3214
-logger_36/type/logger.py,sha256=mflRwDwvo1sZhAwJJ5DhSvM-Oqij3DUmE0B7mXQRYkE,24789
+logger_36/type/logger.py,sha256=ISMUQBZ-KhLBi_tZjCAYtss5pAwFW3psTQu5k9_ZbEw,25287
 logger_36/type/loggers.py,sha256=znqxWBnfQxvkg3VUfbTUvt3S6Kq0DAzWWepxQDt9suI,2871
-logger_36/type/message.py,sha256=1TA41C-jk-zlfVwv66am6BDvhHKD_4VJoafc2nXEgE8,3969
-logger_36-2025.13.dist-info/METADATA,sha256=7FsKH9oTSxEdfppbTtwRuwqAm9RGAl8dqqcHEA5Auag,6506
-logger_36-2025.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-logger_36-2025.13.dist-info/top_level.txt,sha256=sM95BTMWmslEEgR_1pzwZsOeSp8C_QBiu8ImbFr0XLc,10
-logger_36-2025.13.dist-info/RECORD,,
+logger_36/type/message.py,sha256=zKME5p87ynsXte_b5usXV3VHaj34Uezs9Gg_WVWfaeY,3063
+logger_36-2025.14.dist-info/METADATA,sha256=GkEE-L8P0ShhL0XxKOu-A5p3yZD0mJzAcGax90FiUw8,6506
+logger_36-2025.14.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+logger_36-2025.14.dist-info/top_level.txt,sha256=sM95BTMWmslEEgR_1pzwZsOeSp8C_QBiu8ImbFr0XLc,10
+logger_36-2025.14.dist-info/RECORD,,