logger-36 2025.24__py3-none-any.whl → 2025.25__py3-none-any.whl

logger_36/type/handler.py

@@ -8,15 +8,14 @@ import logging as l
 import typing as h
 from pathlib import Path as path_t
 
-from logger_36.config.message import (
-    FALLBACK_MESSAGE_WIDTH,
-    LEVEL_CLOSING,
-    LEVEL_OPENING,
-    MESSAGE_MARKER,
-    WHERE_SEPARATOR,
-)
+from logger_36.config.message import FALLBACK_MESSAGE_WIDTH
 from logger_36.config.rule import DEFAULT_RULE_LENGTH, RULE_CHARACTER
-from logger_36.constant.message import NEXT_LINE_PROLOGUE
+from logger_36.constant.message import (
+    NEXT_LINE_PROLOGUE,
+    TIME_PLACEHOLDER,
+    WHERE_PROLOGUE,
+    CONTEXT_LENGTH_p_1,
+)
 from logger_36.constant.record import SHOW_W_RULE_ATTR, WHEN_OR_ELAPSED_ATTR, WHERE_ATTR
 from logger_36.constant.rule import DEFAULT_RULE, MIN_HALF_RULE_LENGTH
 from logger_36.extension.line import WrappedLines
@@ -53,41 +52,40 @@ class extension_t:
 
     def MessageFromRecord(
         self, record: l.LogRecord, /, *, rule_color: str = "black"
-    ) -> tuple[str, bool]:
+    ) -> tuple[str, bool, int | None]:
         """
-        The second returned value is is_not_a_rule.
+        Arguments from second on: is_not_a_rule, where_location.
         """
         message = record.msg  # See logger_36.catalog.handler.README.txt.
         if self.PreProcessedMessage is not None:
             message = self.PreProcessedMessage(message)
 
         if hasattr(record, SHOW_W_RULE_ATTR):
-            return self.Rule(text=message, color=rule_color), False
+            return self.Rule(text=message, color=rule_color), False, None
 
         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)
+                lines = message.splitlines()
             else:
-                lines = WrappedLines([message], self.message_width)
-            message = NEXT_LINE_PROLOGUE.join(lines)
-
-        when_or_elapsed = getattr(record, WHEN_OR_ELAPSED_ATTR, None)
-        if when_or_elapsed is None:
-            return message, True
+                lines = [message]
+            message = NEXT_LINE_PROLOGUE.join(WrappedLines(lines, self.message_width))
 
+        when_or_elapsed = getattr(record, WHEN_OR_ELAPSED_ATTR, TIME_PLACEHOLDER)
         if (where := getattr(record, WHERE_ATTR, None)) is None:
+            where_location = None
             where = ""
         else:
-            where = f"{NEXT_LINE_PROLOGUE}{WHERE_SEPARATOR} {where}"
+            where_location = CONTEXT_LENGTH_p_1 + message.__len__()
+            where = f"{WHERE_PROLOGUE}{where}"
 
         return (
-            f"{when_or_elapsed}"
-            f"{LEVEL_OPENING}{record.levelname[0]}{LEVEL_CLOSING} "
-            f"{MESSAGE_MARKER} {message}{where}"
-        ), True
+            f"{when_or_elapsed}_{record.levelname[0].lower()} {message}{where}",
+            True,
+            where_location,
+        )
 
     def Rule(self, /, *, text: str | None = None, color: str = "black") -> str | h.Any:
         """

logger_36/type/issue.py

@@ -8,9 +8,9 @@ import logging as l
 import typing as h
 
 from logger_36.config.issue import ISSUE_BASE_CONTEXT
-from logger_36.constant.generic import NOT_PASSED
 from logger_36.constant.issue import ISSUE_LEVEL_SEPARATOR
 from logger_36.constant.message import expected_op_h
+from logger_36.extension.sentinel import NOT_PASSED
 from logger_36.task.format.message import MessageWithActualExpected
 
 issue_t = str
@@ -28,11 +28,11 @@ def NewIssue(
     expected_is_choices: bool = False,
     expected_op: expected_op_h = "=",
     with_final_dot: bool = True,
-) -> issue_t:
+) -> tuple[issue_t, bool]:
     """"""
     if context.__len__() == 0:
         context = ISSUE_BASE_CONTEXT
-    message = MessageWithActualExpected(
+    message, has_actual_expected = MessageWithActualExpected(
         message,
         actual=actual,
         expected=expected,
@@ -41,7 +41,10 @@ def NewIssue(
         with_final_dot=with_final_dot,
     )
 
-    return f"{level}{ISSUE_LEVEL_SEPARATOR}{context}{separator}{message}"
+    return (
+        f"{level}{ISSUE_LEVEL_SEPARATOR}{context}{separator}{message}",
+        has_actual_expected,
+    )
 
 
 """

logger_36/type/logger.py

@@ -7,6 +7,7 @@ SEE COPYRIGHT NOTICE BELOW
 import dataclasses as d
 import inspect as e
 import logging as l
+import multiprocessing as prll
 import sys as s
 import textwrap as text
 import threading as thrd
@@ -15,6 +16,8 @@ import types as t
 import typing as h
 from datetime import date as date_t
 from datetime import datetime as date_time_t
+from logging.handlers import QueueHandler as queue_handler_t
+from logging.handlers import QueueListener as log_server_t
 from pathlib import Path as path_t
 from traceback import TracebackException as traceback_t
 
@@ -26,25 +29,32 @@ from logger_36.catalog.config.optional import (
 )
 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.memory import memory_handler_t, records_h
 from logger_36.config.issue import ISSUE_CONTEXT_END, ISSUE_CONTEXT_SEPARATOR
 from logger_36.config.message import (
     DATE_FORMAT,
-    ELAPSED_TIME_SEPARATOR,
     LONG_ENOUGH,
     TIME_FORMAT,
     WHERE_SEPARATOR,
 )
-from logger_36.constant.date_time import DATE_ORIGIN, DATE_TIME_ORIGIN
-from logger_36.constant.generic import NOT_PASSED
+from logger_36.constant.chronos import DATE_ORIGIN, DATE_TIME_ORIGIN
 from logger_36.constant.issue import ISSUE_LEVEL_SEPARATOR, ORDER, order_h
 from logger_36.constant.logger import WARNING_LOGGER_NAME, WARNING_TYPE_COMPILED_PATTERN
 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.message import LINE_INDENT, expected_op_h
 from logger_36.constant.path import USER_FOLDER, LAUNCH_ROOT_FILE_relative
-from logger_36.constant.record import SHOW_W_RULE_ATTR, SHOW_WHERE_ATTR
-from logger_36.extension.record import RecordLocation
+from logger_36.constant.record import (
+    HAS_ACTUAL_EXPECTED_ATTR,
+    SHOW_W_RULE_ATTR,
+    SHOW_WHEN_ATTR,
+    SHOW_WHERE_ATTR,
+    WHEN_OR_ELAPSED_ATTR,
+    WHERE_ATTR,
+)
+from logger_36.extension.file import NewTemporaryFile
+from logger_36.extension.sentinel import NOT_PASSED
 from logger_36.task.format.message import MessageWithActualExpected
-from logger_36.task.measure.chronos import ElapsedTime
+from logger_36.task.measure.chronos import FormattedElapsedTime
 from logger_36.task.measure.memory import CurrentUsage as CurrentMemoryUsage
 from logger_36.type.handler import extension_t as handler_extension_t
 from logger_36.type.handler import handler_h as base_handler_h
@@ -63,6 +73,8 @@ logger_handle_raw_h = h.Callable[[l.LogRecord], None]
 logger_handle_with_self_h = h.Callable[[l.Logger, l.LogRecord], None]
 logger_handle_h = logger_handle_raw_h | logger_handle_with_self_h
 
+MAIN_PROCESS_NAME = "MainProcess"
+
 
 @d.dataclass(slots=True, repr=False, eq=False)
 class logger_t(base_t):
@@ -87,7 +99,9 @@ class logger_t(base_t):
     last_message_date: date_t = d.field(init=False, default=DATE_ORIGIN)
     memory_usages: list[tuple[str, int]] = d.field(init=False, default_factory=list)
     context_levels: list[str] = d.field(init=False, default_factory=list)
-    staged_issues: list[issue_t] = d.field(init=False, default_factory=list)
+    staged_issues: list[tuple[issue_t, bool]] = d.field(
+        init=False, default_factory=list
+    )
     intercepted_wrn_handle: logger_handle_h | None = d.field(init=False, default=None)
     intercepted_log_handles: dict[str, logger_handle_h] = d.field(
         init=False, default_factory=dict
@@ -97,6 +111,8 @@ class logger_t(base_t):
     # Used only until the first handler is added (see AddHandler).
     _should_activate_log_interceptions: bool = d.field(init=False, default=False)
 
+    log_server: log_server_t | None = d.field(init=False, default=None)
+
     name_: d.InitVar[str | None] = None
     level_: d.InitVar[int] = l.NOTSET
     activate_wrn_interceptions: d.InitVar[bool] = True
@@ -109,6 +125,21 @@ class logger_t(base_t):
         FormattedEntry = lambda _: f"{_[0]}: {_[1].replace('\n', '↲ ')}"
         return "\n".join(map(FormattedEntry, self.history.items()))
 
+    @property
+    def records(self) -> records_h | None:
+        """"""
+        return logger_t.Records(self)
+
+    @staticmethod
+    def Records(logger: base_t | l.Logger, /) -> records_h | None:
+        """"""
+        for handler in logger.handlers:
+            output = getattr(handler, "records", None)
+            if memory_handler_t.AreRecords(output):
+                return output
+
+        return None
+
     @property
     def intercepts_warnings(self) -> bool:
         """"""
@@ -156,6 +187,8 @@ class logger_t(base_t):
         activate_exc_interceptions: bool,
     ) -> None:
         """"""
+        assert prll.current_process().name == MAIN_PROCESS_NAME
+
         if name_ is None:
             name_ = f"{type(self).__name__}:{hex(id(self))[2:]}"
 
@@ -185,38 +218,39 @@ class logger_t(base_t):
 
     def handle(self, record: l.LogRecord, /) -> None:
         """"""
-        elapsed_time, now = ElapsedTime(should_return_now=True)
-
+        now = date_time_t.now()
         if (date := now.date()) != self.last_message_date:
             self._AcknowledgeDateChange(date)
 
+        level = record.levelno
+
         # When.
-        if now - self.last_message_now > LONG_ENOUGH:
-            w_or_e = now.strftime(TIME_FORMAT)
-        else:
-            w_or_e = f"{ELAPSED_TIME_SEPARATOR}{elapsed_time:.<{TIME_LENGTH_m_1}}"
-        record.when_or_elapsed = w_or_e
+        if getattr(record, SHOW_WHEN_ATTR, True):
+            if now - self.last_message_now > LONG_ENOUGH:
+                w_or_e = f"{now:{TIME_FORMAT}}"
+            else:
+                w_or_e = FormattedElapsedTime(now)  # or: f"{[...]:.<{TIME_LENGTH}}".
+            setattr(record, WHEN_OR_ELAPSED_ATTR, w_or_e)
         self.last_message_now = now
 
         # Where.
-        should_show_where = getattr(record, SHOW_WHERE_ATTR, record.levelno != l.INFO)
+        should_show_where = getattr(record, SHOW_WHERE_ATTR, level != l.INFO)
         if should_show_where or self.should_monitor_memory_usage:
-            where = RecordLocation(record, should_show_where)
-        else:
-            where = None
+            where = f"{record.pathname}:{record.funcName}:{record.lineno}"
+            if should_show_where:
+                setattr(record, WHERE_ATTR, where)
+            if self.should_monitor_memory_usage:
+                self.memory_usages.append((where, CurrentMemoryUsage()))
 
         # What.
         if not isinstance(record.msg, str):
             record.msg = str(record.msg)
 
         base_t.handle(self, record)
-        self.n_events[record.levelno] += 1
+        self.n_events[level] += 1
 
-        if self.should_monitor_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)
+        if (self.exit_on_critical and (level is l.CRITICAL)) or (
+            self.exit_on_error and (level 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.
@@ -230,7 +264,7 @@ class logger_t(base_t):
             {
                 "name": self.name,
                 "levelno": l.INFO,  # For management by logging.Logger.handle.
-                "msg": f"DATE: {date.strftime(DATE_FORMAT)}",
+                "msg": f"DATE: {date:{DATE_FORMAT}}",
                 SHOW_W_RULE_ATTR: True,
             }
         )
@@ -390,6 +424,27 @@ class logger_t(base_t):
         """"""
         self.AddHandler(file_handler_t, path=path)
 
+    def MakeMultiSafe(self) -> None:
+        """
+        Should not be called until after all desired handlers have been added (as a
+        better-then-nothing check, it is checked that the logger has at least one
+        handler). If handlers are added passed this call, execution might freeze or
+        crash.
+        """
+        assert self.log_server is None
+        assert self.hasHandlers()
+
+        handlers = tuple(self.handlers)  # Making a copy is necessary.
+        for handler in handlers:
+            self.removeHandler(handler)
+
+        queue = prll.Queue()
+
+        self.addHandler(queue_handler_t(queue))
+
+        self.log_server = log_server_t(queue, *handlers)
+        self.log_server.start()
+
     def __call__(self, *args, **kwargs) -> None:
         """
         For a print-like calling for print-based debugging.
@@ -401,7 +456,7 @@ class logger_t(base_t):
         path = path_t(details.filename)
         if path.is_relative_to(USER_FOLDER):
             path = path.relative_to(USER_FOLDER)
-        where = f"{str(path.with_suffix(''))}.{details.function}.{details.lineno}"
+        where = f"{str(path.with_suffix(''))}:{details.function}:{details.lineno}"
 
         self.info(separator.join(map(str, args)) + f"\n{WHERE_SEPARATOR} " + where)
 
@@ -420,7 +475,7 @@ class logger_t(base_t):
         """"""
         if isinstance(level, str):
             level = l.getLevelNamesMapping()[level.upper()]
-        message = MessageWithActualExpected(
+        message, has_actual_expected = MessageWithActualExpected(
             message,
             actual=actual,
             expected=expected,
@@ -428,7 +483,11 @@ class logger_t(base_t):
             expected_op=expected_op,
             with_final_dot=with_final_dot,
         )
-        self.log(level, message)
+        if has_actual_expected:
+            extra = {HAS_ACTUAL_EXPECTED_ATTR: True}
+        else:
+            extra = {}
+        self.log(level, message, extra=extra)
 
     def LogAsIs(self, message: str, /, *, indented: bool = False) -> None:
         """"""
@@ -472,11 +531,9 @@ class logger_t(base_t):
         self.LogException(exception, level=l.CRITICAL)
         s.exit(1)
 
-    def DealWithExceptionInThread(
-        self, exc_type, exc_value, exc_traceback, _, /
-    ) -> None:
+    def DealWithExceptionInThread(self, args, /) -> None:
         """"""
-        self.DealWithException(exc_type, exc_value, exc_traceback)
+        self.DealWithException(args.exc_type, args.exc_value, args.exc_traceback)
 
     def DisplayRule(
         self, /, *, message: str | None = None, color: str = "white"
@@ -527,7 +584,9 @@ class logger_t(base_t):
         )
         self.staged_issues.append(issue)
 
-    def PopIssues(self, /, *, should_remove_context: bool = False) -> list[str]:
+    def PopIssues(
+        self, /, *, should_remove_context: bool = False
+    ) -> list[tuple[str, bool]]:
         """"""
         if not self.has_staged_issues:
             return []
@@ -539,10 +598,10 @@ class logger_t(base_t):
         else:
             separator = ISSUE_LEVEL_SEPARATOR
         separator_length = separator.__len__()
-        for issue in self.staged_issues:
+        for issue, has_actual_expected in self.staged_issues:
             start_idx = issue.find(separator)
             issue = issue[(start_idx + separator_length) :]
-            output.append(issue)
+            output.append((issue, has_actual_expected))
 
         self.staged_issues.clear()
 
@@ -564,13 +623,16 @@ class logger_t(base_t):
                     "Invalid commit order",
                     actual=order,
                     expected=f"One of {str(ORDER)[1:-1]}",
-                )
+                )[0]
             )
 
         if order == "when":
             issues = self.staged_issues
         else:  # order == "context"
-            issues = sorted(self.staged_issues, key=lambda _: _.context)
+            issues = sorted(
+                self.staged_issues,
+                key=lambda _: _[0].split(ISSUE_LEVEL_SEPARATOR, maxsplit=1)[1],
+            )
         """
         Format issues as an exception:
         try:
@@ -582,20 +644,43 @@ class logger_t(base_t):
             formatted = "\n".join(lines)
         """
 
-        hide_where = {SHOW_WHERE_ATTR: False}
+        extra = {SHOW_WHERE_ATTR: False}
         if unified:
-            level, _ = issues[0].split(ISSUE_LEVEL_SEPARATOR, maxsplit=1)
+            level, _ = issues[0][0].split(ISSUE_LEVEL_SEPARATOR, maxsplit=1)
             wo_level = []
-            for issue in issues:
+            any_has_actual_expected = False
+            for issue, has_actual_expected in issues:
                 _, issue = issue.split(ISSUE_LEVEL_SEPARATOR, maxsplit=1)
+                if has_actual_expected:
+                    any_has_actual_expected = True
                 wo_level.append(issue)
-            self.log(int(level), "\n".join(wo_level), stacklevel=2, extra=hide_where)
+            if any_has_actual_expected:
+                extra[HAS_ACTUAL_EXPECTED_ATTR] = True
+            self.log(int(level), "\n".join(wo_level), stacklevel=2, extra=extra)
         else:
-            for issue in issues:
+            for issue, has_actual_expected in issues:
                 level, issue = issue.split(ISSUE_LEVEL_SEPARATOR, maxsplit=1)
-                self.log(int(level), issue, stacklevel=2, extra=hide_where)
+                if has_actual_expected:
+                    extra[HAS_ACTUAL_EXPECTED_ATTR] = True
+                self.log(int(level), issue, stacklevel=2, extra=extra)
+                if has_actual_expected:
+                    del extra[HAS_ACTUAL_EXPECTED_ATTR]
         self.staged_issues.clear()
 
+    def StoragePath(self, suffix: str, /) -> path_t:
+        """
+        Use as staticmethod if needed.
+        """
+        for handler in self.handlers:
+            if (path := getattr(handler, "baseFilename", None)) is not None:
+                output = path_t(path).with_suffix(suffix)
+                if output.exists():
+                    output = NewTemporaryFile(suffix)
+
+                return output
+
+        return NewTemporaryFile(suffix)
+
     def __enter__(self) -> None:
         """"""
         pass
@@ -611,6 +696,13 @@ class logger_t(base_t):
         _ = self.context_levels.pop()
         return False
 
+    def __del__(self) -> None:
+        """"""
+        assert prll.current_process().name == MAIN_PROCESS_NAME
+
+        if self.log_server is not None:
+            self.log_server.stop()
+
 
 def _HandleForWarnings(interceptor: base_t, /) -> logger_handle_h:
     """"""

logger_36/version.py

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

{logger_36-2025.24.dist-info → logger_36-2025.25.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: logger-36
-Version: 2025.24
+Version: 2025.25
 Summary: Simple logger with a catalog of handlers
 Home-page: https://src.koda.cnrs.fr/eric.debreuve/logger-36/
 Author: Eric Debreuve
@@ -109,46 +109,32 @@ The code is formatted by `Black <https://github.com/psf/black/>`_, *The Uncompro
 The imports are ordered by `isort <https://github.com/timothycrosley/isort/>`_... *your imports, so you don't have to*.
 
 ..
-  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/
+   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-2025.25.dist-info/RECORD

@@ -0,0 +1,53 @@
+logger_36/__init__.py,sha256=mK6AD0eWI2Sk42oxleTvsxzYJ28FbHK5WNkpLgAhnNE,2129
+logger_36/version.py,sha256=gqr9_xGceDfeDrDRv0O1e-8Rn6mXcEV_iFdCtiuTyAk,1680
+logger_36/api/chronos.py,sha256=o_UMZbeExjb01aNURmzIjOMAHhI9e90nyvJJYcJR6VQ,1739
+logger_36/api/logger.py,sha256=eLZ2yuH-sYeh4Z2KnAwTRJEbmkmgzBPMncdqXfFUTG8,1760
+logger_36/api/memory.py,sha256=U4mMEkx8WRHk9q2d3SCFGt2EJaBuflOXw2bGbAxOnSc,1828
+logger_36/api/message.py,sha256=DuT4UX4r_1DTXzuuRD-tvsTZk5X-Nj11loBKhuWOMw0,1791
+logger_36/api/storage.py,sha256=S1fVzrMp-_zlhg27fRPddWCFQRyvbpFwSreALOeoNFI,1713
+logger_36/catalog/config/console_rich.py,sha256=t9p9-AkSgPiLAsm1evAdbz77g7JcVLePhUJ1FzNi3cY,2330
+logger_36/catalog/config/optional.py,sha256=8d8HdpE07gHfsdoL8mVAlRlh9AgLcb4z7I7h6ob7CfU,2174
+logger_36/catalog/handler/console.py,sha256=XIyO_8MrzaTlihDbFhIzRk47HjxMH4gV2Zqp0-1oMsU,2320
+logger_36/catalog/handler/console_rich.py,sha256=RXLu8AQxAmyec1bXUc99Mabp7BjZc-lKEfwrCzMPkZA,6662
+logger_36/catalog/handler/file.py,sha256=5GR_aACDEBXuZ-pUH9P0OCaXbCf-aLPmsz-XrGCAIgE,2434
+logger_36/catalog/handler/generic.py,sha256=kwr7x7GWLmWvT7niHGW7OqlMotvTQNuNEwQGfKh_nhU,7040
+logger_36/catalog/handler/memory.py,sha256=pJwKOlCm8Ej8ipDI00-FfX4qJjMPXJb-DucD1ukIQOU,4057
+logger_36/catalog/logger/chronos.py,sha256=MDAx_NRRcRZcQYDDjVCRcu87SDP-rPYjX0-10KNcMnk,2216
+logger_36/catalog/logger/gpu.py,sha256=Py5YY0nD_pqJzJsEKQYoOGHcPqyNVJ3J2noOS3hDL6g,2890
+logger_36/catalog/logger/memory.py,sha256=pa-9pkvDGdf52giwL3Zi1mjWNFE_NVzBGdjwcfeIDNc,4256
+logger_36/catalog/logger/system.py,sha256=zEbHirATqZAVYFmHLd0pppeuRhka1ucWwyHRq0afQNE,2593
+logger_36/config/issue.py,sha256=QOkVRPSLZC_2mfcFpad-pcSXJXfLHdWUAXiMbTWlZTg,1741
+logger_36/config/memory.py,sha256=bZmNYsD2goVdkraS1v_t2OqAJo86jKMtP311kIVURDk,1691
+logger_36/config/message.py,sha256=bDAW4hZdsHBTYlCA7IZbL1FxGPwjX9Khmw0d21VHGs0,1968
+logger_36/config/rule.py,sha256=BqOb4SWKgT0YQZ-DtOzkLNZNWZVZkl5GN3lMoWoPrKw,1702
+logger_36/config/system.py,sha256=YRSa2eN_SoTnTXWUXAcpKt4JXifabzMR0eXwjUYlA_A,1951
+logger_36/constant/chronos.py,sha256=JJvBN_skqRdUgnuWhMqG0gZ3_ZkXmAz1syEixfu4lCM,2131
+logger_36/constant/error.py,sha256=FinnCcwGGH2oiXX3aw2uxKYvR3d5Tkb9rlNhNjyuoF8,2354
+logger_36/constant/html.py,sha256=w8gttc1XBSMpdKRolnXAVJ5x_hOAIsVsUyELCXJYdWU,2011
+logger_36/constant/issue.py,sha256=0EmcsRmSxktFUJR0qOU0PnKG-gfbLDOULH6sSRHFOcc,1789
+logger_36/constant/logger.py,sha256=ZQYX9JiPsoivwRgYNtdEqRKCagSKD88lRqvxP8MX1ZE,1942
+logger_36/constant/memory.py,sha256=Q_E5tTWa-cGaNwrE_xmKa3BxQG6oJO6DHczrxc_M4sE,1817
+logger_36/constant/message.py,sha256=TdsZXWO2UmlG3a0ia3UsUCxtVUa8GNferi69pO4A9TM,2301
+logger_36/constant/path.py,sha256=r-vx5ztGhcpYfg37kw0oaxBYdTSkWOJuToTmexaW8tE,2265
+logger_36/constant/record.py,sha256=70JO2LYL-1Eg-vLD3N7nUoYALp6ji7-b3DLxCHTc7iQ,1881
+logger_36/constant/rule.py,sha256=ul-MqOdHBGBC5Nwn05EUnz2T__7VEs82qiH7Fzs5qCk,1804
+logger_36/constant/system.py,sha256=pLlLXG5sepQlSUOo3TphaGrHg8xzJBp-GxpL2NPP47k,1904
+logger_36/extension/file.py,sha256=ClY8k805DnB6Vy0LEQIhlO0MavP91Y-CEjHjFepyROE,2034
+logger_36/extension/inspection.py,sha256=LoHXi4wsIgHKrq_7GYkVcfJ9rnBG16pLKMpAoHNwJiY,3922
+logger_36/extension/line.py,sha256=9BgxnY6wiyc44Ari5rkvqbvz9ao4sNs39u8k7sY6vFc,2611
+logger_36/extension/sentinel.py,sha256=SQgkQiRcTIjCRvbxiOb6TEm59BC0FNMcjYoIShpcwLo,1718
+logger_36/instance/logger.py,sha256=X_U10RYU1h2Aa70D8hBnmFyJZtRILK16KN-GB4xkHMU,1782
+logger_36/instance/loggers.py,sha256=inBk4KKrQ-z3szaopQ29-qQwh1iSc842sWo5J6zJoiM,1725
+logger_36/task/storage.py,sha256=L93v5w9p_7MoiagEr3d6QSYEQxX42DxmZ-BJTCuLpgQ,3915
+logger_36/task/format/memory.py,sha256=xcWwbUnl1BxH7RVBHyhp1RlbT2n370PzoFLLLd3dtlU,3726
+logger_36/task/format/message.py,sha256=Q9QkyUAU47Nj606zsvq0gNyso8Vk9G9OaqG9Em5FjKg,3575
+logger_36/task/measure/chronos.py,sha256=fZKK16LwlLzRRAP-gfF1uy6gFCL33gR7LZ4Xs_nXdVY,2612
+logger_36/task/measure/memory.py,sha256=kkPHEIUTUhkCOLrAt01eLJLnsnkl0nFPNhFZdIB_JAw,1991
+logger_36/type/handler.py,sha256=bDsCFYpevCJBV7Vc9jovttapjU-7GXI1_TDbmOf2kN4,6660
+logger_36/type/issue.py,sha256=M2KeQwzDG9yqgdtbyWk5Y-ier7c71TuAKlNCf5QCGzY,2770
+logger_36/type/logger.py,sha256=0OjqyMcBAyS0qUUeEzweALrs0m5rVqZF3e6R1b8B4RA,27358
+logger_36/type/loggers.py,sha256=7EX7Sg_RlduBjdfFlNZmUfNeDloH1xU30Rdkg_-rXh8,3172
+logger_36-2025.25.dist-info/METADATA,sha256=Uchfn7mGuqLow-qAR-TejGvwkXNns2N7XnpLbgHeGFE,5980
+logger_36-2025.25.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+logger_36-2025.25.dist-info/top_level.txt,sha256=sM95BTMWmslEEgR_1pzwZsOeSp8C_QBiu8ImbFr0XLc,10
+logger_36-2025.25.dist-info/RECORD,,