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

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__ = "2023.13"
+__version__ = "2024.2"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: logger-36
-Version: 2023.13
+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-2023.13.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
 

logger_36/type/generic.py

@@ -1,116 +0,0 @@
-# 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 logging as lggg
-from typing import Callable, Protocol
-
-from rich.console import Console as console_t
-from rich.markup import escape as PreProcessedForRich
-from rich.terminal_theme import DEFAULT_TERMINAL_THEME
-
-from logger_36.type.console import console_handler_t
-from logger_36.type.extension import handler_extension_t
-
-
-class can_show_message_p(Protocol):
-    def Show(self, message: str, /) -> None:
-        ...
-
-
-class generic_handler_t(lggg.Handler, handler_extension_t):
-    __slots__ = ("console", "Show")
-    console: console_t | None
-    Show: Callable[[str], None]
-
-    def __init__(
-        self,
-        interface: can_show_message_p | Callable[[str], None],
-        /,
-        *args,
-        supports_html: bool = False,
-        **kwargs,
-    ) -> None:
-        """"""
-        lggg.Handler.__init__(self, *args, **kwargs)
-        handler_extension_t.__init__(self)
-
-        if supports_html:
-            self.console = console_t(
-                tab_size=console_handler_t.TAB_SIZE,
-                highlight=False,
-                force_terminal=True,
-            )
-        else:
-            self.console = None
-        if hasattr(interface, "Show"):
-            self.Show = interface.Show
-        else:
-            self.Show = interface
-        self.setFormatter(self.formatter)
-
-    def emit(self, record: lggg.LogRecord, /) -> None:
-        """"""
-        if self.console is None:
-            message, _ = self.MessageLines(record, should_fully_format=True)
-        else:
-            first_line, next_lines = self.MessageLines(
-                record, PreProcessed=PreProcessedForRich
-            )
-            highlighted = console_handler_t.HighlightedVersion(
-                first_line, next_lines, record.levelno
-            )
-            segments = self.console.render(highlighted)
-
-            # Inspired from the code of: rich.console.export_html.
-            html_segments = []
-            for text, style, _ in segments:
-                if text == "\n":
-                    html_segments.append("\n")
-                else:
-                    if style is not None:
-                        style = style.get_html_style(DEFAULT_TERMINAL_THEME)
-                        if (style is not None) and (style.__len__() > 0):
-                            text = f'<span style="{style}">{text}</span>'
-                    html_segments.append(text)
-            if html_segments[-1] == "\n":
-                html_segments = html_segments[:-1]
-
-            # /!\ For some reason, the widget splits the message into lines, place each line
-            # inside a pre tag, and set margin-bottom of the first and list lines to 12px.
-            # This can be seen by printing self.contents.toHtml(). To avoid the unwanted
-            # extra margins, margin-bottom is set to 0 below.
-            message = (
-                "<pre style='margin-bottom:0px'>" + "".join(html_segments) + "</pre>"
-            )
-
-        self.Show(message)
-
-        self.ExitOrNotIfError(record)

logger_36-2023.13.dist-info/RECORD

@@ -1,16 +0,0 @@
-logger_36/__init__.py,sha256=UtQbi5wL1lW-C1kJ4ADgX79belpJGnih3SS0291baAc,1782
-logger_36/config.py,sha256=uygYJ4rYnBnXKmKXdlQ3RjaRg50Yx2IIq4sCrhzdj8w,2295
-logger_36/constant.py,sha256=avAF1WLC_KZQ7d9opLY90L9s9Sr9BhzFIAX2o3QIXY8,2404
-logger_36/main.py,sha256=IEVhspokomwGR40w5bO8aP5wzYivYc1BAp2_pwsvKPQ,6302
-logger_36/version.py,sha256=odgsu8D49CDnQqs51FIFaHYus8iLmO6XLfpg2L5CTGY,1576
-logger_36/measure/chronos.py,sha256=absTi1vArUQYxDKdebgjwijT7xunb5uenIj7pT96Maw,2113
-logger_36/measure/memory.py,sha256=N6Y6Qwu1wSQygSMZqREpwdmBFhd280H_ix3k-uGa-Ss,3241
-logger_36/task/inspection.py,sha256=pVry624aFjIuiV97AGm_gBvW2QCQvDl-qTnoCKZoVL4,4127
-logger_36/type/console.py,sha256=jZfXsn6TQNk2nWXgFIHIi__-5bejqmKkVMLhieIDlLc,4862
-logger_36/type/extension.py,sha256=l7ifJGUkji2HLH3g4gojEVLjVZ9djmC6hr3lxV1Rr9s,4812
-logger_36/type/file.py,sha256=OLBcnrnQAkIKkVa-qssXMJVdY8kzOmjzQnO9k4NM-sc,2224
-logger_36/type/generic.py,sha256=TSK5kQxfhT3NJL4ZQrXB-zO-EWIdK9iztIE_D4GDRWs,4544
-logger_36-2023.13.dist-info/METADATA,sha256=Sdrq3a8VZaA2GMU_sNGSPoEmwzar4a08whNy3C5L-c8,4242
-logger_36-2023.13.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-logger_36-2023.13.dist-info/top_level.txt,sha256=sM95BTMWmslEEgR_1pzwZsOeSp8C_QBiu8ImbFr0XLc,10
-logger_36-2023.13.dist-info/RECORD,,