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

logger_36/task/format/memory.py

@@ -5,7 +5,7 @@ SEE COPYRIGHT NOTICE BELOW
 """
 
 from logger_36.constant.memory import STORAGE_UNITS, storage_units_h
-from logger_36.task.format.message import FormattedMessage
+from logger_36.task.format.message import MessageWithActualExpected
 
 _KILO_UNIT = 1000.0
 _MEGA_UNIT = _KILO_UNIT * 1000.0
@@ -41,7 +41,7 @@ def FormattedUsage(
         value, unit = FormattedUsageWithAutoUnit(usage, decimals)
     else:
         raise ValueError(
-            FormattedMessage(
+            MessageWithActualExpected(
                 "Invalid unit", actual=unit, expected=str(STORAGE_UNITS)[1:-1]
             )
         )

logger_36/task/format/message.py

@@ -7,35 +7,11 @@ SEE COPYRIGHT NOTICE BELOW
 import difflib as diff
 import typing as h
 
-from logger_36.config.message import (
-    ELAPSED_TIME_FORMAT,
-    LEVEL_CLOSING,
-    LEVEL_OPENING,
-    MEMORY_FORMAT,
-    MESSAGE_MARKER,
-)
 from logger_36.constant.generic import NOT_PASSED
 from logger_36.constant.message import expected_op_h
 
 
-def MessageFormat(with_where: bool, with_memory_usage: bool, /) -> str:
-    """"""
-    output = [
-        f"%(asctime)s"
-        f"{LEVEL_OPENING}%(level_first_letter)s{LEVEL_CLOSING}\t"
-        f"{MESSAGE_MARKER}%(message)s"
-    ]
-
-    if with_where:
-        output.append("%(where)s")
-    output.append(ELAPSED_TIME_FORMAT)
-    if with_memory_usage:
-        output.append(MEMORY_FORMAT)
-
-    return "".join(output)
-
-
-def FormattedMessage(
+def MessageWithActualExpected(
     message: str,
     /,
     *,

logger_36/task/format/rule.py

@@ -14,8 +14,8 @@ def RuleAsText(text: str | None, /) -> str:
 
 
 try:
-    from rich.rule import Rule as rule_t
-    from rich.text import Text as text_t
+    from rich.rule import Rule as rule_t  # noqa
+    from rich.text import Text as text_t  # noqa
 
     def Rule(text: str | None, color: str, /) -> rule_t | str:
         """"""

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/task/measure/memory.py

@@ -5,7 +5,7 @@ SEE COPYRIGHT NOTICE BELOW
 """
 
 try:
-    from psutil import Process as process_t
+    from psutil import Process as process_t  # noqa
 
     _PROCESS = process_t()
 except ModuleNotFoundError:

logger_36/task/storage.py

@@ -12,7 +12,7 @@ from html.parser import HTMLParser as html_parser_t
 from pathlib import Path as path_t
 
 try:
-    from rich.console import Console as console_t
+    from rich.console import Console as console_t  # noqa
 except ModuleNotFoundError:
     console_t = None
 

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,48 @@ 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.handler import ANONYMOUS
 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 +63,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 +78,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 +106,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 +116,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 +144,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,69 +173,94 @@ 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
+            name = handler.name
+            if (name is None) or (name.__len__() == 0):
+                name = ANONYMOUS
         else:
-            show_memory_usage = getattr(extension, SHOW_MEMORY_ATTR, False)
-        if show_memory_usage:
-            self.any_handler_shows_memory = True
+            name = getattr(extension, "name", ANONYMOUS)
+            if getattr(extension, STORE_MEMORY_ATTR, False):
+                self.any_handler_stores_memory = True
+
+        path = getattr(handler, "baseFilename", "")
+        if isinstance(path, path_t) or (path.__len__() > 0):
+            path = f"\nPath: {path}"
 
-        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,
+            f'New handler "{name}" of type "{type(handler).__name__}" and '
+            f"level {handler.level}={lggg.getLevelName(handler.level)}{path}",
         )
 
     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)
-            )
+        elapsed_time, now = ElapsedTime(should_return_now=True)
 
-            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 +268,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 +288,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 +398,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 +420,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 +450,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 +479,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.30"
 
 """
 COPYRIGHT NOTICE

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

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