logger-36 2024.1__py3-none-any.whl → 2024.2__py3-none-any.whl

logger_36/type/extension.py

@@ -29,94 +29,106 @@
 # The fact that you are presently reading this means that you have had
 # knowledge of the CeCILL license and that you accept its terms.
 
+import dataclasses as dtcl
 import logging as lggg
 import sys as sstm
-from typing import Callable
+import typing as h
 
-from logger_36.catalog.memory import WithAutoUnit as MemoryWithAutoUnit
-from logger_36.config import DATE_TIME_FORMAT, MESSAGE_FORMAT
-from logger_36.constant import LOG_LEVEL_LENGTH, NEXT_LINE_PROLOGUE
-from logger_36.measure.chronos import ElapsedTime
-from logger_36.measure.memory import CurrentUsage as CurrentMemoryUsage
+from logger_36.config.message import TIME_FORMAT, WHERE_FORMAT
+from logger_36.constant.handler import HANDLER_CODES
+from logger_36.constant.memory import MEMORY_MEASURE_ERROR
+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.measure.chronos import TimeStamp
+from logger_36.task.measure.memory import CanCheckMemory
 
 
+@dtcl.dataclass(slots=True, repr=False, eq=False)
 class handler_extension_t:
-    __slots__ = ("formatter", "show_memory_usage", "max_memory_usage", "exit_on_error")
-    formatter: lggg.Formatter
-    show_memory_usage: bool
-    max_memory_usage: int
-    exit_on_error: bool
+    name: str | None = None
+    show_where: bool = True
+    show_memory_usage: bool = False
+    FormattedRecord: h.Callable[[lggg.LogRecord], str] = dtcl.field(init=False)
 
-    def __init__(self) -> None:
+    handler: dtcl.InitVar[lggg.Handler | None] = None
+    level: dtcl.InitVar[int] = lggg.NOTSET
+    formatter: dtcl.InitVar[lggg.Formatter | None] = None
+
+    def __post_init__(
+        self, handler: lggg.Handler | None, level: int, formatter: lggg.Formatter | None
+    ) -> None:
         """"""
-        self.formatter = lggg.Formatter(fmt=MESSAGE_FORMAT, datefmt=DATE_TIME_FORMAT)
-        self.show_memory_usage = False
-        self.max_memory_usage = -1
-        self.exit_on_error = False
+        if self.name in HANDLER_CODES:
+            raise ValueError(
+                FormattedMessage(
+                    "Invalid handler name",
+                    actual=self.name,
+                    expected=f"a name not in {str(HANDLER_CODES)[1:-1]}",
+                )
+            )
+
+        if self.name is None:
+            self.name = TimeStamp()
+
+        if self.show_memory_usage and not CanCheckMemory():
+            self.show_memory_usage = False
+            print(MEMORY_MEASURE_ERROR, file=sstm.stderr)
+
+        handler.setLevel(level)
 
-    def MessageLines(
+        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
+
+    def FormattedLines(
         self,
         record: lggg.LogRecord,
         /,
         *,
-        PreProcessed: Callable[[str], str] | None = None,
-        should_fully_format: bool = False,
+        PreProcessed: h.Callable[[str], str] | None = None,
+        should_join_lines: bool = False,
     ) -> tuple[str, str | None]:
         """
-        Note: "message" is not yet an attribute of record (it will be set by format());
-        Use "msg" instead.
+        See logger_36.catalog.handler.README.txt.
         """
-        if not isinstance(record.msg, str):
-            record.msg = str(record.msg)
+        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:
-            record.msg = PreProcessed(record.msg)
-        if "\n" in record.msg:
-            original_message = record.msg
-            lines = original_message.splitlines()
-            record.msg = lines[0]
+            message = PreProcessed(message)
+        if "\n" in message:
+            lines = message.splitlines()
             next_lines = NEXT_LINE_PROLOGUE.join(lines[1:])
             next_lines = f"{NEXT_LINE_PROLOGUE}{next_lines}"
+            message = lines[0]
         else:
-            original_message = next_lines = None
-
-        # The record is shared between handlers, so do not re-assign if already there.
-        if not hasattr(record, "elapsed_time"):
-            record.elapsed_time = ElapsedTime()
-        # Re-assign for each handler in case they have different show properties.
-        if self.show_memory_usage:
-            record.memory_usage = self.FormattedMemoryUsage()
-        else:
-            record.memory_usage = ""
+            next_lines = None
 
-        padding = (LOG_LEVEL_LENGTH - record.levelname.__len__() - 1) * " "
-        first_line = self.formatter.format(record).replace("\t", padding)
+        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 = ""
+            else:
+                record.where = WHERE_FORMAT.format(
+                    module=record.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.
-        if original_message is not None:
-            record.msg = original_message
+        record.msg = original_message
 
-        if should_fully_format:
+        if should_join_lines:
             if next_lines is None:
                 return first_line, None
             else:
                 return f"{first_line}{next_lines}", None
         else:
             return first_line, next_lines
-
-    def FormattedMemoryUsage(self) -> str:
-        """"""
-        if self.show_memory_usage:
-            usage = CurrentMemoryUsage()
-            if usage > self.max_memory_usage:
-                self.max_memory_usage = usage
-
-            usage, unit = MemoryWithAutoUnit(usage, 1)
-
-            return f" :{usage}{unit}"
-        else:
-            return ""
-
-    def ExitOrNotIfError(self, record: lggg.LogRecord, /) -> None:
-        """"""
-        if self.exit_on_error and (record.levelno in (lggg.ERROR, lggg.CRITICAL)):
-            sstm.exit(1)

logger_36/type/issue.py

@@ -0,0 +1,57 @@
+# Copyright CNRS/Inria/UCA
+# Contributor(s): Eric Debreuve (since 2023)
+#
+# eric.debreuve@cnrs.fr
+#
+# 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.
+
+import typing as h
+
+from logger_36.config.issue import BASE_CONTEXT
+from logger_36.constant.generic import NOT_PASSED
+from logger_36.task.format.message import FormattedMessage
+
+issue_t = str
+
+
+def NewIssue(
+    context: str,
+    separator: str,
+    message: str,
+    /,
+    *,
+    actual: h.Any = NOT_PASSED,
+    expected: h.Any | None = None,
+) -> issue_t:
+    """"""
+    if context.__len__() == 0:
+        context = BASE_CONTEXT
+    message = FormattedMessage(
+        message, actual=actual, expected=expected, with_final_dot=False
+    )
+
+    return f"{context}{separator}{message}"

logger_36/type/logger.py

@@ -0,0 +1,349 @@
+# Copyright CNRS/Inria/UCA
+# Contributor(s): Eric Debreuve (since 2023)
+#
+# eric.debreuve@cnrs.fr
+#
+# 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.
+
+from __future__ import annotations
+
+import dataclasses as dtcl
+import logging as lggg
+import sys as sstm
+import types as t
+import typing as h
+from datetime import datetime as dttm
+from pathlib import Path as path_t
+from traceback import TracebackException as traceback_t
+
+from logger_36.config.message import DATE_FORMAT, INTERCEPTED_LOG_SEPARATOR
+from logger_36.constant.generic import NOT_PASSED
+from logger_36.constant.issue import 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.record import SHOW_MEMORY_ATTR, SHOW_W_RULE_ATTR
+from logger_36.task.format.memory import (
+    FormattedUsageWithAutoUnit as FormattedMemoryUsage,
+)
+from logger_36.task.format.message import FormattedMessage
+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
+
+
+@dtcl.dataclass(slots=True, repr=False, eq=False)
+class logger_t(lggg.Logger):
+    ISSUE_CONTEXT_SEPARATOR: h.ClassVar[str] = ">"
+    ISSUE_CONTEXT_END: h.ClassVar[str] = ":: "
+
+    # Must not be False until at least one handler has been added.
+    should_hold_messages: bool = True
+
+    name: dtcl.InitVar[str] = LOGGER_NAME
+    level: dtcl.InitVar[int] = lggg.NOTSET
+    activate_wrn_interceptions: dtcl.InitVar[bool] = True
+    exit_on_error: bool = False
+
+    on_hold: list[lggg.LogRecord] = dtcl.field(init=False, default_factory=list)
+    last_message_date: str = dtcl.field(init=False, default="")
+    any_handler_shows_memory: bool = dtcl.field(init=False, default=False)
+    memory_usages: list[tuple[str, int]] = dtcl.field(init=False, default_factory=list)
+    context_levels: list[str] = dtcl.field(init=False, default_factory=list)
+    staged_issues: list[issue_t] = dtcl.field(init=False, default_factory=list)
+    intercepted_wrn_handle: logger_handle_h | None = dtcl.field(
+        init=False, default=None
+    )
+    intercepted_log_handles: dict[str, logger_handle_h] = dtcl.field(
+        init=False, default_factory=dict
+    )
+
+    def __post_init__(
+        self, name: str, level: int, activate_wrn_interceptions: bool
+    ) -> None:
+        """"""
+        lggg.Logger.__init__(self, name)
+        self.setLevel(level)
+        self.propagate = False
+
+        if activate_wrn_interceptions:
+            self._ActivateWarningInterceptions()
+
+    def _ActivateWarningInterceptions(self) -> None:
+        """
+        The log message will not appear if called from __post_init__ since there are no
+        handlers yet.
+        """
+        if self.intercepted_wrn_handle is None:
+            logger = lggg.getLogger(WARNING_LOGGER_NAME)
+
+            self.intercepted_wrn_handle = logger.handle
+            logger.handle = t.MethodType(_HandleForWarnings(self), logger)
+
+            lggg.captureWarnings(True)
+            self.info("Warning Interception: ON", **HIDE_WHERE_KWARG)
+
+    def _DeactivateWarningInterceptions(self) -> None:
+        """"""
+        if self.intercepted_wrn_handle is not None:
+            logger = lggg.getLogger(WARNING_LOGGER_NAME)
+
+            logger.handle = self.intercepted_wrn_handle
+            self.intercepted_wrn_handle = None
+
+            lggg.captureWarnings(False)
+            self.info("Warning Interception: OFF", **HIDE_WHERE_KWARG)
+
+    def ToggleWarningInterceptions(self, state: bool, /) -> None:
+        """"""
+        if state:
+            self._ActivateWarningInterceptions()
+        else:
+            self._DeactivateWarningInterceptions()
+
+    def ToggleLogInterceptions(self, state: bool, /) -> None:
+        """"""
+        if state:
+            self.ToggleLogInterceptions(False)
+
+            all_loggers = [lggg.getLogger()] + [
+                lggg.getLogger(_nme)
+                for _nme in self.manager.loggerDict
+                if _nme not in (self.name, WARNING_LOGGER_NAME)
+            ]
+            for logger in all_loggers:
+                self.intercepted_log_handles[logger.name] = logger.handle
+                logger.handle = t.MethodType(
+                    _HandleForInterceptions(logger, self), logger
+                )
+
+            intercepted = sorted(self.intercepted_log_handles.keys())
+            if intercepted.__len__() > 0:
+                self.info(
+                    f"Now Intercepting LOGs from: {str(intercepted)[1:-1]}",
+                    **HIDE_WHERE_KWARG,
+                )
+        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)
+
+    @property
+    def max_memory_usage(self) -> int:
+        """"""
+        return max(tuple(zip(*self.memory_usages))[1])
+
+    @property
+    def max_memory_usage_full(self) -> tuple[str, int]:
+        """"""
+        where_s, usages = zip(*self.memory_usages)
+        max_usage = max(usages)
+
+        return where_s[usages.index(max_usage)], max_usage
+
+    def AddHandler(self, handler: lggg.Handler, should_hold_messages: bool, /) -> None:
+        """"""
+        self.should_hold_messages = should_hold_messages
+        lggg.Logger.addHandler(self, handler)
+
+        extension = getattr(handler, "extension", None)
+        if extension is None:
+            show_memory_usage = False
+        else:
+            show_memory_usage = getattr(extension, SHOW_MEMORY_ATTR, False)
+        if show_memory_usage:
+            self.any_handler_shows_memory = True
+
+        extension = getattr(handler, "extension", handler.name)
+        if isinstance(extension, str):
+            name = extension
+        else:
+            name = getattr(extension, "name", "Anonymous")
+        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()
+
+        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}"
+
+        date = dttm.now().strftime(DATE_FORMAT)
+        if date != self.last_message_date:
+            self.last_message_date = date
+            # levelno is added for management by lggg.Logger.handle.
+            date_record = lggg.makeLogRecord(
+                {
+                    "levelno": lggg.INFO,
+                    "msg": f"DATE: {date}",
+                    SHOW_W_RULE_ATTR: True,
+                }
+            )
+            if self.should_hold_messages:
+                self.on_hold.append(date_record)
+            else:
+                lggg.Logger.handle(self, date_record)
+
+        if self.should_hold_messages:
+            self.on_hold.append(record)
+        else:
+            lggg.Logger.handle(self, record)
+
+        if self.exit_on_error and (record.levelno in (lggg.ERROR, lggg.CRITICAL)):
+            sstm.exit(1)
+
+    def AddContextLevel(self, new_level: str, /) -> None:
+        """"""
+        self.context_levels.append(new_level)
+
+    def AddedContextLevel(self, new_level: str, /) -> logger_t:
+        """
+        Meant to be used as:
+        with self.AddedContextLevel("new level"):
+            ...
+        """
+        self.AddContextLevel(new_level)
+        return self
+
+    def StageIssue(
+        self,
+        message: str,
+        /,
+        *,
+        actual: h.Any = NOT_PASSED,
+        expected: h.Any | None = None,
+    ) -> None:
+        """"""
+        cls = self.__class__
+        context = cls.ISSUE_CONTEXT_SEPARATOR.join(self.context_levels)
+        issue = NewIssue(
+            context, cls.ISSUE_CONTEXT_END, message, actual=actual, expected=expected
+        )
+        self.staged_issues.append(issue)
+
+    @property
+    def has_staged_issues(self) -> bool:
+        """"""
+        return self.staged_issues.__len__() > 0
+
+    def CommitIssues(
+        self,
+        level: int,
+        /,
+        *,
+        order: order_h = "when",
+    ) -> None:
+        """"""
+        if not self.has_staged_issues:
+            return
+
+        if order not in ORDER:
+            raise ValueError(
+                FormattedMessage(
+                    "Invalid commit order",
+                    actual=order,
+                    expected=f"One of {str(ORDER)[1:-1]}",
+                )
+            )
+
+        if order == "when":
+            issues = self.staged_issues
+        else:  # order == "context"
+            issues = sorted(self.staged_issues, key=lambda _elm: _elm.context)
+        issues = "\n".join(issues)
+
+        self.log(level, issues, **HIDE_WHERE_KWARG)
+        self.staged_issues.clear()
+
+    def __enter__(self) -> None:
+        """"""
+        pass
+
+    def __exit__(
+        self,
+        exc_type: Exception | None,
+        exc_value: str | None,
+        traceback: traceback_t | None,
+        /,
+    ) -> bool:
+        """"""
+        _ = self.context_levels.pop()
+        return False
+
+
+def _HandleForWarnings(interceptor: lggg.Logger, /) -> logger_handle_h:
+    """"""
+
+    def handle_p(_: lggg.Logger, record: lggg.LogRecord, /) -> None:
+        pieces = WARNING_TYPE_COMPILED_PATTERN.match(record.msg).group
+        module = path_t(pieces(1)).stem
+        line = pieces(2)
+        kind = pieces(3)
+        message = pieces(4)
+        duplicate = lggg.makeLogRecord(record.__dict__)
+        duplicate.msg = f"{kind}: {message}"
+        duplicate.module = module
+        duplicate.funcName = "<function>"
+        duplicate.lineno = line
+        interceptor.handle(duplicate)
+
+    return handle_p
+
+
+def _HandleForInterceptions(
+    intercepted: lggg.Logger, interceptor: lggg.Logger, /
+) -> logger_handle_h:
+    """"""
+
+    def handle_p(_: lggg.Logger, record: lggg.LogRecord, /) -> None:
+        duplicate = lggg.makeLogRecord(record.__dict__)
+        duplicate.msg = f"{intercepted.name}{INTERCEPTED_LOG_SEPARATOR}{record.msg}"
+        interceptor.handle(duplicate)
+
+    return handle_p

logger_36/version.py

@@ -29,4 +29,4 @@
 # The fact that you are presently reading this means that you have had
 # knowledge of the CeCILL license and that you accept its terms.
 
-__version__ = "2024.1"
+__version__ = "2024.2"

{logger_36-2024.1.dist-info → logger_36-2024.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: logger-36
-Version: 2024.1
+Version: 2024.2
 Summary: Simple logger using rich_
 Home-page: https://src.koda.cnrs.fr/eric.debreuve/logger-36/
 Author: Eric Debreuve
@@ -16,7 +16,6 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Development Status :: 4 - Beta
 Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
-Requires-Dist: rich
 
 ..
    Copyright CNRS/Inria/UCA

logger_36-2024.2.dist-info/RECORD

@@ -0,0 +1,39 @@
+logger_36/__init__.py,sha256=-VGyte6TD6SWU4jBXUjur_xU1R1Asha5KXEwDNmGJ6Q,1756
+logger_36/instance.py,sha256=NQlDAyXV3TNekX9xj9V7JMePmsa2DWnTDaVzh5dcyGM,1616
+logger_36/main.py,sha256=hj3hctMBHJbPWw1078tJ_zOU-6-kEGCzMgHwpWY5ElA,6134
+logger_36/version.py,sha256=k9JK70ov-I4eRm2xjcPqT7aryHlmg6XXYSEUPtNqgU8,1575
+logger_36/catalog/config/console_rich.py,sha256=jJnYXPDsMCTu8zny2X3NdeyKFCfhJupberqIBxyv3LA,2030
+logger_36/catalog/handler/console.py,sha256=PnaCWJsXN-x_-X8i-4o4HWys-7K0A83s4kIdtmDz3AQ,3092
+logger_36/catalog/handler/console_rich.py,sha256=YqKyKwHoYCEVnW1S87NDu3ReTCIzSdYgC-20-813TFQ,5395
+logger_36/catalog/handler/file.py,sha256=BAxA-ZQAikmH0R9Ia3mbSXf-Z60-FfA4ElOVjjmanS0,3507
+logger_36/catalog/handler/generic.py,sha256=1pAmP5vOxBPWhpqoBRDNIc3q14dIDsj7JbX-VqcgUbM,5931
+logger_36/catalog/logging/chronos.py,sha256=5SWyRUhwwKeJg3NPf9jkCqtKc7b_4x58Slbq2iMA8kE,1814
+logger_36/catalog/logging/gpu.py,sha256=OpSQK0paA-xzxeWTKAx9QUqEytFyYvHgiVvWe97-rZ8,2465
+logger_36/catalog/logging/memory.py,sha256=50wX25rXnI8NLlr3gp6793hKUE988CACIXVLMQRUcMs,4038
+logger_36/catalog/logging/system.py,sha256=BzJLBvhyIE5nfUZJo4f1PPmu47YufVyin5ssX9GpXVU,2447
+logger_36/config/issue.py,sha256=cAv4hbikcATtEwMtjgsOcPij8Ylv4XE2dg5hcqaw0FU,1574
+logger_36/config/memory.py,sha256=_cJE_ku9adDk2Pb9jvyQIRilvYRS2uofB8hfTucRrwo,1587
+logger_36/config/message.py,sha256=8AzmioSYDuguK1KN1a84yX0EE-1AnMb7XYgoImtorEA,2056
+logger_36/config/system.py,sha256=d4dddB8IknyGmvOmUdi9Bunc60mEXjwB3AvjyrpCKrY,1847
+logger_36/constant/generic.py,sha256=Tdo8wbhde6hcoB8Xv8AXIkFm4EimOfadDEAacf0j8OE,1614
+logger_36/constant/handler.py,sha256=YoCxN1MTl1c3VuUETjvFKyW_4XM6vwb6BdCUk4Y4_VQ,1681
+logger_36/constant/issue.py,sha256=nq-JDE9pKoshYkXnS-F8R4dlCUCKFQR5w7SwNp-iz30,1656
+logger_36/constant/logger.py,sha256=ze64rQ0oDoC-r0EvX-6qmVN41cG9_vGr7kxrGjtpFvk,2150
+logger_36/constant/memory.py,sha256=9bKK_L4TfNB-Q34qIeTDtDLhQd3p9N0ZHpAmRTXZgJI,1795
+logger_36/constant/message.py,sha256=vT9AukWubfwuQIO10eeR0EMO0Sov9-vLPj95Mg4WPsA,2084
+logger_36/constant/record.py,sha256=79NZCveVyCvwIWOMGmFrdMXsOLdJullguPbY4TB8EZY,1681
+logger_36/constant/system.py,sha256=CLfopBgUhkegE-VQxGRxPMJGanIcK6vkhix8ZzEG5V0,1800
+logger_36/task/inspection.py,sha256=Ozgj_2iQqHEmn6VQPh2rAZJ5233SD1WotFNUOXvukW4,4397
+logger_36/task/storage.py,sha256=y9q8RS_uwxVs89pwecdB7018-4qsgPpAqocAJkhMh-k,5060
+logger_36/task/format/memory.py,sha256=ZeDM6pCMRh81iSifQjiaYHVmKzzR5JhVTqAKd3Dju0U,3610
+logger_36/task/format/message.py,sha256=XAqdR8NWFo-EnzUzaRBFO6jyYb0Su7jCgVQ1HLelxHs,3511
+logger_36/task/format/rule.py,sha256=elNk65Y7HT42otObwfds-DwGwfZae0A77nDPCZuMcGE,1968
+logger_36/task/measure/chronos.py,sha256=qT80jxZm_dAg2P4WkfU0L3PRvRojT21Ps3DtNYqGdrg,2253
+logger_36/task/measure/memory.py,sha256=1f1X-XHd_58LJYJ0Ok5TGIagnf0k5F39IFqWHN2Ojas,1874
+logger_36/type/extension.py,sha256=fsYx0wT1bR6DtpM2VnaxsM0MFv2vBLROgRSCs4duasY,5198
+logger_36/type/issue.py,sha256=4D4e047sHhF3r8YtDj3k50iC5UaSUpXEKMaD9isjspc,2139
+logger_36/type/logger.py,sha256=eIQQiuhicz73ipz-94qGcwxe34sP_HxSgWnFxk78owI,12245
+logger_36-2024.2.dist-info/METADATA,sha256=OFiqvDFojFn_Nog71KVNtDBz_WespEDNYh3u5Ur8ChU,4221
+logger_36-2024.2.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+logger_36-2024.2.dist-info/top_level.txt,sha256=sM95BTMWmslEEgR_1pzwZsOeSp8C_QBiu8ImbFr0XLc,10
+logger_36-2024.2.dist-info/RECORD,,

{logger_36-2024.1.dist-info → logger_36-2024.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.42.0)
+Generator: bdist_wheel (0.43.0)
 Root-Is-Purelib: true
 Tag: py3-none-any