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

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,7 +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 os import sep as FOLDER_SEPARATOR
+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
 
@@ -27,26 +29,35 @@ 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.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.path import PROJECT_FILE_RELATIVE, USER_FOLDER
-from logger_36.constant.record import SHOW_W_RULE_ATTR, SHOW_WHERE_ATTR
+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 (
+    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 any_handler_t as base_handler_t
 from logger_36.type.handler import extension_t as handler_extension_t
+from logger_36.type.handler import handler_h as base_handler_h
 from logger_36.type.issue import NewIssue, issue_t
 
 if RICH_IS_AVAILABLE:
@@ -62,8 +73,7 @@ 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
 
-_DATE_TIME_ORIGIN = date_time_t.fromtimestamp(1970, None)
-_DATE_ORIGIN = _DATE_TIME_ORIGIN.date()
+MAIN_PROCESS_NAME = "MainProcess"
 
 
 @d.dataclass(slots=True, repr=False, eq=False)
@@ -85,26 +95,51 @@ class logger_t(base_t):
     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)
+    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)
     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
     )
     intercepts_exceptions: bool = d.field(init=False, default=False)
 
-    # Used only until the last handler is added (see AddHandler).
+    # 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
     activate_log_interceptions: d.InitVar[bool] = True
     activate_exc_interceptions: d.InitVar[bool] = True
 
+    @property
+    def formatted_history(self) -> str:
+        """"""
+        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:
         """"""
@@ -152,9 +187,15 @@ 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:]}"
 
+        self.history[date_time_t.now()] = (
+            f'Logger "{name_}" instantiation for "{LAUNCH_ROOT_FILE_relative}"'
+        )
+
         base_t.__init__(self, name_)
         self.setLevel(level_)
         self.propagate = False  # Part of base_t.
@@ -175,44 +216,41 @@ class logger_t(base_t):
         if self.should_monitor_memory_usage:
             self.ActivateMemoryUsageMonitoring()
 
-        self.history[date_time_t.now()] = (
-            f'Logger "{self.name}" instantiation for "{PROJECT_FILE_RELATIVE}"'
-        )
-
     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.
@@ -226,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,
             }
         )
@@ -332,8 +370,8 @@ class logger_t(base_t):
 
     def AddHandler(
         self,
-        handler_t_or_handler: type[base_handler_t]
-        | base_handler_t
+        handler_t_or_handler: type[base_handler_h]
+        | base_handler_h
         | l.Handler
         | l.FileHandler,
         /,
@@ -386,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.
@@ -397,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)
 
@@ -416,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,
@@ -424,7 +483,25 @@ 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:
+        """"""
+        if indented:
+            message = text.indent(message, LINE_INDENT)
+
+        for handler in self.handlers:
+            EmitMessage = getattr(
+                handler, handler_extension_t.EmitMessage.__name__, None
+            )
+            if EmitMessage is not None:
+                EmitMessage(message)
+
+    info_raw = LogAsIs  # To follow the convention of the logging methods info, error...
 
     def LogException(
         self,
@@ -454,25 +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)
-
-    def LogAsIs(self, message: str, /, *, indented: bool = False) -> None:
-        """"""
-        if indented:
-            message = text.indent(message, LINE_INDENT)
-
-        for handler in self.handlers:
-            EmitMessage = getattr(
-                handler, handler_extension_t.EmitMessage.__name__, None
-            )
-            if EmitMessage is not None:
-                EmitMessage(message)
-
-    info_raw = LogAsIs  # To follow the convention of the logging methods info, error...
+        self.DealWithException(args.exc_type, args.exc_value, args.exc_traceback)
 
     def DisplayRule(
         self, /, *, message: str | None = None, color: str = "white"
@@ -523,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 []
@@ -535,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()
 
@@ -560,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:
@@ -578,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
@@ -607,25 +696,12 @@ class logger_t(base_t):
         _ = self.context_levels.pop()
         return False
 
+    def __del__(self) -> None:
+        """"""
+        assert prll.current_process().name == MAIN_PROCESS_NAME
 
-def _RecordLocation(record: l.LogRecord, should_also_store: bool, /) -> str:
-    """"""
-    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:
-        if module.is_relative_to(USER_FOLDER):
-            module = module.relative_to(USER_FOLDER)
-
-    output = f"{module}:{record.funcName}:{record.lineno}"
-
-    if should_also_store:
-        record.where = output
-
-    return output
+        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.23"
+__version__ = "2025.25"
 
 """
 COPYRIGHT NOTICE

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

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