logger-36 2025.22__py3-none-any.whl → 2025.23__py3-none-any.whl

logger_36/catalog/handler/memory.py

@@ -0,0 +1,98 @@
+"""
+Copyright CNRS (https://www.cnrs.fr/index.php/en)
+Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2023
+SEE COPYRIGHT NOTICE BELOW
+"""
+
+import json
+import logging as l
+import typing as h
+
+from logger_36.type.handler import handler_t as base_t
+
+formats_h = h.Literal["json", "message", "raw"]
+
+
+class memory_handler_t(base_t):
+    def __init__(
+        self, name: str | None, message_width: int, level: int, format_: formats_h
+    ) -> None:
+        """"""
+        assert format_ in h.get_args(formats_h)
+
+        base_t.__init__(self, name, message_width, None, level)
+
+        self.format_ = format_
+        self.records = []
+
+    @classmethod
+    def New(
+        cls,
+        /,
+        *,
+        name: str | None = None,
+        message_width: int = -1,
+        level: int = l.NOTSET,
+        format_: formats_h = "message",
+        **_,
+    ) -> h.Self:
+        """"""
+        return cls(name, message_width, level, format_)
+
+    def emit(self, record: l.LogRecord, /) -> None:
+        """"""
+        level = record.levelno
+
+        if self.format_ == "raw":
+            is_not_a_rule = True
+        elif self.format_ == "message":
+            record, is_not_a_rule = self.MessageFromRecord(record)
+        else:
+            record = json.dumps(record.__dict__)
+            is_not_a_rule = True
+
+        self.records.append((level, record, is_not_a_rule))
+
+    def EmitMessage(self, message: str, /) -> None:
+        """"""
+        if self.format_ == "message":
+            message_key = "msg"
+        else:
+            message_key = "message"
+        record = l.makeLogRecord(
+            {"name": "<UNKNOWN LOGGER>", "levelno": l.INFO, message_key: message}
+        )
+        self.emit(record)
+
+
+"""
+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.
+"""

logger_36/constant/record.py

@@ -4,7 +4,6 @@ Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2023
 SEE COPYRIGHT NOTICE BELOW
 """
 
-INTERNAL_INFO_ATTR = "internal_info"
 SHOW_WHERE_ATTR = "should_show_where"
 SHOW_W_RULE_ATTR = "should_show_w_rule"
 WHEN_OR_ELAPSED_ATTR = "when_or_elapsed"

logger_36/task/storage.py

@@ -10,25 +10,28 @@ from pathlib import Path as path_t
 
 from logger_36.constant.html import BODY_PLACEHOLDER, MINIMAL_HTML, TITLE_PLACEHOLDER
 from logger_36.instance.logger import L
+from logger_36.type.logger import logger_t
 
 
-def SaveLOGasHTML(path: str | path_t | io_base_t | None = None) -> None:
+def SaveLOGasHTML(
+    path: str | path_t | io_base_t | None = None, /, *, logger: logger_t = L
+) -> None:
     """
     From first console handler found.
     """
     cannot_save = "Cannot save logging record as HTML"
 
     if path is None:
-        for handler in L.handlers:
+        for handler in logger.handlers:
             if isinstance(handler, l.FileHandler):
                 path = path_t(handler.baseFilename).with_suffix(".htm")
                 break
         else:
-            L.warning(f"{cannot_save}: No file handler to build a filename from.")
+            logger.warning(f"{cannot_save}: No file handler to build a filename from.")
             return
 
         if path.exists():
-            L.warning(
+            logger.warning(
                 f'{cannot_save}: Automatically generated path "{path}" already exists.'
             )
             return
@@ -38,13 +41,38 @@ def SaveLOGasHTML(path: str | path_t | io_base_t | None = None) -> None:
     actual_file = isinstance(path, path_t)
 
     if actual_file and path.exists():
-        L.warning(f'{cannot_save}: File "{path}" already exists.')
+        logger.warning(f'{cannot_save}: File "{path}" already exists.')
         return
 
-    body = "\n".join(map(_HighlightedEvent, L.recorded))
-    html = MINIMAL_HTML.replace(TITLE_PLACEHOLDER, L.name).replace(
+    for handler in logger.handlers:
+        records = getattr(handler, "records", None)
+        if isinstance(records, list) and (
+            (records.__len__() == 0)
+            or all(
+                isinstance(_, tuple)
+                and isinstance(_[0], int)
+                and isinstance(_[1], dict | str | l.LogRecord)
+                and isinstance(_[2], bool)
+                for _ in records
+            )
+        ):
+            break
+    else:
+        logger.warning(f"{cannot_save}: No handlers with recording capability found.")
+        return
+
+    if records.__len__() == 0:
+        return
+
+    if isinstance(records[0][1], str):
+        records = map(_HighlightedEvent, records)
+    else:
+        records = map(lambda _: str(_[1]), records)
+    body = "\n".join(records)
+    html = MINIMAL_HTML.replace(TITLE_PLACEHOLDER, logger.name).replace(
         BODY_PLACEHOLDER, body
     )
+
     if actual_file:
         with open(path, "w") as accessor:
             accessor.write(html)
@@ -52,21 +80,25 @@ def SaveLOGasHTML(path: str | path_t | io_base_t | None = None) -> None:
         path.write(html)
 
 
-def _HighlightedEvent(event: tuple[int, str], /) -> str:
+def _HighlightedEvent(event: tuple[int, str, bool], /) -> str:
     """"""
-    level, message = event
-    if level == l.DEBUG:
-        color = "BlueViolet"
-    elif level == l.INFO:
-        color = "black"
-    elif level == l.WARNING:
-        color = "gold"
-    elif level == l.ERROR:
-        color = "orange"
-    elif level == l.CRITICAL:
-        color = "red"
+    level, message, is_not_a_rule = event
+
+    if is_not_a_rule:
+        if level == l.DEBUG:
+            color = "BlueViolet"
+        elif level == l.INFO:
+            color = "black"
+        elif level == l.WARNING:
+            color = "gold"
+        elif level == l.ERROR:
+            color = "orange"
+        elif level == l.CRITICAL:
+            color = "red"
+        else:
+            color = "black"
     else:
-        color = "black"
+        color = "DarkTurquoise"
 
     return f'<span style="color:{color}">{message}</span>'
 

logger_36/type/logger.py

@@ -41,11 +41,7 @@ from logger_36.constant.logger import WARNING_LOGGER_NAME, WARNING_TYPE_COMPILED
 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 (
-    INTERNAL_INFO_ATTR,
-    SHOW_W_RULE_ATTR,
-    SHOW_WHERE_ATTR,
-)
+from logger_36.constant.record import SHOW_W_RULE_ATTR, SHOW_WHERE_ATTR
 from logger_36.task.format.message import MessageWithActualExpected
 from logger_36.task.measure.chronos import ElapsedTime
 from logger_36.task.measure.memory import CurrentUsage as CurrentMemoryUsage
@@ -79,21 +75,15 @@ class logger_t(base_t):
     _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
-    _warming_up is False (which normally indicates that the handler about to
-    be added is the last one).
-
-    _warming_up: Must not be False until at least one handler has been added.
+    which is later checked in AddHandler to effectively call ToggleLogInterceptions.
     """
 
-    should_record_messages: bool = False
-    should_monitor_memory_usage: bool = False
     exit_on_error: bool = False  # Implies exit_on_critical.
     exit_on_critical: bool = False
-    verbose: bool = False
+    should_monitor_memory_usage: bool = False
 
-    events: dict[int, int] = d.field(init=False, default_factory=dict)
-    recorded: list[tuple[int, str]] = d.field(init=False, default_factory=list)
+    history: dict[date_time_t, str] = d.field(init=False, default_factory=dict)
+    n_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)
@@ -105,12 +95,9 @@ class logger_t(base_t):
         init=False, default_factory=dict
     )
     intercepts_exceptions: bool = d.field(init=False, default=False)
-    _recording_handler: handler_extension_t | None = d.field(init=False, default=None)
 
     # Used only until the last handler is added (see AddHandler).
     _should_activate_log_interceptions: bool = d.field(init=False, default=False)
-    _warming_up: bool = d.field(init=False, default=True)
-    _on_hold: list[l.LogRecord] | None = d.field(init=False, default_factory=list)
 
     name_: d.InitVar[str | None] = None
     level_: d.InitVar[int] = l.NOTSET
@@ -168,7 +155,6 @@ class logger_t(base_t):
         if name_ is None:
             name_ = f"{type(self).__name__}:{hex(id(self))[2:]}"
 
-        self.handle = self._HandleWarmUp
         base_t.__init__(self, name_)
         self.setLevel(level_)
         self.propagate = False  # Part of base_t.
@@ -177,15 +163,7 @@ class logger_t(base_t):
             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}"',
-            extra={INTERNAL_INFO_ATTR: True},
-        )
+            self.n_events[level_id] = 0
 
         if activate_wrn_interceptions:
             self.ToggleWarningInterceptions(True)
@@ -197,29 +175,12 @@ class logger_t(base_t):
         if self.should_monitor_memory_usage:
             self.ActivateMemoryUsageMonitoring()
 
-    def _HandleWarmUp(self, record: l.LogRecord, /) -> None:
-        """"""
-        now = ElapsedTime(should_return_now=True)[1]
-        if (date := now.date()) != self.last_message_date:
-            self._AcknowledgeDateChange(date)
-
-        # When.
-        record.when_or_elapsed = (TIME_LENGTH_m_1 + 1) * "."
-        # Where.
-        if record.levelno != l.INFO:
-            _ = _RecordLocation(record, True)
-        # What.
-        if not isinstance(record.msg, str):
-            record.msg = str(record.msg)
-
-        self._on_hold.append(record)
+        self.history[date_time_t.now()] = (
+            f'Logger "{self.name}" instantiation for "{PROJECT_FILE_RELATIVE}"'
+        )
 
-    def _HandleRoutine(self, record: l.LogRecord, /) -> None:
+    def handle(self, record: l.LogRecord, /) -> None:
         """"""
-        is_internal_info = getattr(record, INTERNAL_INFO_ATTR, False)
-        if is_internal_info and not self.verbose:
-            return
-
         elapsed_time, now = ElapsedTime(should_return_now=True)
 
         if (date := now.date()) != self.last_message_date:
@@ -244,7 +205,8 @@ class logger_t(base_t):
         if not isinstance(record.msg, str):
             record.msg = str(record.msg)
 
-        self._HandleRaw(record)
+        base_t.handle(self, record)
+        self.n_events[record.levelno] += 1
 
         if self.should_monitor_memory_usage:
             self.memory_usages.append((where, CurrentMemoryUsage()))
@@ -256,29 +218,6 @@ class logger_t(base_t):
             # __post_init__ set self.exit_on_critical if self.exit_on_error.
             s.exit(1)
 
-    def _HandleRaw(self, record: l.LogRecord, /) -> None:
-        """"""
-        if self.should_record_messages:
-            message = self._recording_handler.MessageFromRecord(record)[0]
-            self.recorded.append((record.levelno, message))
-
-        base_t.handle(self, record)
-        self.events[record.levelno] += 1
-
-    def _FlushRecordsOnHold(self) -> None:
-        """
-        should_record_messages and verbose must have been set by now.
-        """
-        for held in self._on_hold:
-            if self.verbose or not getattr(held, INTERNAL_INFO_ATTR, False):
-                self._HandleRaw(held)
-
-        self._on_hold.clear()
-        self._on_hold = None
-        self._warming_up = False
-
-        self.handle = self._HandleRoutine
-
     def _AcknowledgeDateChange(self, date: date_t, /) -> None:
         """"""
         self.last_message_date = date
@@ -291,38 +230,12 @@ class logger_t(base_t):
                 SHOW_W_RULE_ATTR: True,
             }
         )
-
-        if self._warming_up:
-            self._on_hold.append(record)
-        else:
-            self._HandleRaw(record)
-
-    def ActivateMessageRecording(self) -> None:
-        """"""
-        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}"',
-            extra={INTERNAL_INFO_ATTR: True},
-        )
-
-    def ActivateMemoryUsageMonitoring(self) -> None:
-        """"""
-        if MEMORY_MEASURE_IS_AVAILABLE:
-            # Useless if called from __post_init__.
-            self.should_monitor_memory_usage = True
-            self.info(
-                f'Memory usage monitoring activated for logger "{self.name}"',
-                extra={INTERNAL_INFO_ATTR: True},
-            )
-        else:
-            self.should_monitor_memory_usage = False
-            self.error(MEMORY_MEASURE_ERROR)
+        base_t.handle(self, record)
 
     def ResetEventCounts(self) -> None:
         """"""
-        for level_id in self.events:
-            self.events[level_id] = 0
+        for level_id in self.n_events:
+            self.n_events[level_id] = 0
 
     def ToggleWarningInterceptions(self, state: bool, /) -> None:
         """"""
@@ -335,7 +248,7 @@ class logger_t(base_t):
             logger.handle = t.MethodType(_HandleForWarnings(self), logger)
 
             l.captureWarnings(True)
-            self.info("Warning Interception: ON", extra={INTERNAL_INFO_ATTR: True})
+            self.history[date_time_t.now()] = "Warning Interception: ON"
         else:
             if not self.intercepts_warnings:
                 return
@@ -345,12 +258,12 @@ class logger_t(base_t):
             self.intercepted_wrn_handle = None
 
             l.captureWarnings(False)
-            self.info("Warning Interception: OFF", extra={INTERNAL_INFO_ATTR: True})
+            self.history[date_time_t.now()] = "Warning Interception: OFF"
 
     def ToggleLogInterceptions(self, state: bool, /) -> None:
         """"""
         if state:
-            if self.intercepts_logs:
+            if self._should_activate_log_interceptions or self.intercepts_logs:
                 return
 
             # Note: Alternative to self.manager is logging.root.manager.
@@ -369,11 +282,14 @@ class logger_t(base_t):
             intercepted = sorted(self.intercepted_log_handles.keys())
             if intercepted.__len__() > 0:
                 as_str = ", ".join(intercepted)
-                self.info(
-                    f"Now Intercepting LOGs from: {as_str}",
-                    extra={INTERNAL_INFO_ATTR: True},
+                self.history[date_time_t.now()] = (
+                    f"Now Intercepting LOGs from: {as_str}"
                 )
         else:
+            if self._should_activate_log_interceptions:
+                self._should_activate_log_interceptions = False
+                return
+
             if not self.intercepts_logs:
                 return
 
@@ -381,7 +297,7 @@ class logger_t(base_t):
                 logger = l.getLogger(name)
                 logger.handle = handle
             self.intercepted_log_handles.clear()
-            self.info("Log Interception: OFF", extra={INTERNAL_INFO_ATTR: True})
+            self.history[date_time_t.now()] = "Log Interception: OFF"
 
     def ToggleExceptionInterceptions(self, state: bool, /) -> None:
         """"""
@@ -392,7 +308,7 @@ class logger_t(base_t):
             s.excepthook = self.DealWithException
             thrd.excepthook = self.DealWithExceptionInThread
             self.intercepts_exceptions = True
-            self.info("Exception Interception: ON", extra={INTERNAL_INFO_ATTR: True})
+            self.history[date_time_t.now()] = "Exception Interception: ON"
         else:
             if not self.intercepts_exceptions:
                 return
@@ -400,7 +316,19 @@ class logger_t(base_t):
             s.excepthook = s.__excepthook__
             thrd.excepthook = thrd.__excepthook__
             self.intercepts_exceptions = False
-            self.info("Exception Interception: OFF", extra={INTERNAL_INFO_ATTR: True})
+            self.history[date_time_t.now()] = "Exception Interception: OFF"
+
+    def ActivateMemoryUsageMonitoring(self) -> None:
+        """"""
+        if MEMORY_MEASURE_IS_AVAILABLE:
+            # Useless if called from __post_init__.
+            self.should_monitor_memory_usage = True
+            self.history[date_time_t.now()] = (
+                f'Memory usage monitoring activated for logger "{self.name}"'
+            )
+        else:
+            self.should_monitor_memory_usage = False
+            self.error(MEMORY_MEASURE_ERROR)
 
     def AddHandler(
         self,
@@ -413,21 +341,16 @@ class logger_t(base_t):
         name: str | None = None,
         level: int = l.INFO,
         message_width: int = -1,
-        this_is_last_handler: bool = True,
         **kwargs,
     ) -> None:
         """
         Silently ignores re-holding request after un-holding.
         """
-        should_flush_on_hold = False
-        new_handler_warning = ""
-        if self._warming_up and this_is_last_handler:
-            if self._should_activate_log_interceptions:
-                self.ToggleLogInterceptions(True)
-                self._should_activate_log_interceptions = False
-
-            should_flush_on_hold = True
-            new_handler_warning = "\n(Handlers added from now on will miss above logs.)"
+        if self._should_activate_log_interceptions:
+            # Turn _should_activate_log_interceptions off before calling
+            # ToggleLogInterceptions because it checks it.
+            self._should_activate_log_interceptions = False
+            self.ToggleLogInterceptions(True)
 
         if isinstance(handler_t_or_handler, type):
             handler = handler_t_or_handler.New(
@@ -437,20 +360,13 @@ class logger_t(base_t):
             handler = handler_t_or_handler
         base_t.addHandler(self, handler)
 
-        if self.verbose:
-            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}",
-                extra={INTERNAL_INFO_ATTR: True},
-            )
-
-        # 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.history[date_time_t.now()] = (
+            f'New handler "{handler.name}" of type "{type(handler).__name__}" and '
+            f"level {handler.level}={l.getLevelName(handler.level)}{path}"
+        )
 
     def MakeMonochrome(self) -> None:
         """"""

logger_36/version.py

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

{logger_36-2025.22.dist-info → logger_36-2025.23.dist-info}/METADATA

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

@@ -1,5 +1,5 @@
 logger_36/__init__.py,sha256=mK6AD0eWI2Sk42oxleTvsxzYJ28FbHK5WNkpLgAhnNE,2129
-logger_36/version.py,sha256=WM8W-3pzA_JWd1DQWpdL-uJTAxV5u8_nbyWIlGaizjg,1680
+logger_36/version.py,sha256=3y8_8Te0bVUofCcWg9yoGDEx2HlTct92Ol2Pk3NTA8w,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
@@ -13,6 +13,7 @@ logger_36/catalog/handler/console.py,sha256=YEQN8fw7ra9w-5sJACNC4pktv9einm5ASP9T
 logger_36/catalog/handler/console_rich.py,sha256=gPpq8ij1ZFTXaLgISaCTXDDwv7uWPivLeq2ttpiuKlk,6190
 logger_36/catalog/handler/file.py,sha256=yg8GnsV6AmDsx1R5iZlsK-5idqD733gc09Syl02TG7Y,2458
 logger_36/catalog/handler/generic.py,sha256=L8mLc-iQlBWKBqEN3-wIKy2yk_TVgqIWYn_P1hXDsQA,6361
+logger_36/catalog/handler/memory.py,sha256=-31hTXgGImC6if4wJF6eegvwYhsYAQsDTkdoXIUxZB8,3224
 logger_36/catalog/logger/chronos.py,sha256=S4m9TMPQy_Ju500mpE1jNzu2gZG-QKdVuvX9RVRKHR8,1911
 logger_36/catalog/logger/gpu.py,sha256=Py5YY0nD_pqJzJsEKQYoOGHcPqyNVJ3J2noOS3hDL6g,2890
 logger_36/catalog/logger/memory.py,sha256=J0ZGKO7j1FZA_aDGxpABtvzDy1RjCDiDmWYh4U98fEI,4253
@@ -29,7 +30,7 @@ logger_36/constant/logger.py,sha256=ZQYX9JiPsoivwRgYNtdEqRKCagSKD88lRqvxP8MX1ZE,
 logger_36/constant/memory.py,sha256=Q_E5tTWa-cGaNwrE_xmKa3BxQG6oJO6DHczrxc_M4sE,1817
 logger_36/constant/message.py,sha256=YJOEzdI0ZjUOdHo3CsiS56FVPhrfNoQYvXuUkprH61g,2312
 logger_36/constant/path.py,sha256=OfLh70Jyc8po9Ls34nQh_bRr3PXyQ3kF9ciR9QPhiqI,2213
-logger_36/constant/record.py,sha256=IGWnKA4TGv1oU6ezzNrGocZlB7Ie7nTr4l3IOtwdWOg,1833
+logger_36/constant/record.py,sha256=VMqGxVTbtHpRiDOsYiXEoyYOocYFm8vtcRY-7zXzJrk,1796
 logger_36/constant/rule.py,sha256=tBKQgPTt6G_p5eInDdWoEEAvQFz4WMSt5THsS5jvk14,1779
 logger_36/constant/system.py,sha256=pLlLXG5sepQlSUOo3TphaGrHg8xzJBp-GxpL2NPP47k,1904
 logger_36/extension/html_.py,sha256=W9SyiYsaaYHUrHLGAAN2wiJGXUlwOBJ5gzdjmEcnF18,3342
@@ -37,16 +38,16 @@ logger_36/extension/line.py,sha256=joeojQX1bZJM53333mOEU3s-YC5ExGOrN9Cu9Lh5-FU,2
 logger_36/instance/logger.py,sha256=X_U10RYU1h2Aa70D8hBnmFyJZtRILK16KN-GB4xkHMU,1782
 logger_36/instance/loggers.py,sha256=inBk4KKrQ-z3szaopQ29-qQwh1iSc842sWo5J6zJoiM,1725
 logger_36/task/inspection.py,sha256=ZgPcrPo3h_kEnM-UpHDLg7PAFfB2fqsLFdfmi6hlPVA,4484
-logger_36/task/storage.py,sha256=KAILmJlF5IULxEX9QRCyXCwcalp5mpunWVh1oXuLvSs,3516
+logger_36/task/storage.py,sha256=a50M628062iGEymuj5d9iKo7Ad01OXCZrEQnfNqy0gY,4486
 logger_36/task/format/memory.py,sha256=J1Oy3jw8wjSp2kuiRUm_VFpzXOHX2FOc7nuRrCyrskw,3723
 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=4LCFZzI4OEH6lVBrBQ09ZIvF0nq-_j7OOVnujBDyDWA,6665
 logger_36/type/issue.py,sha256=QHAYf7QgrjJUtF2D46z6X630qTgeP_0FE5hIwf54RsE,2688
-logger_36/type/logger.py,sha256=b2F21M5z1hwPdDsyHgBIlC06X9-_7zsjqyGEsVaIJgM,27536
+logger_36/type/logger.py,sha256=nh7EuJvdkaDrtdHPWIjot2a2hGfAzwufMWm9_2KoDXM,24645
 logger_36/type/loggers.py,sha256=7EX7Sg_RlduBjdfFlNZmUfNeDloH1xU30Rdkg_-rXh8,3172
-logger_36-2025.22.dist-info/METADATA,sha256=xcPkxJFWNYEIXgspK2VCcU4LbsME8hlmFQjASmR-3KM,6529
-logger_36-2025.22.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-logger_36-2025.22.dist-info/top_level.txt,sha256=sM95BTMWmslEEgR_1pzwZsOeSp8C_QBiu8ImbFr0XLc,10
-logger_36-2025.22.dist-info/RECORD,,
+logger_36-2025.23.dist-info/METADATA,sha256=d94bUT9zjDr1Yjny2bsSobExZ1W0MXcIv2hX_DLLGC8,6529
+logger_36-2025.23.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+logger_36-2025.23.dist-info/top_level.txt,sha256=sM95BTMWmslEEgR_1pzwZsOeSp8C_QBiu8ImbFr0XLc,10
+logger_36-2025.23.dist-info/RECORD,,