logger-36 2024.28__py3-none-any.whl → 2024.29__py3-none-any.whl

logger_36/task/measure/chronos.py

@@ -5,25 +5,35 @@ SEE COPYRIGHT NOTICE BELOW
 """
 
 import time
-from datetime import datetime as dttm
+from datetime import datetime as date_time_t
 
 # This module is imported early. Therefore, the current date and time should be close
 # enough to the real start time of the main script.
-_START_DATE_AND_TIME = dttm.now()
+_START_DATE_AND_TIME = date_time_t.now()
 
 
 def TimeStamp(*, precision: str = "microseconds") -> str:
     """"""
-    return dttm.now().isoformat(timespec=precision).replace(".", "-").replace(":", "-")
+    return (
+        date_time_t.now()
+        .isoformat(timespec=precision)
+        .replace(".", "-")
+        .replace(":", "-")
+    )
 
 
-def ElapsedTime() -> str:
+def ElapsedTime(
+    *, should_return_now: bool = False
+) -> str | tuple[str, date_time_t.date]:
     """"""
-    elapsed_seconds = (dttm.now() - _START_DATE_AND_TIME).total_seconds()
-    output = time.strftime("%Hh %Mm %Ss", time.gmtime(elapsed_seconds))
-    while output.startswith("00") and (" " in output):
-        output = output.split(maxsplit=1)[-1]
-
+    now = date_time_t.now()
+    elapsed_seconds = (now - _START_DATE_AND_TIME).total_seconds()
+    output = time.strftime("%H:%M:%S", time.gmtime(elapsed_seconds))
+    while output.startswith("00:"):
+        output = output.split(sep=":", maxsplit=1)[-1]
+
+    if should_return_now:
+        return output, now
     return output
 
 

logger_36/type/handler.py

@@ -8,15 +8,17 @@ import dataclasses as d
 import logging as lggg
 import sys as sstm
 import typing as h
-from os import sep as FOLDER_SEPARATOR
-from pathlib import Path as path_t
 
-from logger_36.config.message import TIME_FORMAT, WHERE_FORMAT
+from logger_36.config.message import (
+    LEVEL_CLOSING,
+    LEVEL_OPENING,
+    MESSAGE_MARKER,
+    WHERE_SEPARATOR,
+)
 from logger_36.constant.error import MEMORY_MEASURE_ERROR
 from logger_36.constant.handler import HANDLER_CODES
 from logger_36.constant.message import NEXT_LINE_PROLOGUE
-from logger_36.constant.record import HIDE_WHERE_ATTR, SHOW_WHERE_ATTR
-from logger_36.task.format.message import FormattedMessage, MessageFormat
+from logger_36.task.format.message import MessageWithActualExpected
 from logger_36.task.measure.chronos import TimeStamp
 from logger_36.task.measure.memory import CanCheckUsage as CanCheckMemoryUsage
 
@@ -26,10 +28,9 @@ _MEMORY_MEASURE_ERROR = MEMORY_MEASURE_ERROR
 @d.dataclass(slots=True, repr=False, eq=False)
 class handler_extension_t:
     name: str | None = None
-    show_where: bool = True
-    show_memory_usage: bool = False
+    should_store_memory_usage: bool = False
     message_width: int = -1
-    FormattedRecord: h.Callable[[lggg.LogRecord], str] = d.field(init=False)
+    MessageFromRecord: h.Callable[..., str] = d.field(init=False)
 
     handler: d.InitVar[lggg.Handler | None] = None
     level: d.InitVar[int] = lggg.NOTSET
@@ -43,7 +44,7 @@ class handler_extension_t:
 
         if self.name in HANDLER_CODES:
             raise ValueError(
-                FormattedMessage(
+                MessageWithActualExpected(
                     "Invalid handler name",
                     actual=self.name,
                     expected=f"a name not in {str(HANDLER_CODES)[1:-1]}",
@@ -53,8 +54,8 @@ class handler_extension_t:
         if self.name is None:
             self.name = TimeStamp()
 
-        if self.show_memory_usage and not CanCheckMemoryUsage():
-            self.show_memory_usage = False
+        if self.should_store_memory_usage and not CanCheckMemoryUsage():
+            self.should_store_memory_usage = False
             if _MEMORY_MEASURE_ERROR is not None:
                 print(_MEMORY_MEASURE_ERROR, file=sstm.stderr)
                 _MEMORY_MEASURE_ERROR = None
@@ -64,85 +65,45 @@ class handler_extension_t:
         if 0 < self.message_width < 5:
             self.message_width = 5
         if formatter is None:
-            message_format = MessageFormat(self.show_where, self.show_memory_usage)
-            formatter = lggg.Formatter(fmt=message_format, datefmt=TIME_FORMAT)
-        handler.setFormatter(formatter)
-        self.FormattedRecord = handler.formatter.format
+            self.MessageFromRecord = self._MessageFromRecord
+        else:
+            handler.setFormatter(formatter)
+            self.MessageFromRecord = handler.formatter.format
 
-    def FormattedLines(
+    def _MessageFromRecord(
         self,
         record: lggg.LogRecord,
         /,
         *,
         PreProcessed: h.Callable[[str], str] | None = None,
-        should_join_lines: bool = False,
-    ) -> tuple[str, str | None]:
+    ) -> str:
         """
         See logger_36.catalog.handler.README.txt.
         """
-        record.level_first_letter = record.levelname[0]
-
         message = record.msg
-        if not isinstance(message, str):
-            message = str(message)
-        original_message = message
 
         if PreProcessed is not None:
             message = PreProcessed(message)
-        if (has_newlines := ("\n" in message)) or (
-            (self.message_width > 0) and (message.__len__() > self.message_width)
-        ):
-            if has_newlines:
-                lines = message.splitlines()
-                if self.message_width > 0:
-                    lines = _WrappedLines(lines, self.message_width)
-            else:
-                lines = _WrappedLines([message], self.message_width)
-            next_lines = NEXT_LINE_PROLOGUE.join(lines[1:])
-            next_lines = f"{NEXT_LINE_PROLOGUE}{next_lines}"
-            message = lines[0]
+        if (self.message_width <= 0) or (message.__len__() <= self.message_width):
+            if "\n" in message:
+                message = NEXT_LINE_PROLOGUE.join(message.splitlines())
         else:
-            next_lines = None
-        if self.message_width > 0:
-            n_missing_s = self.message_width - message.__len__()
-            if n_missing_s > 3:
-                message += " " + (n_missing_s - 1) * "."
-            elif n_missing_s > 0:
-                message += n_missing_s * " "
-
-        record.msg = message
-        if self.show_where and not hasattr(record, SHOW_WHERE_ATTR):
-            hide_where = getattr(record, HIDE_WHERE_ATTR, False)
-            if hide_where:
-                record.where = ""
+            if "\n" in message:
+                lines = _WrappedLines(message.splitlines(), self.message_width)
             else:
-                module = path_t(record.pathname)
-                path_was_found = False
-                for path in sstm.path:
-                    if module.is_relative_to(path):
-                        module = module.relative_to(path)
-                        path_was_found = True
-                        break
-                if path_was_found:
-                    module = str(module.parent / module.stem)
-                    module = module.replace(FOLDER_SEPARATOR, ".")
-                else:
-                    module = record.module
-                record.where = WHERE_FORMAT.format(
-                    module=module, funcName=record.funcName, lineno=record.lineno
-                )
-        first_line = self.FormattedRecord(record).replace("\t", " ")
-
-        # Revert the record message to its original value for subsequent handlers.
-        record.msg = original_message
+                lines = _WrappedLines([message], self.message_width)
+            message = NEXT_LINE_PROLOGUE.join(lines)
 
-        if should_join_lines:
-            if next_lines is None:
-                return first_line, None
-            else:
-                return f"{first_line}{next_lines}", None
+        if (where := getattr(record, "where", None)) is None:
+            where = ""
         else:
-            return first_line, next_lines
+            where = f"{NEXT_LINE_PROLOGUE}{WHERE_SEPARATOR} {where}"
+
+        return (
+            f"{record.when_or_elapsed}"
+            f"{LEVEL_OPENING}{record.level_first_letter}{LEVEL_CLOSING} "
+            f"{MESSAGE_MARKER} {message}{where}"
+        )
 
 
 def _WrappedLines(lines: list[str], message_width: int, /) -> list[str]:

logger_36/type/issue.py

@@ -11,7 +11,7 @@ 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.task.format.message import FormattedMessage
+from logger_36.task.format.message import MessageWithActualExpected
 
 issue_t = str
 
@@ -32,7 +32,7 @@ def NewIssue(
     """"""
     if context.__len__() == 0:
         context = ISSUE_BASE_CONTEXT
-    message = FormattedMessage(
+    message = MessageWithActualExpected(
         message,
         actual=actual,
         expected=expected,

logger_36/type/logger.py

@@ -10,35 +10,47 @@ import sys as sstm
 import traceback as tcbk
 import types as t
 import typing as h
-from datetime import datetime as dttm
+from datetime import date as date_t
+from datetime import datetime as date_time_t
+from os import sep as FOLDER_SEPARATOR
 from pathlib import Path as path_t
 from traceback import TracebackException as traceback_t
 
 from logger_36.config.issue import ISSUE_CONTEXT_END, ISSUE_CONTEXT_SEPARATOR
-from logger_36.config.message import DATE_FORMAT
+from logger_36.config.message import (
+    DATE_FORMAT,
+    ELAPSED_TIME_SEPARATOR,
+    LONG_ENOUGH,
+    TIME_FORMAT,
+)
 from logger_36.constant.generic import NOT_PASSED
 from logger_36.constant.issue import ISSUE_LEVEL_SEPARATOR, ORDER, order_h
 from logger_36.constant.logger import (
-    HIDE_WHERE_KWARG,
     LOGGER_NAME,
     WARNING_LOGGER_NAME,
     WARNING_TYPE_COMPILED_PATTERN,
     logger_handle_h,
 )
 from logger_36.constant.memory import UNKNOWN_MEMORY_USAGE
-from logger_36.constant.message import expected_op_h
-from logger_36.constant.record import SHOW_MEMORY_ATTR, SHOW_W_RULE_ATTR
-from logger_36.task.format.memory import (
-    FormattedUsageWithAutoUnit as FormattedMemoryUsage,
+from logger_36.constant.message import TIME_LENGTH_m_1, expected_op_h
+from logger_36.constant.record import (
+    HIDE_WHERE_ATTR,
+    SHOW_W_RULE_ATTR,
+    STORE_MEMORY_ATTR,
 )
-from logger_36.task.format.message import FormattedMessage
+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
 from logger_36.type.issue import NewIssue, issue_t
 
+logger_base_t = lggg.Logger
+
+_DATE_TIME_ORIGIN = date_time_t.fromtimestamp(1970, None)
+_DATE_ORIGIN = _DATE_TIME_ORIGIN.date()
+
 
 @d.dataclass(slots=True, repr=False, eq=False)
-class logger_t(lggg.Logger):
+class logger_t(logger_base_t):
     name_: d.InitVar[str] = LOGGER_NAME
     level_: d.InitVar[int] = lggg.NOTSET
     activate_wrn_interceptions: d.InitVar[bool] = True
@@ -50,8 +62,9 @@ class logger_t(lggg.Logger):
 
     on_hold: list[lggg.LogRecord] = d.field(init=False, default_factory=list)
     events: dict[int, int] = d.field(init=False, default_factory=dict)
-    last_message_date: str = d.field(init=False, default="")
-    any_handler_shows_memory: bool = d.field(init=False, default=False)
+    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)
+    any_handler_stores_memory: bool = d.field(init=False, default=False)
     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)
@@ -64,9 +77,9 @@ class logger_t(lggg.Logger):
         self, name_: str, level_: int, activate_wrn_interceptions: bool
     ) -> None:
         """"""
-        lggg.Logger.__init__(self, name_)
+        logger_base_t.__init__(self, name_)
         self.setLevel(level_)
-        self.propagate = False  # Part of lggg.Logger.
+        self.propagate = False  # Part of logger_base_t.
 
         for level in lggg.getLevelNamesMapping().values():
             self.events[level] = 0
@@ -92,7 +105,7 @@ class logger_t(lggg.Logger):
             logger.handle = t.MethodType(_HandleForWarnings(self), logger)
 
             lggg.captureWarnings(True)
-            self.info("Warning Interception: ON", **HIDE_WHERE_KWARG)
+            self.info("Warning Interception: ON")
 
     def _DeactivateWarningInterceptions(self) -> None:
         """"""
@@ -102,7 +115,7 @@ class logger_t(lggg.Logger):
             self.intercepted_wrn_handle = None
 
             lggg.captureWarnings(False)
-            self.info("Warning Interception: OFF", **HIDE_WHERE_KWARG)
+            self.info("Warning Interception: OFF")
 
     def ToggleWarningInterceptions(self, state: bool, /) -> None:
         """"""
@@ -130,16 +143,13 @@ class logger_t(lggg.Logger):
             intercepted = sorted(self.intercepted_log_handles.keys())
             if intercepted.__len__() > 0:
                 as_str = ", ".join(intercepted)
-                self.info(
-                    f"Now Intercepting LOGs from: {as_str}",
-                    **HIDE_WHERE_KWARG,
-                )
+                self.info(f"Now Intercepting LOGs from: {as_str}")
         elif self.intercepted_log_handles.__len__() > 0:
             for name, handle in self.intercepted_log_handles.items():
                 logger = lggg.getLogger(name)
                 logger.handle = handle
             self.intercepted_log_handles.clear()
-            self.info("Log Interception: OFF", **HIDE_WHERE_KWARG)
+            self.info("Log Interception: OFF")
 
     @property
     def max_memory_usage(self) -> int:
@@ -162,15 +172,15 @@ class logger_t(lggg.Logger):
     def AddHandler(self, handler: lggg.Handler, should_hold_messages: bool, /) -> None:
         """"""
         self.should_hold_messages = should_hold_messages
-        lggg.Logger.addHandler(self, handler)
+        logger_base_t.addHandler(self, handler)
 
         extension = getattr(handler, "extension", None)
         if extension is None:
-            show_memory_usage = False
+            should_store_memory_usage = False
         else:
-            show_memory_usage = getattr(extension, SHOW_MEMORY_ATTR, False)
-        if show_memory_usage:
-            self.any_handler_shows_memory = True
+            should_store_memory_usage = getattr(extension, STORE_MEMORY_ATTR, False)
+        if should_store_memory_usage:
+            self.any_handler_stores_memory = True
 
         extension = getattr(handler, "extension", handler.name)
         if isinstance(extension, str):
@@ -180,51 +190,75 @@ class logger_t(lggg.Logger):
         self.info(
             f'New handler "{name}" with class "{type(handler).__name__}" and '
             f"level {lggg.getLevelName(handler.level)}",
-            **HIDE_WHERE_KWARG,
         )
 
     def handle(self, record: lggg.LogRecord, /) -> None:
         """"""
-        if (not self.should_hold_messages) and (self.on_hold.__len__() > 0):
-            for hold in self.on_hold:
-                lggg.Logger.handle(self, hold)
-            self.on_hold.clear()
-
-        record.elapsed_time = ElapsedTime()
+        elapsed_time, now = ElapsedTime(should_return_now=True)
 
-        if self.any_handler_shows_memory or not self.hasHandlers():
-            # Memory usage is also added if there are no handlers yet, just in case.
-            usage = CurrentMemoryUsage()
-            self.memory_usages.append(
-                (f"{record.module}.{record.funcName}.{record.lineno}", usage)
-            )
-
-            value, unit = FormattedMemoryUsage(usage, 1)
-            record.memory_usage = f"{value}{unit}"
+        if (self.on_hold.__len__() > 0) and not self.should_hold_messages:
+            for held in self.on_hold:
+                logger_base_t.handle(self, held)
+            self.on_hold.clear()
 
-        date = dttm.now().strftime(DATE_FORMAT)
-        if date != self.last_message_date:
+        if (date := now.date()) != self.last_message_date:
             self.last_message_date = date
             # levelno: Added for management by logging.Logger.handle.
             date_record = lggg.makeLogRecord(
                 {
                     "name": self.name,
                     "levelno": lggg.INFO,
-                    "msg": f"DATE: {date}",
+                    "msg": f"DATE: {date.strftime(DATE_FORMAT)}",
                     SHOW_W_RULE_ATTR: True,
                 }
             )
             if self.should_hold_messages:
                 self.on_hold.append(date_record)
             else:
-                lggg.Logger.handle(self, date_record)
+                logger_base_t.handle(self, date_record)
+
+        # When.
+        if now - self.last_message_now > LONG_ENOUGH:
+            record.when_or_elapsed = now.strftime(TIME_FORMAT)
+        else:
+            record.when_or_elapsed = (
+                f"{ELAPSED_TIME_SEPARATOR}{elapsed_time:.<{TIME_LENGTH_m_1}}"
+            )
+        self.last_message_now = now
+
+        # Where.
+        # Memory usage is also stored if there are no handlers yet, just in case.
+        should_store_where = self.any_handler_stores_memory or not self.hasHandlers()
+        should_show_where = (record.levelno != lggg.INFO) and not hasattr(
+            record, HIDE_WHERE_ATTR
+        )
+        if should_store_where or should_show_where:
+            module = path_t(record.pathname)
+            for path in sstm.path:
+                if module.is_relative_to(path):
+                    module = module.relative_to(path).with_suffix("")
+                    module = str(module).replace(FOLDER_SEPARATOR, ".")
+                    break
+            else:
+                module = record.module
+            where = f"{module}:{record.funcName}:{record.lineno}"
+            if should_show_where:
+                record.where = where
+        else:
+            where = None
+
+        # How.
+        record.level_first_letter = record.levelname[0]
+
+        # What.
+        if not isinstance(record.msg, str):
+            record.msg = str(record.msg)
 
         if self.should_hold_messages:
             self.on_hold.append(record)
         else:
-            lggg.Logger.handle(self, record)
+            logger_base_t.handle(self, record)
 
-        self.events[record.levelno] += 1
         if (self.exit_on_critical and (record.levelno is lggg.CRITICAL)) or (
             self.exit_on_error and (record.levelno is lggg.ERROR)
         ):
@@ -232,6 +266,11 @@ class logger_t(lggg.Logger):
             # __post_init__ set self.exit_on_critical if self.exit_on_error.
             sstm.exit(1)
 
+        self.events[record.levelno] += 1
+
+        if should_store_where:
+            self.memory_usages.append((where, CurrentMemoryUsage()))
+
     def Log(
         self,
         message: str,
@@ -247,7 +286,7 @@ class logger_t(lggg.Logger):
         """"""
         if isinstance(level, str):
             level = lggg.getLevelNamesMapping()[level.upper()]
-        message = FormattedMessage(
+        message = MessageWithActualExpected(
             message,
             actual=actual,
             expected=expected,
@@ -357,7 +396,7 @@ class logger_t(lggg.Logger):
 
         if order not in ORDER:
             raise ValueError(
-                FormattedMessage(
+                MessageWithActualExpected(
                     "Invalid commit order",
                     actual=order,
                     expected=f"One of {str(ORDER)[1:-1]}",
@@ -379,17 +418,18 @@ class logger_t(lggg.Logger):
             formatted = "\n".join(lines)
         """
 
+        hide_where = {HIDE_WHERE_ATTR: None}
         if unified:
             level, _ = issues[0].split(ISSUE_LEVEL_SEPARATOR, maxsplit=1)
             wo_level = []
             for issue in issues:
                 _, issue = issue.split(ISSUE_LEVEL_SEPARATOR, maxsplit=1)
                 wo_level.append(issue)
-            self.log(int(level), "\n".join(wo_level), stacklevel=2)
+            self.log(int(level), "\n".join(wo_level), stacklevel=2, extra=hide_where)
         else:
             for issue in issues:
                 level, issue = issue.split(ISSUE_LEVEL_SEPARATOR, maxsplit=1)
-                self.log(int(level), issue, stacklevel=2)
+                self.log(int(level), issue, stacklevel=2, extra=hide_where)
         self.staged_issues.clear()
 
     def __enter__(self) -> None:
@@ -408,10 +448,10 @@ class logger_t(lggg.Logger):
         return False
 
 
-def _HandleForWarnings(interceptor: lggg.Logger, /) -> logger_handle_h:
+def _HandleForWarnings(interceptor: logger_base_t, /) -> logger_handle_h:
     """"""
 
-    def handle_p(_: lggg.Logger, record: lggg.LogRecord, /) -> None:
+    def handle_p(_: logger_base_t, record: lggg.LogRecord, /) -> None:
         pieces = WARNING_TYPE_COMPILED_PATTERN.match(record.msg)
         if pieces is None:
             # The warning message does not follow the default format.
@@ -437,11 +477,11 @@ def _HandleForWarnings(interceptor: lggg.Logger, /) -> logger_handle_h:
 
 
 def _HandleForInterceptions(
-    intercepted: lggg.Logger, interceptor: lggg.Logger, /
+    intercepted: logger_base_t, interceptor: logger_base_t, /
 ) -> logger_handle_h:
     """"""
 
-    def handle_p(_: lggg.Logger, record: lggg.LogRecord, /) -> None:
+    def handle_p(_: logger_base_t, record: lggg.LogRecord, /) -> None:
         duplicate = lggg.makeLogRecord(record.__dict__)
         duplicate.msg = f"{record.msg} :{intercepted.name}:"
         interceptor.handle(duplicate)

logger_36/version.py

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

{logger_36-2024.28.dist-info → logger_36-2024.29.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: logger-36
-Version: 2024.28
+Version: 2024.29
 Summary: Simple logger with a catalog of handlers
 Home-page: https://src.koda.cnrs.fr/eric.debreuve/logger-36/
 Author: Eric Debreuve

logger_36-2024.29.dist-info/RECORD

@@ -0,0 +1,52 @@
+logger_36/__init__.py,sha256=NtDTs3eMKaXTJeujmgj1um3cBVLti0tYuOsdtVk9o9Q,2269
+logger_36/content.py,sha256=ni9gdYYNZoDa91KNianWBluOBe9KxZMZtzalcBS6vhE,2357
+logger_36/exception.py,sha256=UsFcsAvd1L4aLj6h7T-DilDm6yO501HDYnGekibiMAU,3260
+logger_36/gpu.py,sha256=YYFk6aYQrBDJfxQaDm-ar16T6SlOSL6jJWTOgvpF4EU,2244
+logger_36/handler.py,sha256=vg8LOD0YzGQxyoKB7qr7c4rueRwp-sDF1svDHwffumg,6565
+logger_36/memory.py,sha256=FTc3qCeMqnCNvHJ4Yds73noPENQx_U1MYB-R4LLUjVQ,2682
+logger_36/storage.py,sha256=TNfIXEfHcjixv75wocUyqwX62iDYsor4srRqC3FNzbc,2231
+logger_36/system.py,sha256=xzm6cMeTaCX9VX9ZRXUXgfqoT9oUtv3W2o_H2W0P-4Q,2243
+logger_36/time.py,sha256=_CtpQeUZdsUNGNfwzhoWUiUvawRgmonqwZPHouzWf5M,2308
+logger_36/version.py,sha256=FPamC8R6aakwwSJ4-41eIPnI5eDVF1QjdoZc8H7gmdA,2206
+logger_36/api/logger.py,sha256=Wg2nzQeuRVZ4v-oy3Q2KdYsHSzF9v7a0Fk6BzLnbkYw,2225
+logger_36/api/storage.py,sha256=evKVqIsslA5X82LaZ2HQDxp7ltyNOn8Tr-3-Pic3eUo,2231
+logger_36/catalog/config/console_rich.py,sha256=iyPFozVpw18qkRTBovhb2X2WM93MW5QqgwGQDSzUijI,2866
+logger_36/catalog/handler/console.py,sha256=KL8oGdtQUUE8I5Pc_5wmD1MdDSw8E7dpybkzmFWKRUY,4247
+logger_36/catalog/handler/console_rich.py,sha256=of4C26UZcA10-dBrdRGWVk4u9NycX_9VIgINGevEB14,8330
+logger_36/catalog/handler/file.py,sha256=JgtfBQfgQldxqogzAVYOquX3pLE-qOqnbhZbu9H3tXo,4699
+logger_36/catalog/handler/generic.py,sha256=U1X2B7ptLWtdtiDh_Lri55JmygTPnY9wXwmFsPZcZuE,9002
+logger_36/catalog/logger/chronos.py,sha256=7_Y_HxRHwwHyjOb2v4Y3CxMGCaJBWm7q8wlw05jZGvs,2447
+logger_36/catalog/logger/gpu.py,sha256=QPESzp3V-Qhx2A99A5N3IsM9tA6ikqSPos0MKJyu-ls,3407
+logger_36/catalog/logger/memory.py,sha256=Wv6thZ4ydM_x3mZkpz6XnOm7jaWjXWb3mEQuk4EKXb0,4693
+logger_36/catalog/logger/system.py,sha256=WRDlh0tr8NYp6AeVjLkmzuBMwtJxSokl4_mMJRH9OBU,3076
+logger_36/config/issue.py,sha256=G-i5p6lhZCLAOa-VTMyL9ZonvGCvhdoQ5KZdSWgP-FU,2267
+logger_36/config/logger.py,sha256=9vQ8m1sJsK8tjnh5SZEKzofqeVJbsULTm-ev2rk0x7M,3760
+logger_36/config/memory.py,sha256=yCX5phsB_KJMr5xHpVUeOHFhAA7p_8yahP3X28VndOY,2217
+logger_36/config/message.py,sha256=yfbMO_Jk1IbWvT6Lp6hVpID2Tr99cuiJ-ZaMBesIFXw,2527
+logger_36/config/system.py,sha256=HD8ZuwsXhEAExeZrww8YoDkQGMs4T5RDqQMb1W4qVgc,2477
+logger_36/constant/error.py,sha256=1gdnCwUu3d3ThL4AKxzjn7ijSTBWlr2g-8cAKbubl4A,2825
+logger_36/constant/generic.py,sha256=t6aRb66_NHwMhR1p7BZ4QXTU2jpLz-H5YAL4PuMtKx8,2244
+logger_36/constant/handler.py,sha256=HM8qCSEMGNMCzddjUUNBPGL-3d0qU-EmG5eW4ZQHW6A,2311
+logger_36/constant/issue.py,sha256=01l8itRPWGS5F6gXtsXUJgGR-4lS1Eu3_YeKC-khKLw,2315
+logger_36/constant/logger.py,sha256=QkaFk3I9JF83nkzrk8c1Jl0j_eSTEzGyeJbNgQdoSlE,2670
+logger_36/constant/memory.py,sha256=ZL1MwbdtNsrCrOwzEyfTsfOoOsRBTJtbbf3otHGnxXo,2343
+logger_36/constant/message.py,sha256=Ys_CAyhENlT8Z3rr-AxO4hjdl1jLsKzVSPQ8wqLOCPQ,2838
+logger_36/constant/record.py,sha256=9Q28lVH_s0og4v74delgwIPAJ9G28I5rBM-brXcoY80,2308
+logger_36/constant/system.py,sha256=G2mzBTxRXoJMxb53TnmBaceMJC_q3WonoCG7y6nC_R8,2430
+logger_36/instance/logger.py,sha256=ttKjl9MD7FUjqCWjv5w2hmmpDYxgaORcYf9NaaE9W_M,2246
+logger_36/instance/loggers.py,sha256=RCWpC1NPAf6vXnFc9NqsSALv-x-FEzcH6k_OlxTxeQk,2251
+logger_36/task/inspection.py,sha256=f9VkVrwMJ_ixV9rFu3XUNpmCbEgoo1tssqd2nMeGYLI,5028
+logger_36/task/storage.py,sha256=XaSeu-iBCa0N8HNpwCV7cLprj-lbOJocpTIKUgSOvsc,5668
+logger_36/task/format/memory.py,sha256=WDwRwuZbYwNxXIe_xo-r0XJtFZ0gRnE6wgTaXx_fEbc,4259
+logger_36/task/format/message.py,sha256=T2V2gUlUQqSojyRrz4I4uAHwNe6eBEsuAe6V-LTyx0k,3867
+logger_36/task/format/rule.py,sha256=M4a8uW7FEvMI9f4s32A9-DoP0WVlLkyXamGnqbzZ65A,2797
+logger_36/task/measure/chronos.py,sha256=OhQHPFKJvTEizpj7Uvysu8r9dTpzPgKz1SoTztlEcnI,3066
+logger_36/task/measure/memory.py,sha256=eVw5WOYLyn8o4O4mMArdX2MzsVuhhNDovjYEkk-MIaU,2504
+logger_36/type/handler.py,sha256=HJ547swaN1bdxnxoU4cIinWUkww3YAQ1vYgtugWk5X4,6474
+logger_36/type/issue.py,sha256=p2upR8vAXPkrnSwPuM3R1hmTkRwJwL1e658L6WwSWfQ,3220
+logger_36/type/logger.py,sha256=kYPiUOR_qs9DWBaHH4damx7xsh-OlFbYLHY1enyzn3w,18884
+logger_36/type/loggers.py,sha256=znqxWBnfQxvkg3VUfbTUvt3S6Kq0DAzWWepxQDt9suI,2871
+logger_36-2024.29.dist-info/METADATA,sha256=vV3RAljMWV9CptX6oIUtgz6sqQflABEhCCymI6-hBGw,6276
+logger_36-2024.29.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
+logger_36-2024.29.dist-info/top_level.txt,sha256=sM95BTMWmslEEgR_1pzwZsOeSp8C_QBiu8ImbFr0XLc,10
+logger_36-2024.29.dist-info/RECORD,,

{logger_36-2024.28.dist-info → logger_36-2024.29.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.1.0)
+Generator: setuptools (75.2.0)
 Root-Is-Purelib: true
 Tag: py3-none-any