logger-36 2025.13__tar.gz → 2025.15__tar.gz

{logger_36-2025.13 → logger_36-2025.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: logger-36
-Version: 2025.13
+Version: 2025.15
 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 → logger_36-2025.15}/package/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,17 @@ 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")
-
-    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:
-        """"""
-        self.LogAsIs(RuleAsText(text))
+        message = self.MessageFromRecord(
+            record, RuleAsText, line_width=self.message_width
+        )
+        s.__stdout__.write(message[0] + "\n")
 
 
 """

{logger_36-2025.13 → logger_36-2025.15}/package/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-2025.13 → logger_36-2025.15}/package/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,25 +35,17 @@ 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:
-        """"""
-        self.LogAsIs(RuleAsText(text))
-
 
 """
 COPYRIGHT NOTICE

{logger_36-2025.13 → logger_36-2025.15}/package/logger_36/catalog/handler/generic.py

@@ -22,7 +22,6 @@ 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.type.handler import handler_t as base_t
 
@@ -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-2025.13 → logger_36-2025.15}/package/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-2025.15/package/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-2025.13 → logger_36-2025.15}/package/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-2025.13 → logger_36-2025.15}/package/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-2025.13 → logger_36-2025.15}/package/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>'
 
 
 """