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

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

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

@@ -4,61 +4,39 @@ Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2023
 SEE COPYRIGHT NOTICE BELOW
 """
 
-import dataclasses as d
 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 MessageFromRecordRaw_h, handler_extension_t
+from logger_36.type.handler import handler_t as base_t
 
 
-@d.dataclass(slots=True, repr=False, eq=False)
-class console_handler_t(l.Handler):
-    """
-    kind: See logger_36.constant.handler.handler_codes_h.
-    """
-
+class console_handler_t(base_t):
     kind: h.ClassVar[str] = "c"
 
-    extension: handler_extension_t = d.field(init=False)
-    MessageFromRecord: MessageFromRecordRaw_h = d.field(init=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
-
-    def __post_init__(
-        self,
-        name: str | None,
-        level: int,
-        should_store_memory_usage: bool,
-        message_width: int,
-        formatter: l.Formatter | None,
-    ) -> None:
+    @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,
+        **unused,
+    ) -> h.Self:
         """"""
-        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,
-        )
-
-        self.MessageFromRecord = self.extension.MessageFromRecord
+        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)
+            message = self.MessageFromRecord(record, line_width=self.message_width)
         s.__stdout__.write(message + "\n")
 
     def LogAsIs(self, message: str, /) -> None:

{logger_36-2025.12 → logger_36-2025.13}/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,
@@ -22,12 +27,7 @@ from logger_36.config.message import ACTUAL_PATTERNS, EXPECTED_PATTERNS, WHERE_S
 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 +37,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,87 +53,58 @@ 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:
+    @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:
         """"""
-        console = self.console
-        if console.record:
-            return console.export_html()
-
-        return None
-
-    def __post_init__(
-        self,
-        name: str | None,
-        level: int,
-        should_store_memory_usage: bool,
-        message_width: int,
-        formatter: l.Formatter | None,
-        should_install_traceback: bool,
-        should_record: bool,
-        rich_kwargs: dict[str, h.Any] | None,
-    ) -> 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)
+
+        output.console = None  # console_t | None.
+        output.alternating_logs = alternating_logs
+        output.log_parity = False
+
+        output.__post_init_local__(should_install_traceback, **kwargs)
+
+        return output
+
+    def __post_init_local__(self, should_install_traceback: bool, **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,
-        )
-
-        if rich_kwargs is None:
-            rich_console_kwargs = {}
-        else:
-            rich_console_kwargs = rich_kwargs
-        rich_traceback_kwargs = {}
+        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)
 
     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)
+            message = self.MessageFromRecord(
+                record, line_width=self.message_width, PreProcessed=EscapedVersion
+            )
             richer = HighlightedVersion(
                 self.console,
                 message,

{logger_36-2025.12 → logger_36-2025.13}/package/logger_36/catalog/handler/file.py

@@ -4,68 +4,42 @@ 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 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 MessageFromRecordRaw_h, handler_extension_t
+from logger_36.type.handler import file_handler_t as base_t
 
 
-@d.dataclass(slots=True, repr=False, eq=False)
-class file_handler_t(l.FileHandler):
-    """
-    kind: See logger_36.constant.handler.handler_codes_h.
-    """
-
+class file_handler_t(base_t):
     kind: h.ClassVar[str] = "f"
 
-    extension: handler_extension_t = d.field(init=False)
-    MessageFromRecord: MessageFromRecordRaw_h = d.field(init=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
-    #
-    path: d.InitVar[path_t | None] = None
-    handler_args: d.InitVar[tuple[h.Any, ...] | None] = None
-    handler_kwargs: d.InitVar[dict[str, h.Any] | None] = None
-
-    def __post_init__(
-        self,
-        name: str | None,
-        level: int,
-        should_store_memory_usage: bool,
-        message_width: int,
-        formatter: l.Formatter | None,
-        path: path_t | None,
-        handler_args: tuple[h.Any, ...] | None,
-        handler_kwargs: dict[str, h.Any] | None,
-    ) -> None:
+    @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,
+        **unused,
+    ) -> h.Self:
         """"""
-        l.FileHandler.__init__(self, path, *handler_args, **handler_kwargs)
-
-        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,
+        return cls(
+            name, should_store_memory_usage, message_width, level, formatter, path
         )
 
-        self.MessageFromRecord = self.extension.MessageFromRecord
-
     def emit(self, record: l.LogRecord, /) -> None:
         """"""
         if hasattr(record, SHOW_W_RULE_ATTR):
             message = RuleAsText(record.msg)
         else:
-            message = self.MessageFromRecord(record)
+            message = self.MessageFromRecord(record, line_width=self.message_width)
         self.stream.write(message + "\n")
         self.stream.flush()
 

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

@@ -4,19 +4,19 @@ 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
@@ -24,7 +24,7 @@ else:
 
 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.type.handler import handler_t as base_t
 
 LogAsIs_h = h.Callable[[str | h.Any], None]
 
@@ -34,11 +34,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 +54,42 @@ 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__(
-        self,
-        name: str | None,
-        level: int,
-        should_store_memory_usage: bool,
-        message_width: int,
-        formatter: l.Formatter | None,
-        supports_html: bool,
-        should_record: bool,
-        rich_kwargs: dict[str, h.Any] | None,
-    ) -> None:
+    @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:
         """"""
-        l.Handler.__init__(self)
+        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)
 
-        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,
-        )
+        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
+
+    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,21 +97,20 @@ class generic_handler_t(l.Handler):
         else:
             self.DisplayRule = self._DisplayRuleAsText
 
-        self.MessageFromRecord = self.extension.MessageFromRecord
-        assert self.alternating_logs in (0, 1, 2)
-
     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, line_width=self.message_width)
         else:
             if hasattr(record, SHOW_W_RULE_ATTR):
                 richer = Rule(record.msg, DATE_TIME_COLOR)
             else:
-                message = self.MessageFromRecord(record, PreProcessed=EscapedForRich)
+                message = self.MessageFromRecord(
+                    record, line_width=self.message_width, PreProcessed=EscapedForRich
+                )
                 richer = HighlightedVersion(
                     self.console,
                     message,

{logger_36-2025.12 → logger_36-2025.13}/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.13}/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.13}/package/logger_36/extension/exception.py

@@ -79,7 +79,9 @@ def _HandleException(
             variables = map(
                 lambda _: f"{_:{longest}} = {all_variables[_]}", sorted(found_names)
             )
-            variables = 2 * _INDENTATION + f"\n{2*_INDENTATION}".join(variables) + "\n"
+            variables = (
+                2 * _INDENTATION + f"\n{2 * _INDENTATION}".join(variables) + "\n"
+            )
         else:
             variables = ""
 
@@ -103,7 +105,7 @@ def _HandleException(
         f"{variables}"
         f"{message}"
         f"{_INDENTATION}{REPORT_COLOR}Full report at: file://{document.name}"
-        f"{MONOCHROME}{OPTIONAL_NEWLINE}",
+        f"{MONOCHROME}{OPTIONAL_NEWLINE}"
     )
 
     lines = tcbk.format_exception(exception)

logger_36-2025.13/package/logger_36/extension/line.py

@@ -0,0 +1,83 @@
+"""
+Copyright CNRS/Inria/UniCA
+Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2023
+SEE COPYRIGHT NOTICE BELOW
+"""
+
+
+def WrappedLines(lines: list[str], message_width: int, /) -> list[str]:
+    """"""
+    output = []
+
+    for line in lines:
+        while line.__len__() > message_width:
+            if all(
+                _elm != " " for _elm in line[(message_width - 1) : (message_width + 1)]
+            ):
+                if line[message_width - 2] == " ":
+                    piece, line = (
+                        line[: (message_width - 2)].rstrip(),
+                        line[(message_width - 1) :],
+                    )
+                else:
+                    piece, line = (
+                        line[: (message_width - 1)] + "-",
+                        line[(message_width - 1) :],
+                    )
+            else:
+                piece, line = (
+                    line[:message_width].rstrip(),
+                    line[message_width:].lstrip(),
+                )
+            output.append(piece)
+
+        output.append(line)
+
+    return output
+
+
+"""
+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.13}/package/logger_36/task/format/memory.py

@@ -16,11 +16,7 @@ _BLOCK_FULL = "▉"
 
 
 def FormattedUsage(
-    usage: int,
-    /,
-    *,
-    unit: storage_units_h | None = "a",
-    decimals: int | None = None,
+    usage: int, /, *, unit: storage_units_h | None = "a", decimals: int | None = None
 ) -> tuple[int | float, str]:
     """
     unit: b or None=bytes, k=kilo, m=mega, g=giga, a=auto

{logger_36-2025.12 → logger_36-2025.13}/package/logger_36/task/format/rule.py

@@ -27,7 +27,7 @@ if RICH_IS_AVAILABLE:
             return rule_t(title=text_t(text, style=f"bold {color}"), style=color)
 
 else:
-    Rule = lambda _txt, _: RuleAsText(_txt)
+    Rule = lambda _, __: RuleAsText(_)
 
 """
 COPYRIGHT NOTICE

{logger_36-2025.12 → logger_36-2025.13}/package/logger_36/task/inspection.py

@@ -51,7 +51,7 @@ def Modules(
 
     if formatted:
         max_length += 4
-        AlignedInColumns = lambda _str: f"{_str:{max_length}}" if _str != "\n" else "\n"
+        AlignedInColumns = lambda _: f"{_:{max_length}}" if _ != "\n" else "\n"
         output = map(AlignedInColumns, output)
         output = "".join(output).rstrip()