logger-36 2025.6__py3-none-any.whl → 2025.7__py3-none-any.whl

logger_36/catalog/handler/console.py

@@ -6,14 +6,11 @@ SEE COPYRIGHT NOTICE BELOW
 
 import dataclasses as d
 import logging as l
-import textwrap as txt_
 import typing as h
 
-from logger_36.constant.message import LINE_INDENT
 from logger_36.constant.record import SHOW_W_RULE_ATTR
 from logger_36.task.format.rule import RuleAsText
-from logger_36.type.handler import handler_extension_t
-from logger_36.type.handler import message_from_record_raw_p as message_from_record_p
+from logger_36.type.handler import MessageFromRecordRaw_h, handler_extension_t
 
 
 @d.dataclass(slots=True, repr=False, eq=False)
@@ -25,7 +22,7 @@ class console_handler_t(l.Handler):
     kind: h.ClassVar[str] = "c"
 
     extension: handler_extension_t = d.field(init=False)
-    MessageFromRecord: message_from_record_p = d.field(init=False)
+    MessageFromRecord: MessageFromRecordRaw_h = d.field(init=False)
 
     name: d.InitVar[str | None] = None
     level: d.InitVar[int] = l.NOTSET
@@ -63,18 +60,16 @@ class console_handler_t(l.Handler):
             message = self.MessageFromRecord(record)
         print(message)
 
-    def ShowMessage(self, message: str, /, *, indented: bool = False) -> None:
+    def LogAsIs(self, message: str, /) -> None:
         """
         See documentation of
-        logger_36.catalog.handler.generic.generic_handler_t.ShowMessage.
+        logger_36.catalog.handler.generic.generic_handler_t.LogAsIs.
         """
-        if indented:
-            message = txt_.indent(message, LINE_INDENT)
         print(message)
 
     def DisplayRule(self, /, *, text: str | None = None, color: str = "white") -> None:
         """"""
-        self.ShowMessage(RuleAsText(text))
+        self.LogAsIs(RuleAsText(text))
 
 
 """

logger_36/catalog/handler/console_rich.py

@@ -6,7 +6,6 @@ SEE COPYRIGHT NOTICE BELOW
 
 import dataclasses as d
 import logging as l
-import textwrap as txt_
 import typing as h
 
 from logger_36.catalog.config.console_rich import (
@@ -20,13 +19,10 @@ from logger_36.catalog.config.console_rich import (
     WHITE_COLOR,
 )
 from logger_36.config.message import ACTUAL_PATTERNS, EXPECTED_PATTERNS, WHERE_SEPARATOR
-from logger_36.constant.message import CONTEXT_LENGTH, LINE_INDENT
+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, rule_t
-from logger_36.type.handler import handler_extension_t
-from logger_36.type.handler import (
-    message_from_record_preprocessed_p as message_from_record_p,
-)
+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
@@ -64,7 +60,7 @@ class console_rich_handler_t(l.Handler):
 
     extension: handler_extension_t = d.field(init=False)
     console: console_t = d.field(init=False)
-    MessageFromRecord: message_from_record_p = d.field(init=False)
+    MessageFromRecord: MessageFromRecordPreprocessed_p = d.field(init=False)
     alternating_lines: int = 0
     background_is_light: bool = True
 
@@ -152,18 +148,16 @@ class console_rich_handler_t(l.Handler):
             )
         self.console.print(richer, crop=False, overflow="ignore")
 
-    def ShowMessage(self, message: str | rule_t, /, *, indented: bool = False) -> None:
+    def LogAsIs(self, message: str | renderable_t, /) -> None:
         """
         See documentation of
-        logger_36.catalog.handler.generic.generic_handler_t.ShowMessage.
+        logger_36.catalog.handler.generic.generic_handler_t.LogAsIs.
         """
-        if isinstance(message, str) and indented:
-            message = txt_.indent(message, LINE_INDENT)
         self.console.print(message, crop=False, overflow="ignore")
 
     def DisplayRule(self, /, *, text: str | None = None, color: str = "white") -> None:
         """"""
-        self.ShowMessage(Rule(text, color))
+        self.LogAsIs(Rule(text, color))
 
 
 def HighlightedVersion(

logger_36/catalog/handler/file.py

@@ -6,15 +6,12 @@ SEE COPYRIGHT NOTICE BELOW
 
 import dataclasses as d
 import logging as l
-import textwrap as txt_
 import typing as h
 from pathlib import Path as path_t
 
-from logger_36.constant.message import LINE_INDENT
 from logger_36.constant.record import SHOW_W_RULE_ATTR
 from logger_36.task.format.rule import RuleAsText
-from logger_36.type.handler import handler_extension_t
-from logger_36.type.handler import message_from_record_raw_p as message_from_record_p
+from logger_36.type.handler import MessageFromRecordRaw_h, handler_extension_t
 
 
 @d.dataclass(slots=True, repr=False, eq=False)
@@ -26,7 +23,7 @@ class file_handler_t(l.FileHandler):
     kind: h.ClassVar[str] = "f"
 
     extension: handler_extension_t = d.field(init=False)
-    MessageFromRecord: message_from_record_p = d.field(init=False)
+    MessageFromRecord: MessageFromRecordRaw_h = d.field(init=False)
 
     name: d.InitVar[str | None] = None
     level: d.InitVar[int] = l.NOTSET
@@ -72,19 +69,17 @@ class file_handler_t(l.FileHandler):
         print(message, file=self.stream)
         self.stream.flush()
 
-    def ShowMessage(self, message: str, /, *, indented: bool = False) -> None:
+    def LogAsIs(self, message: str, /) -> None:
         """
         See documentation of
-        logger_36.catalog.handler.generic.generic_handler_t.ShowMessage.
+        logger_36.catalog.handler.generic.generic_handler_t.LogAsIs.
         """
-        if indented:
-            message = txt_.indent(message, LINE_INDENT)
         print(message, file=self.stream)
         self.stream.flush()
 
     def DisplayRule(self, /, *, text: str | None = None, color: str = "white") -> None:
         """"""
-        self.ShowMessage(RuleAsText(text))
+        self.LogAsIs(RuleAsText(text))
 
 
 """

logger_36/catalog/handler/generic.py

@@ -24,16 +24,13 @@ 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 handler_extension_t, message_from_record_h
+from logger_36.type.handler import MessageFromRecord_h, handler_extension_t
 
-
-@h.runtime_checkable
-class show_message_p(h.Protocol):
-    def __call__(self, message: str, /, *, indented: bool = False) -> None: ...
+LogAsIs_h = h.Callable[[str | h.Any], None]
 
 
 @h.runtime_checkable
-class display_rule_p(h.Protocol):
+class DisplayRule_p(h.Protocol):
     def __call__(self, /, *, text: str | None = None, color: str = "white") -> None: ...
 
 
@@ -49,7 +46,7 @@ class generic_handler_t(l.Handler):
             - anything else: disabled
         - Runtime value: 0/1=do not/do highlight next time.
 
-    ShowMessage:
+    LogAsIs:
         Log a message as is, i.e. without formatting. If this is a method, it should
         contain the same call(s) as the final ones in the emit methods that are used to
         output the formatted log messages. This means that there is some code
@@ -62,16 +59,16 @@ class generic_handler_t(l.Handler):
 
     kind: h.ClassVar[str] = "g"
 
-    ShowMessage: show_message_p
+    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_lines: int = 0
     background_is_light: bool = True
 
-    DisplayRule: display_rule_p = d.field(init=False)
+    DisplayRule: DisplayRule_p = d.field(init=False)
     extension: handler_extension_t = d.field(init=False)
-    MessageFromRecord: message_from_record_h = d.field(init=False)
+    MessageFromRecord: MessageFromRecord_h = d.field(init=False)
 
     name: d.InitVar[str | None] = None
     level: d.InitVar[int] = l.NOTSET
@@ -178,17 +175,17 @@ class generic_handler_t(l.Handler):
                 "<pre style='margin-bottom:0px'>" + "".join(html_segments) + "</pre>"
             )
 
-        self.ShowMessage(message)
+        self.LogAsIs(message)
 
     def _DisplayRuleAsText(
         self, /, *, text: str | None = None, color: str = "white"
     ) -> None:
         """"""
-        self.ShowMessage(RuleAsText(text))
+        self.LogAsIs(RuleAsText(text))
 
     def _DisplayRule(self, /, *, text: str | None = None, color: str = "white") -> None:
         """"""
-        self.ShowMessage(Rule(text, color))
+        self.LogAsIs(Rule(text, color))
 
 
 """

logger_36/constant/path.py

@@ -0,0 +1,69 @@
+"""
+Copyright CNRS/Inria/UniCA
+Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2023
+SEE COPYRIGHT NOTICE BELOW
+"""
+
+import inspect as nspt
+import tempfile as tmps
+from pathlib import Path as path_t
+
+USER_FOLDER = path_t.home()
+
+frame = nspt.stack()[-1]
+if path_t(frame.filename).exists():
+    PROJECT_FILE = path_t(frame.filename)
+    if PROJECT_FILE.is_relative_to(USER_FOLDER):
+        PROJECT_FILE_RELATIVE = path_t("~") / PROJECT_FILE.relative_to(USER_FOLDER)
+    else:
+        PROJECT_FILE_RELATIVE = PROJECT_FILE
+    PROJECT_FOLDER = PROJECT_FILE.parent
+else:
+    PROJECT_FILE = PROJECT_FILE_RELATIVE = "<unknown>"
+    PROJECT_FOLDER = path_t(tmps.mkdtemp())
+
+"""
+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/exception.py

@@ -11,6 +11,8 @@ import traceback as tcbk
 import types as t
 from pathlib import Path as path_t
 
+from logger_36.constant.path import USER_FOLDER
+
 _ORIGINAL_EXCEPTION_HANDLER = s.excepthook
 
 
@@ -38,9 +40,8 @@ def _HandleException(
     line_content = module.read_text().splitlines()[line_number - 1].strip()
 
     # Format module.
-    home = path_t.home()
-    if module.is_relative_to(home):
-        module = path_t("~") / module.relative_to(home)
+    if module.is_relative_to(USER_FOLDER):
+        module = path_t("~") / module.relative_to(USER_FOLDER)
 
     # Format line content.
     if line_content.startswith("raise "):

logger_36/handler.py

@@ -11,7 +11,7 @@ from pathlib import Path as path_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.catalog.handler.generic import generic_handler_t, show_message_p
+from logger_36.catalog.handler.generic import LogAsIs_h, generic_handler_t
 
 if RICH_IS_AVAILABLE:
     from logger_36.catalog.handler.console_rich import console_rich_handler_t
@@ -24,7 +24,7 @@ _MISSING_RICH_MESSAGE = MISSING_RICH_MESSAGE
 
 def AddGenericHandler(
     logger: l.Logger,
-    ShowMessage: show_message_p,
+    LogAsIs: LogAsIs_h,
     /,
     *,
     name: str | None = None,
@@ -49,7 +49,7 @@ def AddGenericHandler(
         alternating_lines=alternating_lines,
         should_record=should_record,
         rich_kwargs=kwargs,
-        ShowMessage=ShowMessage,
+        LogAsIs=LogAsIs,
     )
     logger.AddHandler(handler, should_hold_messages=should_hold_messages)
 

logger_36/type/handler.py

@@ -22,14 +22,11 @@ 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
 
-
-@h.runtime_checkable
-class message_from_record_raw_p(h.Protocol):
-    def __call__(self, record: l.LogRecord, /) -> str: ...
+MessageFromRecordRaw_h = h.Callable[[l.LogRecord], str]
 
 
 @h.runtime_checkable
-class message_from_record_preprocessed_p(h.Protocol):
+class MessageFromRecordPreprocessed_p(h.Protocol):
     def __call__(
         self,
         record: l.LogRecord,
@@ -39,7 +36,7 @@ class message_from_record_preprocessed_p(h.Protocol):
     ) -> str: ...
 
 
-message_from_record_h = message_from_record_raw_p | message_from_record_preprocessed_p
+MessageFromRecord_h = MessageFromRecordRaw_h | MessageFromRecordPreprocessed_p
 
 _MEMORY_MEASURE_ERROR = MEMORY_MEASURE_ERROR
 
@@ -49,7 +46,7 @@ class handler_extension_t:
     name: str | None = None
     should_store_memory_usage: bool = False
     message_width: int = -1
-    MessageFromRecord: message_from_record_h = d.field(init=False)
+    MessageFromRecord: MessageFromRecord_h = d.field(init=False)
 
     handler: d.InitVar[l.Handler | None] = None
     level: d.InitVar[int] = l.NOTSET

logger_36/type/logger.py

@@ -7,6 +7,7 @@ SEE COPYRIGHT NOTICE BELOW
 import dataclasses as d
 import logging as l
 import sys as s
+import textwrap as text
 import traceback as tcbk
 import types as t
 import typing as h
@@ -32,15 +33,17 @@ from logger_36.constant.logger import (
     WARNING_TYPE_COMPILED_PATTERN,
 )
 from logger_36.constant.memory import UNKNOWN_MEMORY_USAGE
-from logger_36.constant.message import TIME_LENGTH_m_1, expected_op_h
+from logger_36.constant.message import LINE_INDENT, TIME_LENGTH_m_1, expected_op_h
+from logger_36.constant.path import PROJECT_FILE_RELATIVE
 from logger_36.constant.record import (
     HIDE_WHERE_ATTR,
     SHOW_W_RULE_ATTR,
     STORE_MEMORY_ATTR,
 )
 from logger_36.exception import OverrideExceptionFormat
-from logger_36.handler import AddRichConsoleHandler
+from logger_36.handler import AddConsoleHandler, AddFileHandler, AddRichConsoleHandler
 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.issue import NewIssue, issue_t
@@ -84,6 +87,39 @@ class logger_t(base_t):
         init=False, default_factory=dict
     )
 
+    @property
+    def intercepts_warnings(self) -> bool:
+        """"""
+        return self.intercepted_wrn_handle is not None
+
+    @property
+    def intercepts_logs(self) -> bool:
+        """"""
+        return self.intercepted_log_handles.__len__() > 0
+
+    @property
+    def has_staged_issues(self) -> bool:
+        """"""
+        return self.staged_issues.__len__() > 0
+
+    @property
+    def max_memory_usage(self) -> int:
+        """"""
+        if self.memory_usages.__len__() > 0:
+            return max(tuple(zip(*self.memory_usages))[1])
+        return UNKNOWN_MEMORY_USAGE
+
+    @property
+    def max_memory_usage_full(self) -> tuple[str, int]:
+        """"""
+        if self.memory_usages.__len__() > 0:
+            where_s, usages = zip(*self.memory_usages)
+            max_usage = max(usages)
+
+            return where_s[usages.index(max_usage)], max_usage
+
+        return "?", UNKNOWN_MEMORY_USAGE
+
     def __post_init__(
         self, name_: str, level_: int, activate_wrn_interceptions: bool
     ) -> None:
@@ -95,11 +131,92 @@ class logger_t(base_t):
         for level in l.getLevelNamesMapping().values():
             self.events[level] = 0
 
+        self.info(f'New logger "{self.name}" for "{PROJECT_FILE_RELATIVE}"')
+
         if activate_wrn_interceptions:
-            self._ActivateWarningInterceptions()
+            self.ToggleWarningInterceptions(True)
         if self.exit_on_error:
             self.exit_on_critical = True
 
+    def handle(self, record: l.LogRecord, /) -> None:
+        """"""
+        elapsed_time, now = ElapsedTime(should_return_now=True)
+
+        if (self.on_hold.__len__() > 0) and not self.should_hold_messages:
+            for held in self.on_hold:
+                base_t.handle(self, held)
+            self.on_hold.clear()
+
+        if (date := now.date()) != self.last_message_date:
+            self.last_message_date = date
+            # levelno: Added for management by logging.Logger.handle.
+            date_record = l.makeLogRecord(
+                {
+                    "name": self.name,
+                    "levelno": l.INFO,
+                    "msg": f"DATE: {date.strftime(DATE_FORMAT)}",
+                    SHOW_W_RULE_ATTR: True,
+                }
+            )
+            if self.should_hold_messages:
+                self.on_hold.append(date_record)
+            else:
+                base_t.handle(self, date_record)
+
+        # When.
+        if now - self.last_message_now > LONG_ENOUGH:
+            record.when_or_elapsed = now.strftime(TIME_FORMAT)
+        else:
+            record.when_or_elapsed = (
+                f"{ELAPSED_TIME_SEPARATOR}{elapsed_time:.<{TIME_LENGTH_m_1}}"
+            )
+        self.last_message_now = now
+
+        # Where.
+        # Memory usage is also stored if there are no handlers yet, just in case.
+        should_store_where = self.any_handler_stores_memory or not self.hasHandlers()
+        should_show_where = (record.levelno != l.INFO) and not hasattr(
+            record, HIDE_WHERE_ATTR
+        )
+        if should_store_where or should_show_where:
+            module = path_t(record.pathname)
+            for path in s.path:
+                if module.is_relative_to(path):
+                    module = module.relative_to(path).with_suffix("")
+                    module = str(module).replace(FOLDER_SEPARATOR, ".")
+                    break
+            else:
+                module = record.module
+            where = f"{module}:{record.funcName}:{record.lineno}"
+            if should_show_where:
+                record.where = where
+        else:
+            where = None
+
+        # How.
+        record.level_first_letter = record.levelname[0]
+
+        # What.
+        if not isinstance(record.msg, str):
+            record.msg = str(record.msg)
+
+        if self.should_hold_messages:
+            self.on_hold.append(record)
+        else:
+            base_t.handle(self, record)
+
+        if (self.exit_on_critical and (record.levelno is l.CRITICAL)) or (
+            self.exit_on_error and (record.levelno is l.ERROR)
+        ):
+            # Also works if self.exit_on_error and record.levelno is l.CRITICAL since
+            # __post_init__ set self.exit_on_critical if self.exit_on_error.
+            s.exit(1)
+
+        self.events[record.levelno] += 1
+
+        if should_store_where:
+            self.memory_usages.append((where, CurrentMemoryUsage()))
+
     def SetLevel(
         self,
         level: int,
@@ -133,32 +250,82 @@ class logger_t(base_t):
                 )
             )
 
-    def MakeRich(self, *, alternating_lines: int = 2) -> None:
+    def MakeMonochrome(
+        self,
+        *,
+        should_intercept_logs: bool = True,
+        should_override_exceptions: bool = True,
+    ) -> None:
+        """"""
+        self._MakePreamble(
+            should_intercept_logs=should_intercept_logs,
+            should_override_exceptions=should_override_exceptions,
+        )
+        AddConsoleHandler(self)
+
+    def MakeRich(
+        self,
+        *,
+        alternating_lines: int = 2,
+        should_intercept_logs: bool = True,
+        should_override_exceptions: bool = True,
+    ) -> None:
         """"""
-        OverrideExceptionFormat()
+        self._MakePreamble(
+            should_intercept_logs=should_intercept_logs,
+            should_override_exceptions=should_override_exceptions,
+        )
         AddRichConsoleHandler(self, alternating_lines=alternating_lines)
 
+    def MakePermanent(
+        self,
+        path: str | path_t,
+        /,
+        *,
+        should_intercept_logs: bool = True,
+        should_override_exceptions: bool = True,
+    ) -> None:
+        """"""
+        self._MakePreamble(
+            should_intercept_logs=should_intercept_logs,
+            should_override_exceptions=should_override_exceptions,
+        )
+        AddFileHandler(self, path)
+
+    def _MakePreamble(
+        self,
+        *,
+        should_intercept_logs: bool = True,
+        should_override_exceptions: bool = True,
+    ) -> None:
+        """"""
+        if should_override_exceptions:
+            OverrideExceptionFormat()
+        if should_intercept_logs:
+            self.ToggleLogInterceptions(True)
+
     def ResetEventCounts(self) -> None:
         """"""
         for level in self.events:
             self.events[level] = 0
 
-    def _ActivateWarningInterceptions(self) -> None:
+    def ToggleWarningInterceptions(self, state: bool, /) -> None:
         """
         The log message will not appear if called from __post_init__ since there are no
         handlers yet.
         """
-        if self.intercepted_wrn_handle is None:
+        if state:
+            assert not self.intercepts_warnings
+
             logger = l.getLogger(WARNING_LOGGER_NAME)
             self.intercepted_wrn_handle = logger.handle
             logger.handle = t.MethodType(_HandleForWarnings(self), logger)
 
             l.captureWarnings(True)
             self.info("Warning Interception: ON")
+        else:
+            assert self.intercepts_warnings
 
-    def _DeactivateWarningInterceptions(self) -> None:
-        """"""
-        if self.intercepted_wrn_handle is not None:
             logger = l.getLogger(WARNING_LOGGER_NAME)
             logger.handle = self.intercepted_wrn_handle
             self.intercepted_wrn_handle = None
@@ -166,17 +333,10 @@ class logger_t(base_t):
             l.captureWarnings(False)
             self.info("Warning Interception: OFF")
 
-    def ToggleWarningInterceptions(self, state: bool, /) -> None:
-        """"""
-        if state:
-            self._ActivateWarningInterceptions()
-        else:
-            self._DeactivateWarningInterceptions()
-
     def ToggleLogInterceptions(self, state: bool, /) -> None:
         """"""
         if state:
-            self.ToggleLogInterceptions(False)
+            assert not self.intercepts_logs
 
             all_loggers = [l.getLogger()] + [
                 l.getLogger(_nme)
@@ -193,31 +353,15 @@ class logger_t(base_t):
             if intercepted.__len__() > 0:
                 as_str = ", ".join(intercepted)
                 self.info(f"Now Intercepting LOGs from: {as_str}")
-        elif self.intercepted_log_handles.__len__() > 0:
+        else:
+            assert self.intercepts_logs
+
             for name, handle in self.intercepted_log_handles.items():
                 logger = l.getLogger(name)
                 logger.handle = handle
             self.intercepted_log_handles.clear()
             self.info("Log Interception: OFF")
 
-    @property
-    def max_memory_usage(self) -> int:
-        """"""
-        if self.memory_usages.__len__() > 0:
-            return max(tuple(zip(*self.memory_usages))[1])
-        return UNKNOWN_MEMORY_USAGE
-
-    @property
-    def max_memory_usage_full(self) -> tuple[str, int]:
-        """"""
-        if self.memory_usages.__len__() > 0:
-            where_s, usages = zip(*self.memory_usages)
-            max_usage = max(usages)
-
-            return where_s[usages.index(max_usage)], max_usage
-
-        return "?", UNKNOWN_MEMORY_USAGE
-
     def AddHandler(
         self, handler: l.Handler, /, *, should_hold_messages: bool = False
     ) -> None:
@@ -244,85 +388,6 @@ class logger_t(base_t):
             f"level {handler.level}={l.getLevelName(handler.level)}{path}",
         )
 
-    def handle(self, record: l.LogRecord, /) -> None:
-        """"""
-        elapsed_time, now = ElapsedTime(should_return_now=True)
-
-        if (self.on_hold.__len__() > 0) and not self.should_hold_messages:
-            for held in self.on_hold:
-                base_t.handle(self, held)
-            self.on_hold.clear()
-
-        if (date := now.date()) != self.last_message_date:
-            self.last_message_date = date
-            # levelno: Added for management by logging.Logger.handle.
-            date_record = l.makeLogRecord(
-                {
-                    "name": self.name,
-                    "levelno": l.INFO,
-                    "msg": f"DATE: {date.strftime(DATE_FORMAT)}",
-                    SHOW_W_RULE_ATTR: True,
-                }
-            )
-            if self.should_hold_messages:
-                self.on_hold.append(date_record)
-            else:
-                base_t.handle(self, date_record)
-
-        # When.
-        if now - self.last_message_now > LONG_ENOUGH:
-            record.when_or_elapsed = now.strftime(TIME_FORMAT)
-        else:
-            record.when_or_elapsed = (
-                f"{ELAPSED_TIME_SEPARATOR}{elapsed_time:.<{TIME_LENGTH_m_1}}"
-            )
-        self.last_message_now = now
-
-        # Where.
-        # Memory usage is also stored if there are no handlers yet, just in case.
-        should_store_where = self.any_handler_stores_memory or not self.hasHandlers()
-        should_show_where = (record.levelno != l.INFO) and not hasattr(
-            record, HIDE_WHERE_ATTR
-        )
-        if should_store_where or should_show_where:
-            module = path_t(record.pathname)
-            for path in s.path:
-                if module.is_relative_to(path):
-                    module = module.relative_to(path).with_suffix("")
-                    module = str(module).replace(FOLDER_SEPARATOR, ".")
-                    break
-            else:
-                module = record.module
-            where = f"{module}:{record.funcName}:{record.lineno}"
-            if should_show_where:
-                record.where = where
-        else:
-            where = None
-
-        # How.
-        record.level_first_letter = record.levelname[0]
-
-        # What.
-        if not isinstance(record.msg, str):
-            record.msg = str(record.msg)
-
-        if self.should_hold_messages:
-            self.on_hold.append(record)
-        else:
-            base_t.handle(self, record)
-
-        if (self.exit_on_critical and (record.levelno is l.CRITICAL)) or (
-            self.exit_on_error and (record.levelno is l.ERROR)
-        ):
-            # Also works if self.exit_on_error and record.levelno is l.CRITICAL since
-            # __post_init__ set self.exit_on_critical if self.exit_on_error.
-            s.exit(1)
-
-        self.events[record.levelno] += 1
-
-        if should_store_where:
-            self.memory_usages.append((where, CurrentMemoryUsage()))
-
     def Log(
         self,
         message: str,
@@ -370,22 +435,31 @@ class logger_t(base_t):
             message = f"{type(exception).__name__}:\n{formatted}"
         self.log(level, message)
 
-    def ShowMessage(self, message: str, /, *, indented: bool = False) -> None:
+    def LogAsIs(self, message: str, /, *, indented: bool = False) -> None:
         """
         See documentation of
-        logger_36.catalog.handler.generic.generic_handler_t.ShowMessage.
+        logger_36.catalog.handler.generic.generic_handler_t.LogAsIs.
         """
+        if indented:
+            message = text.indent(message, LINE_INDENT)
+
         for handler in self.handlers:
-            ShowMessage = getattr(handler, "ShowMessage", None)
-            if ShowMessage is not None:
-                ShowMessage(message, indented=indented)
+            if (LogAsIs := getattr(handler, "LogAsIs", None)) is None:
+                self.info(message)
+            else:
+                LogAsIs(message)
+
+    raw_info = LogAsIs  # To follow the convention of the logging methods info, error...
 
-    def DisplayRule(self, /, *, text: str | None = None, color: str = "white") -> None:
+    def DisplayRule(
+        self, /, *, message: str | None = None, color: str = "white"
+    ) -> None:
         """"""
         for handler in self.handlers:
-            DisplayRule = getattr(handler, "DisplayRule", None)
-            if DisplayRule is not None:
-                DisplayRule(text=text, color=color)
+            if (DisplayRule := getattr(handler, "DisplayRule", None)) is None:
+                self.info(RuleAsText(message))
+            else:
+                DisplayRule(text=message, color=color)
 
     def AddContextLevel(self, new_level: str, /) -> None:
         """"""
@@ -427,11 +501,6 @@ class logger_t(base_t):
         )
         self.staged_issues.append(issue)
 
-    @property
-    def has_staged_issues(self) -> bool:
-        """"""
-        return self.staged_issues.__len__() > 0
-
     def CommitIssues(
         self,
         /,

logger_36/version.py

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

{logger_36-2025.6.dist-info → logger_36-2025.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: logger-36
-Version: 2025.6
+Version: 2025.7
 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.6.dist-info → logger_36-2025.7.dist-info}/RECORD

@@ -1,21 +1,21 @@
 logger_36/__init__.py,sha256=3BtAgxFb14e9zzC5fXwqSQxstsd3BO0b_KVu3_wbLwg,2592
 logger_36/content.py,sha256=clHYYUKa8n4qef6PVlUV4mFHRRf6fnm9wEd2fu9oagA,2381
-logger_36/exception.py,sha256=YNT4S_gvz7WQUSWILFAwI01h5-BVw1d0oT97zjnw3dU,4575
+logger_36/exception.py,sha256=BQm9maX9CMjpqN26cEsArPCcX37LqYtQSrUZ3fN8tbU,4613
 logger_36/gpu.py,sha256=BOumedCAPWvCo7J-KJ3XE-jr5S0KSmgcFv_S4QKRPO8,2252
-logger_36/handler.py,sha256=hEKhfsKHhg8UqSrBTVe7w0lubf9SSkuGMi81oXwjPoo,6326
+logger_36/handler.py,sha256=pIwunW-_aSB-SrdlvVmq61nOTH03deKIVcJa4Sz_hkc,6304
 logger_36/memory.py,sha256=szJVk4UTXsbYv3B-W9LFttf1F3j86GXHsKgEUOsXKl4,2743
 logger_36/storage.py,sha256=sCxkHQH4xMaseweK1p2M1j0j2PxNPpy9MytPdg1sKiQ,2239
 logger_36/system.py,sha256=cgOMF_OneYeIJDMbIbIDx96EZss2uAdkk8QofOC7O1U,2251
 logger_36/time.py,sha256=Uw1jQtY1njsRuIPRAXX44v4nPOo84MSBu_WK_YCRzQs,2324
-logger_36/version.py,sha256=eAXepMLNtMw0muvMucofZ1LJ6BBOIZKujqvtOs93Qho,2205
+logger_36/version.py,sha256=QWIy4Jr-I6cIfY2uS0OZkwf54A1Oh3Rxgb14HI6W6bE,2205
 logger_36/api/logger.py,sha256=TE3ATbymeWX-wBKBFkVz2FxUyJnaqY7vzFwAONVsp2o,2233
 logger_36/api/storage.py,sha256=KT52AGR37nsMrhKTVfG8R-Dc7lmCXjWML18cOqqCXZY,2239
 logger_36/catalog/config/console_rich.py,sha256=lAa5Ev5BhXvmQzfIt1FNihMNUQJFlXaIzNanAMdgtd0,2861
 logger_36/catalog/config/optional.py,sha256=HaN6mbx7gHBBppNvUw1ckhYTOrlYqb-b_r0mzPcHPjM,2398
-logger_36/catalog/handler/console.py,sha256=tLMroj95xt_IC9Vra4M5TCDRKrU4mSkfvUg9GliQ_l8,4402
-logger_36/catalog/handler/console_rich.py,sha256=gkRnbhwyFFrS4nGvgUn9lElh7YNCAaC2-7dAex5bHzI,8592
-logger_36/catalog/handler/file.py,sha256=hCb21GahjeRbBJGtPsa2PPme7LmlZ8ftF3Q_BMKRiA8,4865
-logger_36/catalog/handler/generic.py,sha256=Y6rxfKkWe9cA196ntt6p0_rcjEeESGFCKWVlo1WIzW0,9335
+logger_36/catalog/handler/console.py,sha256=s2DBcDK9To-wVS228RsDDPmOPxlIbVnQbZINfIK2TP0,4150
+logger_36/catalog/handler/console_rich.py,sha256=pI0OE0c5I19-ycvOJjdG5vdtDXTZadNNRbKCJD-2oL4,8347
+logger_36/catalog/handler/file.py,sha256=2qbsI3UHxqEm9WiCMkAm20hA2qXth2wKnakazVbwrBs,4613
+logger_36/catalog/handler/generic.py,sha256=y-f6HY5xppoHYYnej0qOQT3BI0Gam_0W1_bIHCk5nn0,9212
 logger_36/catalog/logger/chronos.py,sha256=ocY13f98EfknU7wZCv0FS9Xb7pTNaWCPSusXFIEvEd4,2437
 logger_36/catalog/logger/gpu.py,sha256=lzrkqrMnXsszRB_TiHFqnNNI7JhNat8qL2OSlnHDe5c,3412
 logger_36/catalog/logger/memory.py,sha256=CWhr2J4BqArJxzH6tS-ZThr-rYPAQGtuLn0pP7Iryfg,4685
@@ -31,6 +31,7 @@ logger_36/constant/issue.py,sha256=01l8itRPWGS5F6gXtsXUJgGR-4lS1Eu3_YeKC-khKLw,2
 logger_36/constant/logger.py,sha256=2qRkteblpbHrq9x0aiw9MPquyXrSRd6_yMQnPEhFp2U,2468
 logger_36/constant/memory.py,sha256=ZL1MwbdtNsrCrOwzEyfTsfOoOsRBTJtbbf3otHGnxXo,2343
 logger_36/constant/message.py,sha256=Ys_CAyhENlT8Z3rr-AxO4hjdl1jLsKzVSPQ8wqLOCPQ,2838
+logger_36/constant/path.py,sha256=fKJn2vGj012BU5DFRetDFus_tKMty2q_WL0J2KrXdCo,2731
 logger_36/constant/record.py,sha256=9Q28lVH_s0og4v74delgwIPAJ9G28I5rBM-brXcoY80,2308
 logger_36/constant/system.py,sha256=G2mzBTxRXoJMxb53TnmBaceMJC_q3WonoCG7y6nC_R8,2430
 logger_36/instance/logger.py,sha256=oTw5svRzKRJKvGrrZUtutJIOjp5UISft3fl0Ze7DOBE,2241
@@ -42,11 +43,11 @@ logger_36/task/format/message.py,sha256=T2V2gUlUQqSojyRrz4I4uAHwNe6eBEsuAe6V-LTy
 logger_36/task/format/rule.py,sha256=vkf-HivFb4VqV2GeOPVqMAp99krtziI-kXhox3UVnzw,2873
 logger_36/task/measure/chronos.py,sha256=1kVhu6jZlNAtNWQQh8ZVuRwZIAC9gGz3_ul1tn0t4Yw,3055
 logger_36/task/measure/memory.py,sha256=OjU5EYFH8SnzlCQKAoiXvauUlwQYOrH34jFXTVYF0jE,2517
-logger_36/type/handler.py,sha256=7M8f8U-zedzo-1AR7iIxHnzRHsuDj9IM0WtrqG2GMY0,6902
+logger_36/type/handler.py,sha256=-myl7uBMOzkwCs1u4ehuYlQa9F6909jmnL2v_eQN5ag,6819
 logger_36/type/issue.py,sha256=2rGsFqaQJCbeml9xN08mN_nK79L8qscaS_0ws36Y0bI,3214
-logger_36/type/logger.py,sha256=4cCa-u1ktDdlj96aOWz6OsDJ_WhuN7eKEEALIHDS9NY,20451
+logger_36/type/logger.py,sha256=nGNWJ5xcyA79E45qcZ-gZ3ZuY7j1aDg5NXk7VwbQVFU,22287
 logger_36/type/loggers.py,sha256=znqxWBnfQxvkg3VUfbTUvt3S6Kq0DAzWWepxQDt9suI,2871
-logger_36-2025.6.dist-info/METADATA,sha256=AQ37dDMn1ZG7E3X5x29OR4_GaeG_FWcVkjew0B9hbzw,6505
-logger_36-2025.6.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-logger_36-2025.6.dist-info/top_level.txt,sha256=sM95BTMWmslEEgR_1pzwZsOeSp8C_QBiu8ImbFr0XLc,10
-logger_36-2025.6.dist-info/RECORD,,
+logger_36-2025.7.dist-info/METADATA,sha256=E708bS17nu3wkJZ7YTNfvezYSBUbfwXgUCwiiXwOkf0,6505
+logger_36-2025.7.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+logger_36-2025.7.dist-info/top_level.txt,sha256=sM95BTMWmslEEgR_1pzwZsOeSp8C_QBiu8ImbFr0XLc,10
+logger_36-2025.7.dist-info/RECORD,,