logger-36 2025.12__tar.gz → 2025.14__tar.gz

{logger_36-2025.12 → logger_36-2025.14}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: logger-36
-Version: 2025.12
+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.14/package/logger_36/catalog/handler/console.py

@@ -0,0 +1,93 @@
+"""
+Copyright CNRS/Inria/UniCA
+Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2023
+SEE COPYRIGHT NOTICE BELOW
+"""
+
+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
+
+
+class console_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,
+        **_,
+    ) -> h.Self:
+        """"""
+        return cls(name, should_store_memory_usage, message_width, level, formatter)
+
+    def emit(self, record: l.LogRecord, /) -> None:
+        """"""
+        message = self.MessageFromRecord(
+            record, RuleAsText, line_width=self.message_width
+        )
+        s.__stdout__.write(message[0] + "\n")
+
+    def LogAsIs(self, message: str, /) -> None:
+        """"""
+        s.__stdout__.write(message + "\n")
+
+    def DisplayRule(self, /, *, text: str | None = None, color: str = "black") -> None:
+        """"""
+        self.LogAsIs(RuleAsText(text, None))
+
+
+"""
+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.12 → logger_36-2025.14}/package/logger_36/catalog/handler/console_rich.py

@@ -4,10 +4,15 @@ Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2023
 SEE COPYRIGHT NOTICE BELOW
 """
 
-import dataclasses as d
 import logging as l
 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.text import Text as text_t  # noqa
+from rich.traceback import install as InstallTracebackHandler  # noqa
+
 from logger_36.catalog.config.console_rich import (
     ACTUAL_COLOR,
     ALTERNATIVE_BACKGROUND_FOR_DARK,
@@ -20,14 +25,8 @@ 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 MessageFromRecordPreprocessed_p, handler_extension_t
-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.text import Text as text_t  # noqa
-from rich.traceback import install as InstallTracebackHandler  # noqa
+from logger_36.type.handler import handler_t as base_t
 
 _COMMON_TRACEBACK_ARGUMENTS = ("theme", "width")
 _EXCLUSIVE_TRACEBACK_ARGUMENTS = (
@@ -37,17 +36,14 @@ _EXCLUSIVE_TRACEBACK_ARGUMENTS = (
     "locals_hide_sunder",
     "locals_max_length",
     "locals_max_string",
-    "max_frames" "show_locals",
+    "max_framesshow_locals",
     "suppress",
     "word_wrap",
 )
 
 
-@d.dataclass(slots=True, repr=False, eq=False)
-class console_rich_handler_t(l.Handler):
+class console_rich_handler_t(base_t):
     """
-    kind: See logger_36.constant.handler.handler_codes_h.
-
     alternating_logs:
     - 0: disabled
     - 1: enabled for dark background
@@ -56,105 +52,95 @@ class console_rich_handler_t(l.Handler):
 
     kind: h.ClassVar[str] = "c"
 
-    alternating_logs: int = 0
-
-    name: d.InitVar[str | None] = None
-    level: d.InitVar[int] = l.NOTSET
-    should_store_memory_usage: d.InitVar[bool] = False
-    message_width: d.InitVar[int] = -1
-    formatter: d.InitVar[l.Formatter | None] = None
-    #
-    should_install_traceback: d.InitVar[bool] = False
-    should_record: d.InitVar[bool] = False
-    rich_kwargs: d.InitVar[dict[str, h.Any] | None] = None
-
-    extension: handler_extension_t = d.field(init=False)
-    console: console_t = d.field(init=False)
-    MessageFromRecord: MessageFromRecordPreprocessed_p = d.field(init=False)
-    log_parity: bool = d.field(init=False, default=False)
-
-    @property
-    def past_logs_as_HTML(self) -> str | None:
-        """"""
-        console = self.console
-        if console.record:
-            return console.export_html()
-
-        return None
-
-    def __post_init__(
+    def __init__(
         self,
         name: str | None,
-        level: int,
         should_store_memory_usage: bool,
         message_width: int,
+        level: int,
         formatter: l.Formatter | None,
-        should_install_traceback: bool,
-        should_record: bool,
-        rich_kwargs: dict[str, h.Any] | None,
+        kwargs,
     ) -> None:
         """"""
-        l.Handler.__init__(self)
-
-        self.extension = handler_extension_t(
-            name=name,
-            should_store_memory_usage=should_store_memory_usage,
-            handler=self,
-            level=level,
-            message_width=message_width,
-            formatter=formatter,
+        alternating_logs = kwargs.pop("alternating_logs", 0)
+        should_install_traceback = kwargs.pop("should_install_traceback", False)
+
+        assert alternating_logs in (0, 1, 2)
+
+        base_t.__init__(
+            self,
+            name,
+            should_store_memory_usage,
+            message_width,
+            level,
+            formatter,
+            kwargs,
         )
 
-        if rich_kwargs is None:
-            rich_console_kwargs = {}
-        else:
-            rich_console_kwargs = rich_kwargs
-        rich_traceback_kwargs = {}
+        self.console = None  # console_t | None.
+        self.alternating_logs = alternating_logs
+        self._log_parity = False
+
+        self.__post_init_local__(should_install_traceback, **kwargs)
+
+    def __post_init_local__(self, should_install_traceback: bool, **kwargs) -> None:
+        """"""
+        traceback_kwargs = {}
         if should_install_traceback:
-            for key in rich_console_kwargs:
+            for key in kwargs:
                 if key in _COMMON_TRACEBACK_ARGUMENTS:
-                    rich_traceback_kwargs[key] = rich_console_kwargs[key]
+                    traceback_kwargs[key] = kwargs[key]
                 elif key in _EXCLUSIVE_TRACEBACK_ARGUMENTS:
-                    rich_traceback_kwargs[key] = rich_console_kwargs[key]
-                    del rich_console_kwargs[key]
-
-        self.console = console_t(
-            highlight=False,
-            force_terminal=True,
-            record=should_record,
-            **rich_console_kwargs,
-        )
-        if should_install_traceback:
-            rich_traceback_kwargs["console"] = self.console
-            InstallTracebackHandler(**rich_traceback_kwargs)
+                    traceback_kwargs[key] = kwargs.pop(key)
 
-        self.MessageFromRecord = self.extension.MessageFromRecord
-        assert self.alternating_logs in (0, 1, 2)
+        self.console = console_t(highlight=False, force_terminal=True, **kwargs)
+
+        if should_install_traceback:
+            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, 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.14/package/logger_36/catalog/handler/file.py

@@ -0,0 +1,98 @@
+"""
+Copyright CNRS/Inria/UniCA
+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.task.format.rule import RuleAsText
+from logger_36.type.handler import file_handler_t as base_t
+
+
+class file_handler_t(base_t):
+    kind: h.ClassVar[str] = "f"
+
+    @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,
+        path: str | path_t | None = None,
+        **_,
+    ) -> h.Self:
+        """"""
+        return cls(
+            name, should_store_memory_usage, message_width, level, formatter, path
+        )
+
+    def emit(self, record: l.LogRecord, /) -> None:
+        """"""
+        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:
+        """"""
+        self.stream.write(message + "\n")
+        self.stream.flush()
+
+    def DisplayRule(self, /, *, text: str | None = None, color: str = "black") -> None:
+        """"""
+        self.LogAsIs(RuleAsText(text, None))
+
+
+"""
+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.12 → logger_36-2025.14}/package/logger_36/catalog/handler/generic.py

@@ -4,27 +4,26 @@ Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2023
 SEE COPYRIGHT NOTICE BELOW
 """
 
-import dataclasses as d
 import logging as l
 import typing as h
 
 from logger_36.catalog.config.optional import RICH_IS_AVAILABLE
 
 if RICH_IS_AVAILABLE:
-    from logger_36.catalog.config.console_rich import DATE_TIME_COLOR
-    from logger_36.catalog.handler.console_rich import HighlightedVersion
     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 logger_36.catalog.config.console_rich import DATE_TIME_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
 
-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 MessageFromRecord_h, handler_extension_t
+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]
 
@@ -34,11 +33,8 @@ class DisplayRule_p(h.Protocol):
     def __call__(self, /, *, text: str | None = None, color: str = "white") -> None: ...
 
 
-@d.dataclass(slots=True, repr=False, eq=False)
-class generic_handler_t(l.Handler):
+class generic_handler_t(base_t):
     """
-    kind: See logger_36.constant.handler.handler_codes_h.
-
     alternating_logs:
     - 0: disabled
     - 1: enabled for dark background
@@ -57,59 +53,45 @@ class generic_handler_t(l.Handler):
 
     kind: h.ClassVar[str] = "g"
 
-    LogAsIs: LogAsIs_h
-    # "None -> h.Any" (twice below) since None | None is invalid.
-    console: console_t | h.Any = None
-    console_options: console_options_t | h.Any = None
-    alternating_logs: int = 0
-
-    DisplayRule: DisplayRule_p = d.field(init=False)
-    extension: handler_extension_t = d.field(init=False)
-    MessageFromRecord: MessageFromRecord_h = d.field(init=False)
-    log_parity: bool = d.field(init=False, default=False)
-
-    name: d.InitVar[str | None] = None
-    level: d.InitVar[int] = l.NOTSET
-    should_store_memory_usage: d.InitVar[bool] = False
-    message_width: d.InitVar[int] = -1
-    formatter: d.InitVar[l.Formatter | None] = None
-    #
-    supports_html: d.InitVar[bool] = False
-    should_record: d.InitVar[bool] = False
-    rich_kwargs: d.InitVar[dict[str, h.Any] | None] = None
-
-    def __post_init__(
+    def __init__(
         self,
         name: str | None,
-        level: int,
         should_store_memory_usage: bool,
         message_width: int,
+        level: int,
         formatter: l.Formatter | None,
-        supports_html: bool,
-        should_record: bool,
-        rich_kwargs: dict[str, h.Any] | None,
+        kwargs,
     ) -> None:
         """"""
-        l.Handler.__init__(self)
-
-        self.extension = handler_extension_t(
-            name=name,
-            should_store_memory_usage=should_store_memory_usage,
-            handler=self,
-            level=level,
-            message_width=message_width,
-            formatter=formatter,
+        alternating_logs = kwargs.pop("alternating_logs", 0)
+        LogAsIs = kwargs.pop("LogAsIs", lambda _, indented=False: print(_))
+        supports_html = kwargs.pop("supports_html", False)
+
+        assert alternating_logs in (0, 1, 2)
+
+        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:
+        """"""
         if supports_html and (console_t is not None):
-            if rich_kwargs is None:
-                rich_kwargs = {}
-            self.console = console_t(
-                highlight=False,
-                force_terminal=True,
-                record=should_record,
-                **rich_kwargs,
-            )
+            self.console = console_t(highlight=False, force_terminal=True)
             self.console_options = self.console.options.update(
                 overflow="ignore", no_wrap=True
             )
@@ -117,29 +99,46 @@ class generic_handler_t(l.Handler):
         else:
             self.DisplayRule = self._DisplayRuleAsText
 
-        self.MessageFromRecord = self.extension.MessageFromRecord
-        assert self.alternating_logs in (0, 1, 2)
+    @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)
+            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, 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 = []
@@ -164,13 +163,13 @@ class generic_handler_t(l.Handler):
             )
 
         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.12 → logger_36-2025.14}/package/logger_36/catalog/logger/gpu.py

@@ -39,7 +39,7 @@ def LogGPURelatedDetails(*, logger: logger_t = L) -> None:
         f"               CuDNN: {system_details['cudnn_version']}\n"
         f"          Tensorflow: {tsfl.version.VERSION}\n"
         f"    Tensorflow Build: {tsfl.sysconfig.get_build_info()}\n"
-        f"            TensorRT: {tsrt.__version__}",
+        f"            TensorRT: {tsrt.__version__}"
     )
 
 

{logger_36-2025.12 → logger_36-2025.14}/package/logger_36/catalog/logger/system.py

@@ -33,7 +33,7 @@ def LogSystemDetails(
         f"SYSTEM DETAILS\n"
         f"{details}\n"
         f"    {'Python Modules':>{MAX_DETAIL_NAME_LENGTH}}:\n"
-        f"{modules}",
+        f"{modules}"
     )
 
 

{logger_36-2025.12 → logger_36-2025.14}/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"