logger-36 2025.18__tar.gz → 2025.20__tar.gz

{logger_36-2025.18 → logger_36-2025.20}/PKG-INFO

@@ -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 → logger_36-2025.20}/package/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-2025.18 → logger_36-2025.20}/package/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-2025.18 → logger_36-2025.20}/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.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-2025.18 → logger_36-2025.20}/package/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-2025.18 → logger_36-2025.20}/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.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-2025.18 → logger_36-2025.20}/package/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-2025.20/package/logger_36/constant/rule.py

@@ -0,0 +1,42 @@
+"""
+Copyright CNRS (https://www.cnrs.fr/index.php/en)
+Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2023
+SEE COPYRIGHT NOTICE BELOW
+"""
+
+RULE_CHARACTER = "-"
+MIN_HALF_RULE_LENGTH = 4
+DEFAULT_RULE_LENGTH = 50
+DEFAULT_RULE = DEFAULT_RULE_LENGTH * RULE_CHARACTER
+
+"""
+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.
+"""

{logger_36-2025.18 → logger_36-2025.20}/package/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-2025.20/package/logger_36/type/handler.py

@@ -0,0 +1,201 @@
+"""
+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 pathlib import Path as path_t
+
+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.PreProcessedMessage = PreProcessedMessage
+
+        self.__post_init__()
+
+    def __post_init__(self) -> None:
+        """"""
+        if self.name is None:
+            self.name = f"{type(self).__name__}:{hex(id(self))[2:]}"
+
+        if 0 < self.message_width < FALLBACK_MESSAGE_WIDTH:
+            self.message_width = FALLBACK_MESSAGE_WIDTH
+
+    @classmethod
+    def New(cls, **kwargs) -> h.Self:
+        """
+        Interest: default arguments, no prescribed argument order, variable argument list.
+        """
+        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:
+        """"""
+        raise NotImplementedError
+
+    def EmitRule(self, /, *, text: str | None = None, color: str = "black") -> None:
+        """"""
+        self.EmitAsIs(self.Rule(text, color=color))
+
+
+class handler_t(l.Handler, extension_t):
+    def __init__(
+        self,
+        name: str | None,
+        message_width: int,
+        PreProcessedMessage: h.Callable[[str], str] | None,
+        level: int,
+        *_,
+    ) -> None:
+        """"""
+        l.Handler.__init__(self)
+        extension_t.__init__(self, name, message_width, PreProcessedMessage)
+        __post_init__(self, level)
+
+
+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,
+        path: str | path_t | None,
+        *_,
+    ) -> None:
+        """"""
+        if path is None:
+            raise ValueError("Missing file or folder.")
+        if isinstance(path, str):
+            path = path_t(path)
+        if path.exists():
+            raise ValueError(f"File or folder already exists: {path}.")
+
+        l.FileHandler.__init__(self, path)
+        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) -> None:
+    """"""
+    handler.setLevel(level)
+
+
+"""
+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.
+"""