logger-36 2025.19__py3-none-any.whl → 2025.21__py3-none-any.whl

logger_36/type/handler.py

@@ -82,8 +82,6 @@ class extension_t:
         if when_or_elapsed is None:
             return message, True
 
-        level_first_letter = getattr(record, "level_first_letter", "")
-
         if (where := getattr(record, "where", None)) is None:
             where = ""
         else:
@@ -91,7 +89,7 @@ class extension_t:
 
         return (
             f"{when_or_elapsed}"
-            f"{LEVEL_OPENING}{level_first_letter}{LEVEL_CLOSING} "
+            f"{LEVEL_OPENING}{record.levelname[0]}{LEVEL_CLOSING} "
             f"{MESSAGE_MARKER} {message}{where}"
         ), True
 

logger_36/type/logger.py

@@ -38,12 +38,6 @@ from logger_36.constant.memory import UNKNOWN_MEMORY_USAGE
 from logger_36.constant.message import LINE_INDENT, TIME_LENGTH_m_1, expected_op_h
 from logger_36.constant.path import PROJECT_FILE_RELATIVE, USER_FOLDER
 from logger_36.constant.record import SHOW_W_RULE_ATTR, SHOW_WHERE_ATTR
-from logger_36.constant.rule import (
-    DEFAULT_RULE,
-    DEFAULT_RULE_LENGTH,
-    MIN_HALF_RULE_LENGTH,
-    RULE_CHARACTER,
-)
 from logger_36.task.format.message import MessageWithActualExpected
 from logger_36.task.measure.chronos import ElapsedTime
 from logger_36.task.measure.memory import CanCheckUsage as CanCheckMemoryUsage
@@ -76,12 +70,12 @@ class logger_t(base_t):
     intercepted_wrn_handle: When warning interception is on, this stores the original
         "handle" method of the Python warning logger.
 
-    _should_activate_log_interceptions: Loggers instantiated after a logger_t logger will
-    be missed by an early call of ToggleLogInterceptions. Therefore, passing True for
-    activate_log_interceptions only sets _should_activate_log_interceptions to True,
+    _should_activate_log_interceptions: Loggers instantiated after a logger_t logger
+    will be missed by an early call of ToggleLogInterceptions. Therefore, passing True
+    for activate_log_interceptions only sets _should_activate_log_interceptions to True,
     which is later checked in AddHandler to effectively call ToggleLogInterceptions if
-    _should_hold_messages is False (which normally indicates that the handler about to be
-    added is the last one).
+    _should_hold_messages is False (which normally indicates that the handler about to
+    be added is the last one).
 
     _should_hold_messages: Must not be False until at least one handler has been added.
     """
@@ -171,9 +165,17 @@ class logger_t(base_t):
         self.setLevel(level_)
         self.propagate = False  # Part of base_t.
 
+        if self.exit_on_error:
+            self.exit_on_critical = True
+
         for level_id in l.getLevelNamesMapping().values():
             self.events[level_id] = 0
 
+        if self.should_record_messages:
+            self.ActivateMessageRecording()
+
+        self.info(f'New logger "{self.name}" for "{PROJECT_FILE_RELATIVE}"')
+
         if activate_wrn_interceptions:
             self.ToggleWarningInterceptions(True)
         if activate_log_interceptions:
@@ -181,57 +183,18 @@ class logger_t(base_t):
         if activate_exc_interceptions:
             self.ToggleExceptionInterceptions(True)
 
-        if self.exit_on_error:
-            self.exit_on_critical = True
-
-        if self.should_record_messages:
-            self.ActivateMessageRecording()
-
         if self.should_watch_memory_usage and not CanCheckMemoryUsage():
             self.should_watch_memory_usage = False
             if _MEMORY_MEASURE_ERROR is not None:
                 s.__stderr__.write(_MEMORY_MEASURE_ERROR + "\n")
                 _MEMORY_MEASURE_ERROR = None
 
-        self.info(f'New logger "{self.name}" for "{PROJECT_FILE_RELATIVE}"')
-
     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:
-                if self.should_record_messages:
-                    self.recorded.append(
-                        (
-                            held.levelno,
-                            self._recording_handler.MessageFromRecord(held)[0],
-                        )
-                    )
-                base_t.handle(self, held)
-            self._on_hold.clear()
-
         if (date := now.date()) != self.last_message_date:
-            self.last_message_date = date
-            date_record = l.makeLogRecord(
-                {
-                    "name": self.name,
-                    "levelno": l.INFO,  # For management by logging.Logger.handle.
-                    "msg": f"DATE: {date.strftime(DATE_FORMAT)}",
-                    SHOW_W_RULE_ATTR: True,
-                }
-            )
-            if self._should_hold_messages:
-                self._on_hold.append(date_record)
-            else:
-                if self.should_record_messages:
-                    self.recorded.append(
-                        (
-                            date_record.levelno,
-                            self._recording_handler.MessageFromRecord(date_record)[0],
-                        )
-                    )
-                base_t.handle(self, date_record)
+            self._AcknowledgeDateChange(date)
 
         # When.
         if now - self.last_message_now > LONG_ENOUGH:
@@ -259,9 +222,6 @@ class logger_t(base_t):
         else:
             where = None
 
-        # How.
-        record.level_first_letter = record.levelname[0]
-
         # What.
         if not isinstance(record.msg, str):
             record.msg = str(record.msg)
@@ -269,14 +229,11 @@ class logger_t(base_t):
         if self._should_hold_messages:
             self._on_hold.append(record)
         else:
-            if self.should_record_messages:
-                self.recorded.append(
-                    (
-                        record.levelno,
-                        self._recording_handler.MessageFromRecord(record)[0],
-                    )
-                )
-            base_t.handle(self, record)
+            self._HandleRecord(record)
+        self.events[record.levelno] += 1
+
+        if self.should_watch_memory_usage:
+            self.memory_usages.append((where, CurrentMemoryUsage()))
 
         if (self.exit_on_critical and (record.levelno is l.CRITICAL)) or (
             self.exit_on_error and (record.levelno is l.ERROR)
@@ -285,35 +242,44 @@ class logger_t(base_t):
             # __post_init__ set self.exit_on_critical if self.exit_on_error.
             s.exit(1)
 
-        self.events[record.levelno] += 1
+    def _FlushRecordsOnHold(self) -> None:
+        """"""
+        for held in self._on_hold:
+            self._HandleRecord(held)
 
-        if self.should_watch_memory_usage:
-            self.memory_usages.append((where, CurrentMemoryUsage()))
+        self._on_hold.clear()
 
-    def ActivateMessageRecording(self) -> None:
+    def _AcknowledgeDateChange(self, date: date_t, /) -> None:
         """"""
-        if self._recording_handler is None:
-            self._recording_handler = handler_extension_t("recording_handler", 0, None)
-            self.should_record_messages = True  # Useless if called from __post_init__.
+        self.last_message_date = date
+
+        record = l.makeLogRecord(
+            {
+                "name": self.name,
+                "levelno": l.INFO,  # For management by logging.Logger.handle.
+                "msg": f"DATE: {date.strftime(DATE_FORMAT)}",
+                SHOW_W_RULE_ATTR: True,
+            }
+        )
 
-    def MakeMonochrome(self) -> None:
-        """"""
-        self.AddHandler(console_handler_t)
+        if self._should_hold_messages:
+            self._on_hold.append(record)
+        else:
+            self._HandleRecord(record)
 
-    def MakeRich(self, *, alternating_logs: int = 0) -> None:
+    def _HandleRecord(self, record: l.LogRecord, /) -> None:
         """"""
-        if MISSING_RICH_MESSAGE is not None:
-            s.__stderr__.write(MISSING_RICH_MESSAGE + "\n")
+        if self.should_record_messages:
+            message = self._recording_handler.MessageFromRecord(record)[0]
+            self.recorded.append((record.levelno, message))
 
-        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)
+        base_t.handle(self, record)
 
-    def MakePermanent(self, path: str | path_t, /) -> None:
+    def ActivateMessageRecording(self) -> None:
         """"""
-        self.AddHandler(file_handler_t, path=path)
+        self._recording_handler = handler_extension_t("recording_handler", 0, None)
+        self.should_record_messages = True  # Useless if called from __post_init__.
+        self.info(f'Message recording activated for logger "{self.name}"')
 
     def ResetEventCounts(self) -> None:
         """"""
@@ -395,18 +361,6 @@ class logger_t(base_t):
             self.intercepts_exceptions = False
             self.info("Exception Interception: OFF")
 
-    def DealWithException(self, _, exc_value, exc_traceback, /) -> None:
-        """"""
-        exception = exc_value.with_traceback(exc_traceback)
-        self.LogException(exception, level=l.CRITICAL)
-        s.exit(1)
-
-    def DealWithExceptionInThread(
-        self, exc_type, exc_value, exc_traceback, _, /
-    ) -> None:
-        """"""
-        self.DealWithException(exc_type, exc_value, exc_traceback)
-
     def AddHandler(
         self,
         handler_t_or_handler: type[base_handler_t]
@@ -421,12 +375,19 @@ class logger_t(base_t):
         should_still_hold_messages: bool = False,
         **kwargs,
     ) -> None:
-        """"""
-        if (not should_still_hold_messages) and self._should_activate_log_interceptions:
-            self.ToggleLogInterceptions(True)
-            self._should_activate_log_interceptions = False
+        """
+        Silently ignores re-holding request after un-holding.
+        """
+        should_flush_on_hold = False
+        new_handler_warning = ""
+        if self._should_hold_messages and not should_still_hold_messages:
+            if self._should_activate_log_interceptions:
+                self.ToggleLogInterceptions(True)
+                self._should_activate_log_interceptions = False
 
-        self._should_hold_messages = should_still_hold_messages
+            self._should_hold_messages = False
+            should_flush_on_hold = True
+            new_handler_warning = "\n(Handlers added from now on will miss above logs.)"
 
         if isinstance(handler_t_or_handler, type):
             handler = handler_t_or_handler.New(
@@ -436,14 +397,38 @@ class logger_t(base_t):
             handler = handler_t_or_handler
         base_t.addHandler(self, handler)
 
+        # Wait until after the handler has been added to flush messages on hold.
+        if should_flush_on_hold:
+            self._FlushRecordsOnHold()
+
         path = getattr(handler, "baseFilename", "")
         if isinstance(path, path_t) or (path.__len__() > 0):
             path = f"\nPath: {path}"
         self.info(
             f'New handler "{handler.name}" of type "{type(handler).__name__}" and '
             f"level {handler.level}={l.getLevelName(handler.level)}{path}"
+            f"{new_handler_warning}"
         )
 
+    def MakeMonochrome(self) -> None:
+        """"""
+        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")
+
+        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:
+        """"""
+        self.AddHandler(file_handler_t, path=path)
+
     def __call__(self, *args, **kwargs) -> None:
         """
         For a print-like calling for print-based debugging.
@@ -506,6 +491,18 @@ class logger_t(base_t):
             message = f"Exception of type {type(exception).__name__}\n----\n{formatted}"
         self.log(level, message, extra={SHOW_WHERE_ATTR: False})
 
+    def DealWithException(self, _, exc_value, exc_traceback, /) -> None:
+        """"""
+        exception = exc_value.with_traceback(exc_traceback)
+        self.LogException(exception, level=l.CRITICAL)
+        s.exit(1)
+
+    def DealWithExceptionInThread(
+        self, exc_type, exc_value, exc_traceback, _, /
+    ) -> None:
+        """"""
+        self.DealWithException(exc_type, exc_value, exc_traceback)
+
     def LogAsIs(self, message: str, /, *, indented: bool = False) -> None:
         """"""
         if indented:

logger_36/version.py

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

{logger_36-2025.19.dist-info → logger_36-2025.21.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: logger-36
-Version: 2025.19
+Version: 2025.21
 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.19.dist-info → logger_36-2025.21.dist-info}/RECORD

@@ -1,5 +1,5 @@
 logger_36/__init__.py,sha256=mK6AD0eWI2Sk42oxleTvsxzYJ28FbHK5WNkpLgAhnNE,2129
-logger_36/version.py,sha256=DefgP6TAlC9ZItUKr6xILYjfpSID0x0a7pe5gfQoQ1s,1680
+logger_36/version.py,sha256=uq-1uJ3Ttvm7hNAwg0S3T103Mh6UIamgGGIWFao8YLI,1680
 logger_36/api/content.py,sha256=DuT4UX4r_1DTXzuuRD-tvsTZk5X-Nj11loBKhuWOMw0,1791
 logger_36/api/gpu.py,sha256=NNs1IvQ7bh8Dppm8O8K2YLWbm4rogc3Ie_-D6xzkX3g,1726
 logger_36/api/memory.py,sha256=vOY4cTTrC3u7L0OrKXdPNlsCahYjCrY4h7iqpGZv9kU,2217
@@ -42,11 +42,11 @@ logger_36/task/format/memory.py,sha256=J1Oy3jw8wjSp2kuiRUm_VFpzXOHX2FOc7nuRrCyrs
 logger_36/task/format/message.py,sha256=Rm6zymVEEGcgKfmxMPXP7q3PtwZJKlXGhqZ5tnvlwxA,3502
 logger_36/task/measure/chronos.py,sha256=7ijMZgP4EP18HbLV2yCxpNpRS9724Wyk523f-nkbhUM,2529
 logger_36/task/measure/memory.py,sha256=kkPHEIUTUhkCOLrAt01eLJLnsnkl0nFPNhFZdIB_JAw,1991
-logger_36/type/handler.py,sha256=LmdiBI1NLzpgI_Mzr6nVBsj9Nu_5iZFGKNKTqGAmdSM,6673
+logger_36/type/handler.py,sha256=ChxP1j9PXLmoiNcsOdxI4bYVdr75v7HeCWp_iYJ2WNY,6602
 logger_36/type/issue.py,sha256=QHAYf7QgrjJUtF2D46z6X630qTgeP_0FE5hIwf54RsE,2688
-logger_36/type/logger.py,sha256=oQy5VrJor6aJYH3KMIRMpbWx9YoR9oWFeSZWYzle2n4,26041
+logger_36/type/logger.py,sha256=-cEc56RRpYkXaoDjI7PF7q14Mamdc4zu3DmQ-lRjIn8,25823
 logger_36/type/loggers.py,sha256=7EX7Sg_RlduBjdfFlNZmUfNeDloH1xU30Rdkg_-rXh8,3172
-logger_36-2025.19.dist-info/METADATA,sha256=o3JDxhFujB13yngrFl9lTrpRoSvLYMev6u9pY06nB_E,6529
-logger_36-2025.19.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-logger_36-2025.19.dist-info/top_level.txt,sha256=sM95BTMWmslEEgR_1pzwZsOeSp8C_QBiu8ImbFr0XLc,10
-logger_36-2025.19.dist-info/RECORD,,
+logger_36-2025.21.dist-info/METADATA,sha256=bTX5e3Xn8lko_GnzpFd7XnE60aNUv6V_9JyoLwzE2G4,6529
+logger_36-2025.21.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+logger_36-2025.21.dist-info/top_level.txt,sha256=sM95BTMWmslEEgR_1pzwZsOeSp8C_QBiu8ImbFr0XLc,10
+logger_36-2025.21.dist-info/RECORD,,