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

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/task/format/message.py

@@ -39,7 +39,12 @@ def MessageWithActualExpected(
     else:
         dot = ""
 
-    return f"{message}: Actual={actual}:{type(actual).__name__}; {expected}{dot}"
+    if isinstance(actual, type):
+        actual = actual.__name__
+    else:
+        actual = f"{actual}:{type(actual).__name__}"
+
+    return f"{message}: Actual={actual}; {expected}{dot}"
 
 
 def _FormattedExpected(
@@ -54,14 +59,17 @@ def _FormattedExpected(
         else:
             expected = ", ".join(map(str, expected))
             return f"Valid values: {expected}"
+
+    if isinstance(expected, type):
+        return f"Expected{operator}{expected.__name__}"
+
+    if operator == "=":
+        stripe = f":{type(expected).__name__}"
     else:
-        if operator == "=":
-            stripe = f":{type(expected).__name__}"
-        else:
-            stripe = ""
-            if operator == ":":
-                operator = ": "
-        return f"Expected{operator}{expected}{stripe}"
+        stripe = ""
+        if operator == ":":
+            operator = ": "
+    return f"Expected{operator}{expected}{stripe}"
 
 
 """

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/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()
 

logger_36/task/storage.py

@@ -39,7 +39,7 @@ def SaveLOGasHTML(path: str | path_t | io_base_t | None = None) -> None:
         L.warning(f'{cannot_save}: File "{path}" already exists.')
         return
 
-    html = L.past_logs_as_HTML
+    html = "\n".join(L.recorded)
     if html is None:
         L.warning(f"{cannot_save}: No handler could provide an HTML output.")
     else:

logger_36/type/handler.py

@@ -4,57 +4,37 @@ 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 pathlib import Path as path_t
 
-from logger_36.config.message import (
-    LEVEL_CLOSING,
-    LEVEL_OPENING,
-    MESSAGE_MARKER,
-    WHERE_SEPARATOR,
-)
 from logger_36.constant.error import MEMORY_MEASURE_ERROR
 from logger_36.constant.handler import HANDLER_KINDS
-from logger_36.constant.message import NEXT_LINE_PROLOGUE
 from logger_36.task.format.message import MessageWithActualExpected
 from logger_36.task.measure.chronos import TimeStamp
 from logger_36.task.measure.memory import CanCheckUsage as CanCheckMemoryUsage
-
-MessageFromRecordRaw_h = h.Callable[[l.LogRecord], str]
-
-
-@h.runtime_checkable
-class MessageFromRecordPreprocessed_p(h.Protocol):
-    def __call__(
-        self,
-        record: l.LogRecord,
-        /,
-        *,
-        PreProcessed: h.Callable[[str], str] | None = None,
-    ) -> str: ...
-
-
-MessageFromRecord_h = MessageFromRecordRaw_h | MessageFromRecordPreprocessed_p
+from logger_36.type.message import MessageFromRecord, MessageFromRecord_h
 
 _MEMORY_MEASURE_ERROR = MEMORY_MEASURE_ERROR
 
 
-@d.dataclass(slots=True, repr=False, eq=False)
-class handler_extension_t:
-    name: str | None = None
-    should_store_memory_usage: bool = False
-    message_width: int = -1
-    MessageFromRecord: MessageFromRecord_h = d.field(init=False)
-
-    handler: d.InitVar[l.Handler | None] = None
-    level: d.InitVar[int] = l.NOTSET
-    formatter: d.InitVar[l.Formatter | None] = None
+class _base_t:
+    kind: h.ClassVar[str] = ""  # See logger_36.constant.handler.handler_codes_h.
 
-    def __post_init__(
-        self, handler: l.Handler | None, level: int, formatter: l.Formatter | None
+    def __init__(
+        self, name: str | None, should_store_memory_usage: bool, message_width: int
     ) -> None:
+        """"""
+        self.name = name
+        self.should_store_memory_usage = should_store_memory_usage
+        self.message_width = message_width
+        #
+        self.MessageFromRecord: MessageFromRecord_h | None = None
+
+        self.__post_init__()
+
+    def __post_init__(self) -> None:
         """"""
         global _MEMORY_MEASURE_ERROR
 
@@ -76,81 +56,81 @@ class handler_extension_t:
                 s.__stderr__.write(_MEMORY_MEASURE_ERROR + "\n")
                 _MEMORY_MEASURE_ERROR = None
 
-        handler.setLevel(level)
-
         if 0 < self.message_width < 5:
             self.message_width = 5
-        if formatter is None:
-            self.MessageFromRecord = self._MessageFromRecord
-        else:
-            handler.setFormatter(formatter)
-            self.MessageFromRecord = handler.formatter.format
 
-    def _MessageFromRecord(
-        self,
-        record: l.LogRecord,
-        /,
-        *,
-        PreProcessed: h.Callable[[str], str] | None = None,
-    ) -> str:
+    @classmethod
+    def New(cls, **kwargs) -> h.Self:
         """
-        See logger_36.catalog.handler.README.txt.
+        Interest: default arguments, no prescribed argument order, variable argument list.
         """
-        message = record.msg
-
-        if PreProcessed is not None:
-            message = PreProcessed(message)
-        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)
-
-        if (where := getattr(record, "where", None)) is None:
-            where = ""
-        else:
-            where = f"{NEXT_LINE_PROLOGUE}{WHERE_SEPARATOR} {where}"
-
-        return (
-            f"{record.when_or_elapsed}"
-            f"{LEVEL_OPENING}{record.level_first_letter}{LEVEL_CLOSING} "
-            f"{MESSAGE_MARKER} {message}{where}"
-        )
-
-
-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)
+        raise NotImplementedError
 
-        output.append(line)
 
-    return output
+class handler_t(l.Handler, _base_t):
+    def __init__(
+        self,
+        name: str | None,
+        should_store_memory_usage: bool,
+        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)
+
+
+class file_handler_t(l.FileHandler, _base_t):
+    def __init__(
+        self,
+        name: str | None,
+        should_store_memory_usage: bool,
+        message_width: int,
+        level: int,
+        formatter: l.Formatter | None,
+        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)
+        _base_t.__init__(self, name, should_store_memory_usage, message_width)
+        _HandlerPostInit(self, level, formatter)
+
+
+any_handler_t = handler_t | file_handler_t
+
+
+def _HandlerPostInit(
+    handler: any_handler_t, level: int, formatter: l.Formatter | None
+) -> None:
+    """"""
+    handler.setLevel(level)
+
+    if formatter is None:
+        handler.MessageFromRecord = MessageFromRecord
+    else:
+        handler.setFormatter(formatter)
+        _MessageFromRecordRaw = handler.formatter.format
+
+        def _MessageFromRecord(
+            record: l.LogRecord,
+            /,
+            *,
+            line_width: int = 0,
+            PreProcessed: h.Callable[[str], str] | None = None,
+        ) -> str:
+            #
+            return _MessageFromRecordRaw(record)
+
+        handler.MessageFromRecord = _MessageFromRecord
 
 
 """

logger_36/type/logger.py

@@ -17,6 +17,9 @@ from os import sep as FOLDER_SEPARATOR
 from pathlib import Path as path_t
 from traceback import TracebackException as traceback_t
 
+from logger_36.catalog.config.optional import MISSING_RICH_MESSAGE, RICH_IS_AVAILABLE
+from logger_36.catalog.handler.console import console_handler_t
+from logger_36.catalog.handler.file import file_handler_t
 from logger_36.config.issue import ISSUE_CONTEXT_END, ISSUE_CONTEXT_SEPARATOR
 from logger_36.config.message import (
     DATE_FORMAT,
@@ -40,13 +43,21 @@ from logger_36.constant.record import (
     SHOW_W_RULE_ATTR,
     STORE_MEMORY_ATTR,
 )
-from logger_36.exception import OverrideExceptionFormat
-from logger_36.handler import AddConsoleHandler, AddFileHandler, AddRichConsoleHandler
+from logger_36.extension.exception import OverrideExceptionFormat
 from logger_36.task.format.message import 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
+else:
+    from logger_36.catalog.handler.console import (
+        console_handler_t as console_rich_handler_t,
+    )
 
 base_t = l.Logger
 
@@ -74,10 +85,12 @@ class logger_t(base_t):
 
     # 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)
     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)
@@ -112,16 +125,9 @@ class logger_t(base_t):
         return self.staged_issues.__len__() > 0
 
     @property
-    def past_logs_as_HTML(self) -> str | None:
-        """
-        From the first handler found with the given functionality, if any.
-        """
-        for handler in self.handlers:
-            past_logs_as_HTML = getattr(handler, "past_logs_as_HTML", None)
-            if past_logs_as_HTML is not None:
-                return past_logs_as_HTML
-
-        return None
+    def n_staged_issues(self) -> int:
+        """"""
+        return self.staged_issues.__len__()
 
     @property
     def max_memory_usage(self) -> int:
@@ -172,6 +178,8 @@ class logger_t(base_t):
 
         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))
                 base_t.handle(self, held)
             self.on_hold.clear()
 
@@ -189,6 +197,8 @@ class logger_t(base_t):
             if self.should_hold_messages:
                 self.on_hold.append(date_record)
             else:
+                if self.should_record_messages:
+                    self.recorded.append(MessageFromRecord(date_record))
                 base_t.handle(self, date_record)
 
         # When.
@@ -231,6 +241,8 @@ class logger_t(base_t):
         if self.should_hold_messages:
             self.on_hold.append(record)
         else:
+            if self.should_record_messages:
+                self.recorded.append(MessageFromRecord(record))
             base_t.handle(self, record)
 
         if (self.exit_on_critical and (record.levelno is l.CRITICAL)) or (
@@ -245,13 +257,7 @@ class logger_t(base_t):
         if should_store_where:
             self.memory_usages.append((where, CurrentMemoryUsage()))
 
-    def SetLevel(
-        self,
-        level: int,
-        /,
-        *,
-        which: handler_codes_h | str = "a",
-    ) -> None:
+    def SetLevel(self, level: int, /, *, which: handler_codes_h | str = "a") -> None:
         """
         Set level of handlers, but the logger level is not modified.
 
@@ -281,17 +287,24 @@ class logger_t(base_t):
     def MakeMonochrome(self) -> None:
         """"""
         OverrideExceptionFormat()
-        AddConsoleHandler(self)
+        self.AddHandler(console_handler_t)
 
     def MakeRich(self, *, alternating_logs: int = 0) -> None:
         """"""
+        if MISSING_RICH_MESSAGE is not None:
+            s.__stderr__.write(MISSING_RICH_MESSAGE + "\n")
+
         OverrideExceptionFormat()
-        AddRichConsoleHandler(self, alternating_logs=alternating_logs)
+        if console_rich_handler_t is console_handler_t:
+            handler_kwargs = {}
+        else:
+            handler_kwargs = {"alternating_logs": alternating_logs}
+        self.AddHandler(console_rich_handler_t, **handler_kwargs)
 
     def MakePermanent(self, path: str | path_t, /) -> None:
         """"""
         OverrideExceptionFormat()
-        AddFileHandler(self, path)
+        self.AddHandler(file_handler_t, path=path)
 
     def ResetEventCounts(self) -> None:
         """"""
@@ -355,14 +368,32 @@ class logger_t(base_t):
             self.info("Log Interception: OFF")
 
     def AddHandler(
-        self, handler: l.Handler, /, *, should_hold_messages: bool = False
+        self,
+        handler_t: type[base_handler_t],
+        /,
+        *,
+        name: str | None = None,
+        level: int = l.INFO,
+        should_store_memory_usage: bool = False,
+        message_width: int = -1,
+        formatter: l.Formatter | None = None,
+        should_still_hold_messages: bool = False,
+        **kwargs,
     ) -> None:
         """"""
-        if (not should_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_hold_messages = should_hold_messages
+        self.should_hold_messages = should_still_hold_messages
+        handler = handler_t.New(
+            name=name,
+            should_store_memory_usage=should_store_memory_usage,
+            message_width=message_width,
+            level=level,
+            formatter=formatter,
+            **kwargs,
+        )
         base_t.addHandler(self, handler)
 
         extension = getattr(handler, "extension", None)
@@ -381,7 +412,7 @@ class logger_t(base_t):
 
         self.info(
             f'New handler "{name}" of type "{type(handler).__name__}" and '
-            f"level {handler.level}={l.getLevelName(handler.level)}{path}",
+            f"level {handler.level}={l.getLevelName(handler.level)}{path}"
         )
 
     def Log(
@@ -497,12 +528,29 @@ class logger_t(base_t):
         )
         self.staged_issues.append(issue)
 
+    def PopIssues(self, /, *, should_remove_context: bool = False) -> list[str]:
+        """"""
+        if not self.has_staged_issues:
+            return []
+
+        output = []
+
+        if should_remove_context:
+            separator = ISSUE_CONTEXT_END
+        else:
+            separator = ISSUE_LEVEL_SEPARATOR
+        separator_length = separator.__len__()
+        for issue in self.staged_issues:
+            start_idx = issue.find(separator)
+            issue = issue[(start_idx + separator_length) :]
+            output.append(issue)
+
+        self.staged_issues.clear()
+
+        return output
+
     def CommitIssues(
-        self,
-        /,
-        *,
-        order: order_h = "when",
-        unified: bool = False,
+        self, /, *, order: order_h = "when", unified: bool = False
     ) -> None:
         """
         Note that issues after an issue with a level triggering process exit will not be
@@ -523,7 +571,7 @@ class logger_t(base_t):
         if order == "when":
             issues = self.staged_issues
         else:  # order == "context"
-            issues = sorted(self.staged_issues, key=lambda _elm: _elm.context)
+            issues = sorted(self.staged_issues, key=lambda _: _.context)
         """
         Format issues as an exception:
         try:

logger_36/type/message.py

@@ -0,0 +1,121 @@
+"""
+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 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
+
+
+@h.runtime_checkable
+class _MessageFromRecordPreprocessed_p(h.Protocol):
+    def __call__(
+        self,
+        record: l.LogRecord,
+        /,
+        *,
+        line_width: int = 0,
+        PreProcessed: h.Callable[[str], str] | None = None,
+    ) -> str: ...
+
+
+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
+
+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/version.py

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

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: logger-36
-Version: 2025.11
+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