logger-36 2025.21__py3-none-any.whl → 2025.22__py3-none-any.whl

logger_36/catalog/config/optional.py

@@ -8,11 +8,20 @@ try:
     import rich  # noqa
 except ModuleNotFoundError:
     RICH_IS_AVAILABLE = False
-    from logger_36.constant.error import MISSING_RICH_MESSAGE
+    from logger_36.constant.error import MISSING_RICH_MESSAGE  # noqa
 else:
     RICH_IS_AVAILABLE = True
     MISSING_RICH_MESSAGE = None
 
+from logger_36.task.measure.memory import CanCheckUsage as CanCheckMemoryUsage
+
+if CanCheckMemoryUsage():
+    MEMORY_MEASURE_IS_AVAILABLE = True
+    MEMORY_MEASURE_ERROR = None
+else:
+    MEMORY_MEASURE_IS_AVAILABLE = False
+    from logger_36.constant.error import MEMORY_MEASURE_ERROR  # noqa
+
 """
 COPYRIGHT NOTICE
 

logger_36/catalog/handler/console.py

@@ -29,7 +29,7 @@ class console_handler_t(base_t):
         """"""
         s.__stdout__.write(self.MessageFromRecord(record)[0] + "\n")
 
-    def EmitAsIs(self, message: str, /) -> None:
+    def EmitMessage(self, message: str, /) -> None:
         """"""
         s.__stdout__.write(message + "\n")
 

logger_36/catalog/handler/console_rich.py

@@ -96,7 +96,7 @@ class console_rich_handler_t(base_t):
         """"""
         return cls(name, message_width, level, kwargs)
 
-    def Rule(self, text: str | None, /, *, color: str = "black") -> str | rule_t:
+    def Rule(self, /, *, text: str | None = None, color: str = "black") -> str | rule_t:
         """"""
         if text is None:
             return rule_t(style=color)
@@ -116,7 +116,7 @@ class console_rich_handler_t(base_t):
         self.console.print(message, crop=False, overflow="ignore")
         self._log_parity = not self._log_parity
 
-    def EmitAsIs(self, message: str | renderable_t, /) -> None:
+    def EmitMessage(self, message: str | renderable_t, /) -> None:
         """"""
         self.console.print(message, crop=False, overflow="ignore")
 

logger_36/catalog/handler/file.py

@@ -32,7 +32,7 @@ class file_handler_t(base_t):
         self.stream.write(output[0] + "\n")
         self.stream.flush()
 
-    def EmitAsIs(self, message: str, /) -> None:
+    def EmitMessage(self, message: str, /) -> None:
         """"""
         self.stream.write(message + "\n")
         self.stream.flush()

logger_36/catalog/handler/generic.py

@@ -38,10 +38,10 @@ class generic_handler_t(base_t):
         self, name: str | None, message_width: int, level: int, kwargs
     ) -> None:
         """
-        EmitAsIs: By definition, the generic handler does not know how to output
+        EmitMessage: By definition, the generic handler does not know how to output
         messages. If not passed, it defaults to output-ing messages in the console.
         """
-        EmitAsIs = kwargs.pop("EmitAsIs", None)
+        EmitMessage = kwargs.pop(base_t.EmitMessage.__name__, None)
         alternating_logs = kwargs.pop("alternating_logs", 0)
         supports_html = kwargs.pop("supports_html", False)
 
@@ -49,8 +49,8 @@ class generic_handler_t(base_t):
 
         base_t.__init__(self, name, message_width, None, level, kwargs)
 
-        if EmitAsIs is not None:
-            self.EmitAsIs = EmitAsIs
+        if EmitMessage is not None:
+            self.EmitMessage = EmitMessage
         self.is_rich = False
         self.console = None  # console_t | None.
         self.console_options = None  # rich.console.ConsoleOptions | None.
@@ -82,14 +82,14 @@ class generic_handler_t(base_t):
         """"""
         return cls(name, message_width, level, kwargs)
 
-    def Rule(self, text: str | None, /, *, color: str = "black") -> str | rule_t:
+    def Rule(self, /, *, text: str | None = None, color: str = "black") -> str | rule_t:
         """"""
         if self.is_rich:
             if text is None:
                 return rule_t(style=color)
             return rule_t(title=text_t(text, style=f"bold {color}"), style=color)
 
-        return base_t.Rule(self, text, color=color)
+        return base_t.Rule(self, text=text, color=color)
 
     def emit(self, record: l.LogRecord, /) -> None:
         """"""
@@ -131,7 +131,7 @@ class generic_handler_t(base_t):
         else:
             message = self.MessageFromRecord(record)[0]
 
-        self.EmitAsIs(message)
+        self.EmitMessage(message)
         self._log_parity = not self._log_parity
 
 

logger_36/constant/record.py

@@ -4,8 +4,11 @@ Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2023
 SEE COPYRIGHT NOTICE BELOW
 """
 
-SHOW_W_RULE_ATTR = "should_show_w_rule"
+INTERNAL_INFO_ATTR = "internal_info"
 SHOW_WHERE_ATTR = "should_show_where"
+SHOW_W_RULE_ATTR = "should_show_w_rule"
+WHEN_OR_ELAPSED_ATTR = "when_or_elapsed"
+WHERE_ATTR = "where"
 
 """
 COPYRIGHT NOTICE

logger_36/type/handler.py

@@ -16,7 +16,7 @@ from logger_36.config.message import (
     WHERE_SEPARATOR,
 )
 from logger_36.constant.message import NEXT_LINE_PROLOGUE
-from logger_36.constant.record import SHOW_W_RULE_ATTR
+from logger_36.constant.record import SHOW_W_RULE_ATTR, WHEN_OR_ELAPSED_ATTR, WHERE_ATTR
 from logger_36.constant.rule import (
     DEFAULT_RULE,
     DEFAULT_RULE_LENGTH,
@@ -66,7 +66,7 @@ class extension_t:
             message = self.PreProcessedMessage(message)
 
         if hasattr(record, SHOW_W_RULE_ATTR):
-            return self.Rule(message, color=rule_color), False
+            return self.Rule(text=message, color=rule_color), False
 
         if (self.message_width <= 0) or (message.__len__() <= self.message_width):
             if "\n" in message:
@@ -78,11 +78,11 @@ class extension_t:
                 lines = WrappedLines([message], self.message_width)
             message = NEXT_LINE_PROLOGUE.join(lines)
 
-        when_or_elapsed = getattr(record, "when_or_elapsed", None)
+        when_or_elapsed = getattr(record, WHEN_OR_ELAPSED_ATTR, None)
         if when_or_elapsed is None:
             return message, True
 
-        if (where := getattr(record, "where", None)) is None:
+        if (where := getattr(record, WHERE_ATTR, None)) is None:
             where = ""
         else:
             where = f"{NEXT_LINE_PROLOGUE}{WHERE_SEPARATOR} {where}"
@@ -93,7 +93,7 @@ class extension_t:
             f"{MESSAGE_MARKER} {message}{where}"
         ), True
 
-    def Rule(self, text: str | None, /, *, color: str = "black") -> str | h.Any:
+    def Rule(self, /, *, text: str | None = None, color: str = "black") -> str | h.Any:
         """
         Return type hint h.Any: For Rich, for example.
         """
@@ -113,13 +113,13 @@ class extension_t:
 
         return f"{half_rule} {text} {half_rule}"
 
-    def EmitAsIs(self, message: str, /) -> None:
+    def EmitMessage(self, message: str, /) -> None:
         """"""
         raise NotImplementedError
 
     def EmitRule(self, /, *, text: str | None = None, color: str = "black") -> None:
         """"""
-        self.EmitAsIs(self.Rule(text, color=color))
+        self.EmitMessage(self.Rule(text=text, color=color))
 
 
 class handler_t(l.Handler, extension_t):

logger_36/type/logger.py

@@ -19,7 +19,12 @@ from os import sep as FOLDER_SEPARATOR
 from pathlib import Path as path_t
 from traceback import TracebackException as traceback_t
 
-from logger_36.catalog.config.optional import MISSING_RICH_MESSAGE, RICH_IS_AVAILABLE
+from logger_36.catalog.config.optional import (
+    MEMORY_MEASURE_ERROR,
+    MEMORY_MEASURE_IS_AVAILABLE,
+    MISSING_RICH_MESSAGE,
+    RICH_IS_AVAILABLE,
+)
 from logger_36.catalog.handler.console import console_handler_t
 from logger_36.catalog.handler.file import file_handler_t
 from logger_36.config.issue import ISSUE_CONTEXT_END, ISSUE_CONTEXT_SEPARATOR
@@ -30,17 +35,19 @@ from logger_36.config.message import (
     TIME_FORMAT,
     WHERE_SEPARATOR,
 )
-from logger_36.constant.error import MEMORY_MEASURE_ERROR
 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 WARNING_LOGGER_NAME, WARNING_TYPE_COMPILED_PATTERN
 from logger_36.constant.memory import UNKNOWN_MEMORY_USAGE
 from logger_36.constant.message import LINE_INDENT, TIME_LENGTH_m_1, expected_op_h
 from logger_36.constant.path import PROJECT_FILE_RELATIVE, USER_FOLDER
-from logger_36.constant.record import SHOW_W_RULE_ATTR, SHOW_WHERE_ATTR
+from logger_36.constant.record import (
+    INTERNAL_INFO_ATTR,
+    SHOW_W_RULE_ATTR,
+    SHOW_WHERE_ATTR,
+)
 from logger_36.task.format.message import MessageWithActualExpected
 from logger_36.task.measure.chronos import ElapsedTime
-from logger_36.task.measure.memory import CanCheckUsage as CanCheckMemoryUsage
 from logger_36.task.measure.memory import CurrentUsage as CurrentMemoryUsage
 from logger_36.type.handler import any_handler_t as base_handler_t
 from logger_36.type.handler import extension_t as handler_extension_t
@@ -61,7 +68,6 @@ logger_handle_h = logger_handle_raw_h | logger_handle_with_self_h
 
 _DATE_TIME_ORIGIN = date_time_t.fromtimestamp(1970, None)
 _DATE_ORIGIN = _DATE_TIME_ORIGIN.date()
-_MEMORY_MEASURE_ERROR = MEMORY_MEASURE_ERROR
 
 
 @d.dataclass(slots=True, repr=False, eq=False)
@@ -74,16 +80,17 @@ class logger_t(base_t):
     will be missed by an early call of ToggleLogInterceptions. Therefore, passing True
     for activate_log_interceptions only sets _should_activate_log_interceptions to True,
     which is later checked in AddHandler to effectively call ToggleLogInterceptions if
-    _should_hold_messages is False (which normally indicates that the handler about to
+    _warming_up is False (which normally indicates that the handler about to
     be added is the last one).
 
-    _should_hold_messages: Must not be False until at least one handler has been added.
+    _warming_up: Must not be False until at least one handler has been added.
     """
 
     should_record_messages: bool = False
-    should_watch_memory_usage: bool = False
+    should_monitor_memory_usage: bool = False
     exit_on_error: bool = False  # Implies exit_on_critical.
     exit_on_critical: bool = False
+    verbose: bool = False
 
     events: dict[int, int] = d.field(init=False, default_factory=dict)
     recorded: list[tuple[int, str]] = d.field(init=False, default_factory=list)
@@ -98,11 +105,13 @@ class logger_t(base_t):
         init=False, default_factory=dict
     )
     intercepts_exceptions: bool = d.field(init=False, default=False)
-    _should_hold_messages: bool = d.field(init=False, default=True)
-    _should_activate_log_interceptions: bool = d.field(init=False, default=False)
-    _on_hold: list[l.LogRecord] = d.field(init=False, default_factory=list)
     _recording_handler: handler_extension_t | None = d.field(init=False, default=None)
 
+    # Used only until the last handler is added (see AddHandler).
+    _should_activate_log_interceptions: bool = d.field(init=False, default=False)
+    _warming_up: bool = d.field(init=False, default=True)
+    _on_hold: list[l.LogRecord] | None = d.field(init=False, default_factory=list)
+
     name_: d.InitVar[str | None] = None
     level_: d.InitVar[int] = l.NOTSET
     activate_wrn_interceptions: d.InitVar[bool] = True
@@ -156,11 +165,10 @@ class logger_t(base_t):
         activate_exc_interceptions: bool,
     ) -> None:
         """"""
-        global _MEMORY_MEASURE_ERROR
-
         if name_ is None:
             name_ = f"{type(self).__name__}:{hex(id(self))[2:]}"
 
+        self.handle = self._HandleWarmUp
         base_t.__init__(self, name_)
         self.setLevel(level_)
         self.propagate = False  # Part of base_t.
@@ -174,7 +182,10 @@ class logger_t(base_t):
         if self.should_record_messages:
             self.ActivateMessageRecording()
 
-        self.info(f'New logger "{self.name}" for "{PROJECT_FILE_RELATIVE}"')
+        self.info(
+            f'New logger "{self.name}" for "{PROJECT_FILE_RELATIVE}"',
+            extra={INTERNAL_INFO_ATTR: True},
+        )
 
         if activate_wrn_interceptions:
             self.ToggleWarningInterceptions(True)
@@ -183,14 +194,32 @@ class logger_t(base_t):
         if activate_exc_interceptions:
             self.ToggleExceptionInterceptions(True)
 
-        if self.should_watch_memory_usage and not CanCheckMemoryUsage():
-            self.should_watch_memory_usage = False
-            if _MEMORY_MEASURE_ERROR is not None:
-                s.__stderr__.write(_MEMORY_MEASURE_ERROR + "\n")
-                _MEMORY_MEASURE_ERROR = None
+        if self.should_monitor_memory_usage:
+            self.ActivateMemoryUsageMonitoring()
 
-    def handle(self, record: l.LogRecord, /) -> None:
+    def _HandleWarmUp(self, record: l.LogRecord, /) -> None:
         """"""
+        now = ElapsedTime(should_return_now=True)[1]
+        if (date := now.date()) != self.last_message_date:
+            self._AcknowledgeDateChange(date)
+
+        # When.
+        record.when_or_elapsed = (TIME_LENGTH_m_1 + 1) * "."
+        # Where.
+        if record.levelno != l.INFO:
+            _ = _RecordLocation(record, True)
+        # What.
+        if not isinstance(record.msg, str):
+            record.msg = str(record.msg)
+
+        self._on_hold.append(record)
+
+    def _HandleRoutine(self, record: l.LogRecord, /) -> None:
+        """"""
+        is_internal_info = getattr(record, INTERNAL_INFO_ATTR, False)
+        if is_internal_info and not self.verbose:
+            return
+
         elapsed_time, now = ElapsedTime(should_return_now=True)
 
         if (date := now.date()) != self.last_message_date:
@@ -206,19 +235,8 @@ class logger_t(base_t):
 
         # Where.
         should_show_where = getattr(record, SHOW_WHERE_ATTR, record.levelno != l.INFO)
-        if should_show_where or self.should_watch_memory_usage:
-            module = path_t(record.pathname)
-            for path in s.path:
-                if module.is_relative_to(path):
-                    module = module.relative_to(path).with_suffix("")
-                    module = str(module).replace(FOLDER_SEPARATOR, ".")
-                    break
-            else:
-                if module.is_relative_to(USER_FOLDER):
-                    module = module.relative_to(USER_FOLDER)
-            where = f"{module}:{record.funcName}:{record.lineno}"
-            if should_show_where:
-                record.where = where
+        if should_show_where or self.should_monitor_memory_usage:
+            where = _RecordLocation(record, should_show_where)
         else:
             where = None
 
@@ -226,13 +244,9 @@ class logger_t(base_t):
         if not isinstance(record.msg, str):
             record.msg = str(record.msg)
 
-        if self._should_hold_messages:
-            self._on_hold.append(record)
-        else:
-            self._HandleRecord(record)
-        self.events[record.levelno] += 1
+        self._HandleRaw(record)
 
-        if self.should_watch_memory_usage:
+        if self.should_monitor_memory_usage:
             self.memory_usages.append((where, CurrentMemoryUsage()))
 
         if (self.exit_on_critical and (record.levelno is l.CRITICAL)) or (
@@ -242,12 +256,28 @@ class logger_t(base_t):
             # __post_init__ set self.exit_on_critical if self.exit_on_error.
             s.exit(1)
 
-    def _FlushRecordsOnHold(self) -> None:
+    def _HandleRaw(self, record: l.LogRecord, /) -> None:
         """"""
+        if self.should_record_messages:
+            message = self._recording_handler.MessageFromRecord(record)[0]
+            self.recorded.append((record.levelno, message))
+
+        base_t.handle(self, record)
+        self.events[record.levelno] += 1
+
+    def _FlushRecordsOnHold(self) -> None:
+        """
+        should_record_messages and verbose must have been set by now.
+        """
         for held in self._on_hold:
-            self._HandleRecord(held)
+            if self.verbose or not getattr(held, INTERNAL_INFO_ATTR, False):
+                self._HandleRaw(held)
 
         self._on_hold.clear()
+        self._on_hold = None
+        self._warming_up = False
+
+        self.handle = self._HandleRoutine
 
     def _AcknowledgeDateChange(self, date: date_t, /) -> None:
         """"""
@@ -262,24 +292,32 @@ class logger_t(base_t):
             }
         )
 
-        if self._should_hold_messages:
+        if self._warming_up:
             self._on_hold.append(record)
         else:
-            self._HandleRecord(record)
-
-    def _HandleRecord(self, record: l.LogRecord, /) -> None:
-        """"""
-        if self.should_record_messages:
-            message = self._recording_handler.MessageFromRecord(record)[0]
-            self.recorded.append((record.levelno, message))
-
-        base_t.handle(self, record)
+            self._HandleRaw(record)
 
     def ActivateMessageRecording(self) -> None:
         """"""
         self._recording_handler = handler_extension_t("recording_handler", 0, None)
         self.should_record_messages = True  # Useless if called from __post_init__.
-        self.info(f'Message recording activated for logger "{self.name}"')
+        self.info(
+            f'Message recording activated for logger "{self.name}"',
+            extra={INTERNAL_INFO_ATTR: True},
+        )
+
+    def ActivateMemoryUsageMonitoring(self) -> None:
+        """"""
+        if MEMORY_MEASURE_IS_AVAILABLE:
+            # Useless if called from __post_init__.
+            self.should_monitor_memory_usage = True
+            self.info(
+                f'Memory usage monitoring activated for logger "{self.name}"',
+                extra={INTERNAL_INFO_ATTR: True},
+            )
+        else:
+            self.should_monitor_memory_usage = False
+            self.error(MEMORY_MEASURE_ERROR)
 
     def ResetEventCounts(self) -> None:
         """"""
@@ -297,7 +335,7 @@ class logger_t(base_t):
             logger.handle = t.MethodType(_HandleForWarnings(self), logger)
 
             l.captureWarnings(True)
-            self.info("Warning Interception: ON")
+            self.info("Warning Interception: ON", extra={INTERNAL_INFO_ATTR: True})
         else:
             if not self.intercepts_warnings:
                 return
@@ -307,7 +345,7 @@ class logger_t(base_t):
             self.intercepted_wrn_handle = None
 
             l.captureWarnings(False)
-            self.info("Warning Interception: OFF")
+            self.info("Warning Interception: OFF", extra={INTERNAL_INFO_ATTR: True})
 
     def ToggleLogInterceptions(self, state: bool, /) -> None:
         """"""
@@ -331,7 +369,10 @@ class logger_t(base_t):
             intercepted = sorted(self.intercepted_log_handles.keys())
             if intercepted.__len__() > 0:
                 as_str = ", ".join(intercepted)
-                self.info(f"Now Intercepting LOGs from: {as_str}")
+                self.info(
+                    f"Now Intercepting LOGs from: {as_str}",
+                    extra={INTERNAL_INFO_ATTR: True},
+                )
         else:
             if not self.intercepts_logs:
                 return
@@ -340,7 +381,7 @@ class logger_t(base_t):
                 logger = l.getLogger(name)
                 logger.handle = handle
             self.intercepted_log_handles.clear()
-            self.info("Log Interception: OFF")
+            self.info("Log Interception: OFF", extra={INTERNAL_INFO_ATTR: True})
 
     def ToggleExceptionInterceptions(self, state: bool, /) -> None:
         """"""
@@ -351,7 +392,7 @@ class logger_t(base_t):
             s.excepthook = self.DealWithException
             thrd.excepthook = self.DealWithExceptionInThread
             self.intercepts_exceptions = True
-            self.info("Exception Interception: ON")
+            self.info("Exception Interception: ON", extra={INTERNAL_INFO_ATTR: True})
         else:
             if not self.intercepts_exceptions:
                 return
@@ -359,7 +400,7 @@ class logger_t(base_t):
             s.excepthook = s.__excepthook__
             thrd.excepthook = thrd.__excepthook__
             self.intercepts_exceptions = False
-            self.info("Exception Interception: OFF")
+            self.info("Exception Interception: OFF", extra={INTERNAL_INFO_ATTR: True})
 
     def AddHandler(
         self,
@@ -372,7 +413,7 @@ class logger_t(base_t):
         name: str | None = None,
         level: int = l.INFO,
         message_width: int = -1,
-        should_still_hold_messages: bool = False,
+        this_is_last_handler: bool = True,
         **kwargs,
     ) -> None:
         """
@@ -380,12 +421,11 @@ class logger_t(base_t):
         """
         should_flush_on_hold = False
         new_handler_warning = ""
-        if self._should_hold_messages and not should_still_hold_messages:
+        if self._warming_up and this_is_last_handler:
             if self._should_activate_log_interceptions:
                 self.ToggleLogInterceptions(True)
                 self._should_activate_log_interceptions = False
 
-            self._should_hold_messages = False
             should_flush_on_hold = True
             new_handler_warning = "\n(Handlers added from now on will miss above logs.)"
 
@@ -397,32 +437,33 @@ class logger_t(base_t):
             handler = handler_t_or_handler
         base_t.addHandler(self, handler)
 
+        if self.verbose:
+            path = getattr(handler, "baseFilename", "")
+            if isinstance(path, path_t) or (path.__len__() > 0):
+                path = f"\nPath: {path}"
+            self.info(
+                f'New handler "{handler.name}" of type "{type(handler).__name__}" and '
+                f"level {handler.level}={l.getLevelName(handler.level)}{path}"
+                f"{new_handler_warning}",
+                extra={INTERNAL_INFO_ATTR: True},
+            )
+
         # Wait until after the handler has been added to flush messages on hold.
         if should_flush_on_hold:
             self._FlushRecordsOnHold()
 
-        path = getattr(handler, "baseFilename", "")
-        if isinstance(path, path_t) or (path.__len__() > 0):
-            path = f"\nPath: {path}"
-        self.info(
-            f'New handler "{handler.name}" of type "{type(handler).__name__}" and '
-            f"level {handler.level}={l.getLevelName(handler.level)}{path}"
-            f"{new_handler_warning}"
-        )
-
     def MakeMonochrome(self) -> None:
         """"""
         self.AddHandler(console_handler_t)
 
     def MakeRich(self, *, alternating_logs: int = 0) -> None:
         """"""
-        if MISSING_RICH_MESSAGE is not None:
-            s.__stderr__.write(MISSING_RICH_MESSAGE + "\n")
-
-        if console_rich_handler_t is console_handler_t:
-            handler_kwargs = {}
-        else:
+        if RICH_IS_AVAILABLE:
             handler_kwargs = {"alternating_logs": alternating_logs}
+        else:
+            handler_kwargs = {}
+            self.error(MISSING_RICH_MESSAGE)
+
         self.AddHandler(console_rich_handler_t, **handler_kwargs)
 
     def MakePermanent(self, path: str | path_t, /) -> None:
@@ -509,8 +550,11 @@ class logger_t(base_t):
             message = text.indent(message, LINE_INDENT)
 
         for handler in self.handlers:
-            if (EmitAsIs := getattr(handler, "EmitAsIs", None)) is not None:
-                EmitAsIs(message)
+            EmitMessage = getattr(
+                handler, handler_extension_t.EmitMessage.__name__, None
+            )
+            if EmitMessage is not None:
+                EmitMessage(message)
 
     info_raw = LogAsIs  # To follow the convention of the logging methods info, error...
 
@@ -519,7 +563,8 @@ class logger_t(base_t):
     ) -> None:
         """"""
         for handler in self.handlers:
-            if (EmitRule := getattr(handler, "EmitRule", None)) is not None:
+            EmitRule = getattr(handler, handler_extension_t.EmitRule.__name__, None)
+            if EmitRule is not None:
                 EmitRule(text=message, color=color)
 
     def AddContextLevel(self, new_level: str, /) -> None:
@@ -647,6 +692,26 @@ class logger_t(base_t):
         return False
 
 
+def _RecordLocation(record: l.LogRecord, should_also_store: bool, /) -> str:
+    """"""
+    module = path_t(record.pathname)
+    for path in s.path:
+        if module.is_relative_to(path):
+            module = module.relative_to(path).with_suffix("")
+            module = str(module).replace(FOLDER_SEPARATOR, ".")
+            break
+    else:
+        if module.is_relative_to(USER_FOLDER):
+            module = module.relative_to(USER_FOLDER)
+
+    output = f"{module}:{record.funcName}:{record.lineno}"
+
+    if should_also_store:
+        record.where = output
+
+    return output
+
+
 def _HandleForWarnings(interceptor: base_t, /) -> logger_handle_h:
     """"""
 

logger_36/version.py

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

{logger_36-2025.21.dist-info → logger_36-2025.22.dist-info}/METADATA

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

{logger_36-2025.21.dist-info → logger_36-2025.22.dist-info}/RECORD

@@ -1,5 +1,5 @@
 logger_36/__init__.py,sha256=mK6AD0eWI2Sk42oxleTvsxzYJ28FbHK5WNkpLgAhnNE,2129
-logger_36/version.py,sha256=uq-1uJ3Ttvm7hNAwg0S3T103Mh6UIamgGGIWFao8YLI,1680
+logger_36/version.py,sha256=WM8W-3pzA_JWd1DQWpdL-uJTAxV5u8_nbyWIlGaizjg,1680
 logger_36/api/content.py,sha256=DuT4UX4r_1DTXzuuRD-tvsTZk5X-Nj11loBKhuWOMw0,1791
 logger_36/api/gpu.py,sha256=NNs1IvQ7bh8Dppm8O8K2YLWbm4rogc3Ie_-D6xzkX3g,1726
 logger_36/api/memory.py,sha256=vOY4cTTrC3u7L0OrKXdPNlsCahYjCrY4h7iqpGZv9kU,2217
@@ -8,11 +8,11 @@ logger_36/api/system.py,sha256=h-3GfhZPwawv0UKBWKkT1LzxSCZwpA2VIsy03lLYi6w,1725
 logger_36/api/time.py,sha256=JG0vgzPSRZ7UWQyoihnVu4sjPC-okFIKA3ZyNh2GaZo,1798
 logger_36/api/type.py,sha256=eLZ2yuH-sYeh4Z2KnAwTRJEbmkmgzBPMncdqXfFUTG8,1760
 logger_36/catalog/config/console_rich.py,sha256=t9p9-AkSgPiLAsm1evAdbz77g7JcVLePhUJ1FzNi3cY,2330
-logger_36/catalog/config/optional.py,sha256=5vabOlEQIFxoT_y4AjP19rpOjBuUJplpuBkLoCIKImA,1872
-logger_36/catalog/handler/console.py,sha256=OKtRG3PseT06_UwZBtbragNIKvCqa7ZsLphYEsgeq2c,2308
-logger_36/catalog/handler/console_rich.py,sha256=b3B_pQefv0IeQFEj-tZ5-tH8RrcessZI8sI4Tyf17bg,6180
-logger_36/catalog/handler/file.py,sha256=JReN8KruN8eKhBfG9sj72kkHfukHK4-8mdSxNpgFhLU,2455
-logger_36/catalog/handler/generic.py,sha256=0Z4Vm-AAc92szghYEzihkm9CBRzCvqgdUTXH_p98S4o,6314
+logger_36/catalog/config/optional.py,sha256=8d8HdpE07gHfsdoL8mVAlRlh9AgLcb4z7I7h6ob7CfU,2174
+logger_36/catalog/handler/console.py,sha256=YEQN8fw7ra9w-5sJACNC4pktv9einm5ASP9TncU8TQo,2311
+logger_36/catalog/handler/console_rich.py,sha256=gPpq8ij1ZFTXaLgISaCTXDDwv7uWPivLeq2ttpiuKlk,6190
+logger_36/catalog/handler/file.py,sha256=yg8GnsV6AmDsx1R5iZlsK-5idqD733gc09Syl02TG7Y,2458
+logger_36/catalog/handler/generic.py,sha256=L8mLc-iQlBWKBqEN3-wIKy2yk_TVgqIWYn_P1hXDsQA,6361
 logger_36/catalog/logger/chronos.py,sha256=S4m9TMPQy_Ju500mpE1jNzu2gZG-QKdVuvX9RVRKHR8,1911
 logger_36/catalog/logger/gpu.py,sha256=Py5YY0nD_pqJzJsEKQYoOGHcPqyNVJ3J2noOS3hDL6g,2890
 logger_36/catalog/logger/memory.py,sha256=J0ZGKO7j1FZA_aDGxpABtvzDy1RjCDiDmWYh4U98fEI,4253
@@ -29,7 +29,7 @@ logger_36/constant/logger.py,sha256=ZQYX9JiPsoivwRgYNtdEqRKCagSKD88lRqvxP8MX1ZE,
 logger_36/constant/memory.py,sha256=Q_E5tTWa-cGaNwrE_xmKa3BxQG6oJO6DHczrxc_M4sE,1817
 logger_36/constant/message.py,sha256=YJOEzdI0ZjUOdHo3CsiS56FVPhrfNoQYvXuUkprH61g,2312
 logger_36/constant/path.py,sha256=OfLh70Jyc8po9Ls34nQh_bRr3PXyQ3kF9ciR9QPhiqI,2213
-logger_36/constant/record.py,sha256=gQCGLxq8Vs789Ty_qaRNKy18mqlyMT_4kyN-T9r_rGE,1734
+logger_36/constant/record.py,sha256=IGWnKA4TGv1oU6ezzNrGocZlB7Ie7nTr4l3IOtwdWOg,1833
 logger_36/constant/rule.py,sha256=tBKQgPTt6G_p5eInDdWoEEAvQFz4WMSt5THsS5jvk14,1779
 logger_36/constant/system.py,sha256=pLlLXG5sepQlSUOo3TphaGrHg8xzJBp-GxpL2NPP47k,1904
 logger_36/extension/html_.py,sha256=W9SyiYsaaYHUrHLGAAN2wiJGXUlwOBJ5gzdjmEcnF18,3342
@@ -42,11 +42,11 @@ logger_36/task/format/memory.py,sha256=J1Oy3jw8wjSp2kuiRUm_VFpzXOHX2FOc7nuRrCyrs
 logger_36/task/format/message.py,sha256=Rm6zymVEEGcgKfmxMPXP7q3PtwZJKlXGhqZ5tnvlwxA,3502
 logger_36/task/measure/chronos.py,sha256=7ijMZgP4EP18HbLV2yCxpNpRS9724Wyk523f-nkbhUM,2529
 logger_36/task/measure/memory.py,sha256=kkPHEIUTUhkCOLrAt01eLJLnsnkl0nFPNhFZdIB_JAw,1991
-logger_36/type/handler.py,sha256=ChxP1j9PXLmoiNcsOdxI4bYVdr75v7HeCWp_iYJ2WNY,6602
+logger_36/type/handler.py,sha256=4LCFZzI4OEH6lVBrBQ09ZIvF0nq-_j7OOVnujBDyDWA,6665
 logger_36/type/issue.py,sha256=QHAYf7QgrjJUtF2D46z6X630qTgeP_0FE5hIwf54RsE,2688
-logger_36/type/logger.py,sha256=-cEc56RRpYkXaoDjI7PF7q14Mamdc4zu3DmQ-lRjIn8,25823
+logger_36/type/logger.py,sha256=b2F21M5z1hwPdDsyHgBIlC06X9-_7zsjqyGEsVaIJgM,27536
 logger_36/type/loggers.py,sha256=7EX7Sg_RlduBjdfFlNZmUfNeDloH1xU30Rdkg_-rXh8,3172
-logger_36-2025.21.dist-info/METADATA,sha256=bTX5e3Xn8lko_GnzpFd7XnE60aNUv6V_9JyoLwzE2G4,6529
-logger_36-2025.21.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-logger_36-2025.21.dist-info/top_level.txt,sha256=sM95BTMWmslEEgR_1pzwZsOeSp8C_QBiu8ImbFr0XLc,10
-logger_36-2025.21.dist-info/RECORD,,
+logger_36-2025.22.dist-info/METADATA,sha256=xcPkxJFWNYEIXgspK2VCcU4LbsME8hlmFQjASmR-3KM,6529
+logger_36-2025.22.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+logger_36-2025.22.dist-info/top_level.txt,sha256=sM95BTMWmslEEgR_1pzwZsOeSp8C_QBiu8ImbFr0XLc,10
+logger_36-2025.22.dist-info/RECORD,,