logger-36 2025.24__py3-none-any.whl → 2025.26__py3-none-any.whl

logger_36/task/storage.py

@@ -5,12 +5,17 @@ SEE COPYRIGHT NOTICE BELOW
 """
 
 import logging as l
-import os as o
-import tempfile as tmps
 from io import IOBase as io_base_t
 from pathlib import Path as path_t
 
-from logger_36.constant.html import BODY_PLACEHOLDER, MINIMAL_HTML, TITLE_PLACEHOLDER
+from logger_36.constant.error import CANNOT_SAVE_RECORDS
+from logger_36.constant.html import (
+    BODY_PLACEHOLDER,
+    HTML_SUFFIX,
+    MINIMAL_HTML,
+    TITLE_PLACEHOLDER,
+)
+from logger_36.extension.file import NewTemporaryFile
 from logger_36.instance.logger import L
 from logger_36.type.logger import logger_t
 
@@ -21,60 +26,17 @@ def SaveLOGasHTML(
     """
     From first console handler found.
     """
-    cannot_save = "Cannot save logging record as HTML"
-
-    if path is None:
-        for handler in logger.handlers:
-            if isinstance(handler, l.FileHandler):
-                path = path_t(handler.baseFilename).with_suffix(".htm")
-                break
-        else:
-            logger.warning(f"{cannot_save}: No file handler to build a filename from.")
-            return
-
-        if path.exists():
-            logger.warning(
-                f'{cannot_save}: Automatically generated path "{path}" already exists.'
-            )
-            return
-    elif isinstance(path, str):
-        path = path_t(path)
-
-    actual_file = isinstance(path, path_t)
-
-    if actual_file and path.exists():
-        existing = path
-
-        accessor, path = tmps.mkstemp(suffix=".htm")
-        o.close(accessor)
-        path = path_t(path)
-
+    records = logger_t.Records(logger)
+    if records is None:
         logger.warning(
-            f'File "{existing}" already exists: Saving LOG as HTML in {path} instead.'
+            f"{CANNOT_SAVE_RECORDS}: No handlers with recording capability found"
         )
-
-    for handler in logger.handlers:
-        records = getattr(handler, "records", None)
-        if isinstance(records, list) and (
-            (records.__len__() == 0)
-            or all(
-                isinstance(_, tuple)
-                and isinstance(_[0], int)
-                and isinstance(_[1], dict | str | l.LogRecord)
-                and isinstance(_[2], bool)
-                for _ in records
-            )
-        ):
-            break
-    else:
-        logger.warning(f"{cannot_save}: No handlers with recording capability found.")
         return
-
     if records.__len__() == 0:
         return
 
     if isinstance(records[0][1], str):
-        records = map(_HighlightedEvent, records)
+        records = map(_HighlightedRecord, records)
     else:
         records = map(lambda _: str(_[1]), records)
     body = "\n".join(records)
@@ -82,16 +44,29 @@ def SaveLOGasHTML(
         BODY_PLACEHOLDER, body
     )
 
-    if actual_file:
-        with open(path, "w") as accessor:
-            accessor.write(html)
+    if path is None:
+        path = logger_t.StoragePath(logger, HTML_SUFFIX)
+        logger.info(f'Saving LOG as HTML in "{path}"')
+    elif isinstance(path, str):
+        path = path_t(path)
+        if path.exists():
+            existing = path
+            path = NewTemporaryFile(HTML_SUFFIX)
+            logger.warning(
+                f'File "{existing}" already exists: '
+                f'Saving LOG as HTML in "{path}" instead'
+            )
     else:
         path.write(html)
+        return
+
+    with open(path, "w") as accessor:
+        accessor.write(html)
 
 
-def _HighlightedEvent(event: tuple[int, str, bool], /) -> str:
+def _HighlightedRecord(record: tuple[int, str, bool], /) -> str:
     """"""
-    level, message, is_not_a_rule = event
+    level, message, is_not_a_rule = record
 
     if is_not_a_rule:
         if level == l.DEBUG:

logger_36/type/handler.py

@@ -8,15 +8,14 @@ import logging as l
 import typing as h
 from pathlib import Path as path_t
 
-from logger_36.config.message import (
-    FALLBACK_MESSAGE_WIDTH,
-    LEVEL_CLOSING,
-    LEVEL_OPENING,
-    MESSAGE_MARKER,
-    WHERE_SEPARATOR,
-)
+from logger_36.config.message import FALLBACK_MESSAGE_WIDTH
 from logger_36.config.rule import DEFAULT_RULE_LENGTH, RULE_CHARACTER
-from logger_36.constant.message import NEXT_LINE_PROLOGUE
+from logger_36.constant.message import (
+    NEXT_LINE_PROLOGUE,
+    TIME_PLACEHOLDER,
+    WHERE_PROLOGUE,
+    CONTEXT_LENGTH_p_1,
+)
 from logger_36.constant.record import SHOW_W_RULE_ATTR, WHEN_OR_ELAPSED_ATTR, WHERE_ATTR
 from logger_36.constant.rule import DEFAULT_RULE, MIN_HALF_RULE_LENGTH
 from logger_36.extension.line import WrappedLines
@@ -53,47 +52,46 @@ class extension_t:
 
     def MessageFromRecord(
         self, record: l.LogRecord, /, *, rule_color: str = "black"
-    ) -> tuple[str, bool]:
+    ) -> tuple[str, bool, int | None]:
         """
-        The second returned value is is_not_a_rule.
+        Arguments from second on: is_not_a_rule, where_location.
         """
         message = record.msg  # See logger_36.catalog.handler.README.txt.
         if self.PreProcessedMessage is not None:
             message = self.PreProcessedMessage(message)
 
         if hasattr(record, SHOW_W_RULE_ATTR):
-            return self.Rule(text=message, color=rule_color), False
+            return self.Rule(text=message, color=rule_color), False, None
 
         if (self.message_width <= 0) or (message.__len__() <= self.message_width):
             if "\n" in message:
                 message = NEXT_LINE_PROLOGUE.join(message.splitlines())
         else:
             if "\n" in message:
-                lines = WrappedLines(message.splitlines(), self.message_width)
+                lines = message.splitlines()
             else:
-                lines = WrappedLines([message], self.message_width)
-            message = NEXT_LINE_PROLOGUE.join(lines)
-
-        when_or_elapsed = getattr(record, WHEN_OR_ELAPSED_ATTR, None)
-        if when_or_elapsed is None:
-            return message, True
+                lines = [message]
+            message = NEXT_LINE_PROLOGUE.join(WrappedLines(lines, self.message_width))
 
+        when_or_elapsed = getattr(record, WHEN_OR_ELAPSED_ATTR, TIME_PLACEHOLDER)
         if (where := getattr(record, WHERE_ATTR, None)) is None:
+            where_location = None
             where = ""
         else:
-            where = f"{NEXT_LINE_PROLOGUE}{WHERE_SEPARATOR} {where}"
+            where_location = CONTEXT_LENGTH_p_1 + message.__len__()
+            where = f"{WHERE_PROLOGUE}{where}"
 
         return (
-            f"{when_or_elapsed}"
-            f"{LEVEL_OPENING}{record.levelname[0]}{LEVEL_CLOSING} "
-            f"{MESSAGE_MARKER} {message}{where}"
-        ), True
+            f"{when_or_elapsed}_{record.levelname[0].lower()} {message}{where}",
+            True,
+            where_location,
+        )
 
     def Rule(self, /, *, text: str | None = None, color: str = "black") -> str | h.Any:
         """
         Return type hint h.Any: For Rich, for example.
         """
-        if text is None:
+        if text in (None, ""):
             if self.message_width > 0:
                 return self.message_width * RULE_CHARACTER
             return DEFAULT_RULE

logger_36/type/issue.py

@@ -8,9 +8,9 @@ import logging as l
 import typing as h
 
 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.extension.sentinel import NOT_PASSED
 from logger_36.task.format.message import MessageWithActualExpected
 
 issue_t = str
@@ -28,11 +28,11 @@ def NewIssue(
     expected_is_choices: bool = False,
     expected_op: expected_op_h = "=",
     with_final_dot: bool = True,
-) -> issue_t:
+) -> tuple[issue_t, bool]:
     """"""
     if context.__len__() == 0:
         context = ISSUE_BASE_CONTEXT
-    message = MessageWithActualExpected(
+    message, has_actual_expected = MessageWithActualExpected(
         message,
         actual=actual,
         expected=expected,
@@ -41,7 +41,10 @@ def NewIssue(
         with_final_dot=with_final_dot,
     )
 
-    return f"{level}{ISSUE_LEVEL_SEPARATOR}{context}{separator}{message}"
+    return (
+        f"{level}{ISSUE_LEVEL_SEPARATOR}{context}{separator}{message}",
+        has_actual_expected,
+    )
 
 
 """

logger_36/type/logger.py

@@ -7,6 +7,7 @@ SEE COPYRIGHT NOTICE BELOW
 import dataclasses as d
 import inspect as e
 import logging as l
+import multiprocessing as prll
 import sys as s
 import textwrap as text
 import threading as thrd
@@ -15,6 +16,8 @@ import types as t
 import typing as h
 from datetime import date as date_t
 from datetime import datetime as date_time_t
+from logging.handlers import QueueHandler as queue_handler_t
+from logging.handlers import QueueListener as log_server_t
 from pathlib import Path as path_t
 from traceback import TracebackException as traceback_t
 
@@ -26,25 +29,32 @@ from logger_36.catalog.config.optional import (
 )
 from logger_36.catalog.handler.console import console_handler_t
 from logger_36.catalog.handler.file import file_handler_t
+from logger_36.catalog.handler.memory import memory_handler_t, records_h
 from logger_36.config.issue import ISSUE_CONTEXT_END, ISSUE_CONTEXT_SEPARATOR
 from logger_36.config.message import (
     DATE_FORMAT,
-    ELAPSED_TIME_SEPARATOR,
     LONG_ENOUGH,
     TIME_FORMAT,
     WHERE_SEPARATOR,
 )
-from logger_36.constant.date_time import DATE_ORIGIN, DATE_TIME_ORIGIN
-from logger_36.constant.generic import NOT_PASSED
+from logger_36.constant.chronos import DATE_ORIGIN, DATE_TIME_ORIGIN
 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.message import LINE_INDENT, expected_op_h
 from logger_36.constant.path import USER_FOLDER, LAUNCH_ROOT_FILE_relative
-from logger_36.constant.record import SHOW_W_RULE_ATTR, SHOW_WHERE_ATTR
-from logger_36.extension.record import RecordLocation
+from logger_36.constant.record import (
+    HAS_ACTUAL_EXPECTED_ATTR,
+    SHOW_W_RULE_ATTR,
+    SHOW_WHEN_ATTR,
+    SHOW_WHERE_ATTR,
+    WHEN_OR_ELAPSED_ATTR,
+    WHERE_ATTR,
+)
+from logger_36.extension.file import NewTemporaryFile
+from logger_36.extension.sentinel import NOT_PASSED
 from logger_36.task.format.message import MessageWithActualExpected
-from logger_36.task.measure.chronos import ElapsedTime
+from logger_36.task.measure.chronos import FormattedElapsedTime
 from logger_36.task.measure.memory import CurrentUsage as CurrentMemoryUsage
 from logger_36.type.handler import extension_t as handler_extension_t
 from logger_36.type.handler import handler_h as base_handler_h
@@ -63,6 +73,8 @@ logger_handle_raw_h = h.Callable[[l.LogRecord], None]
 logger_handle_with_self_h = h.Callable[[l.Logger, l.LogRecord], None]
 logger_handle_h = logger_handle_raw_h | logger_handle_with_self_h
 
+MAIN_PROCESS_NAME = "MainProcess"
+
 
 @d.dataclass(slots=True, repr=False, eq=False)
 class logger_t(base_t):
@@ -87,7 +99,9 @@ class logger_t(base_t):
     last_message_date: date_t = d.field(init=False, default=DATE_ORIGIN)
     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)
+    staged_issues: list[tuple[issue_t, bool]] = d.field(
+        init=False, default_factory=list
+    )
     intercepted_wrn_handle: logger_handle_h | None = d.field(init=False, default=None)
     intercepted_log_handles: dict[str, logger_handle_h] = d.field(
         init=False, default_factory=dict
@@ -97,6 +111,8 @@ class logger_t(base_t):
     # Used only until the first handler is added (see AddHandler).
     _should_activate_log_interceptions: bool = d.field(init=False, default=False)
 
+    log_server: log_server_t | None = d.field(init=False, default=None)
+
     name_: d.InitVar[str | None] = None
     level_: d.InitVar[int] = l.NOTSET
     activate_wrn_interceptions: d.InitVar[bool] = True
@@ -109,6 +125,21 @@ class logger_t(base_t):
         FormattedEntry = lambda _: f"{_[0]}: {_[1].replace('\n', '↲ ')}"
         return "\n".join(map(FormattedEntry, self.history.items()))
 
+    @property
+    def records(self) -> records_h | None:
+        """"""
+        return logger_t.Records(self)
+
+    @staticmethod
+    def Records(logger: base_t | l.Logger, /) -> records_h | None:
+        """"""
+        for handler in logger.handlers:
+            output = getattr(handler, "records", None)
+            if memory_handler_t.AreRecords(output):
+                return output
+
+        return None
+
     @property
     def intercepts_warnings(self) -> bool:
         """"""
@@ -156,6 +187,8 @@ class logger_t(base_t):
         activate_exc_interceptions: bool,
     ) -> None:
         """"""
+        assert prll.current_process().name == MAIN_PROCESS_NAME
+
         if name_ is None:
             name_ = f"{type(self).__name__}:{hex(id(self))[2:]}"
 
@@ -185,38 +218,39 @@ class logger_t(base_t):
 
     def handle(self, record: l.LogRecord, /) -> None:
         """"""
-        elapsed_time, now = ElapsedTime(should_return_now=True)
-
+        now = date_time_t.now()
         if (date := now.date()) != self.last_message_date:
             self._AcknowledgeDateChange(date)
 
+        level = record.levelno
+
         # When.
-        if now - self.last_message_now > LONG_ENOUGH:
-            w_or_e = now.strftime(TIME_FORMAT)
-        else:
-            w_or_e = f"{ELAPSED_TIME_SEPARATOR}{elapsed_time:.<{TIME_LENGTH_m_1}}"
-        record.when_or_elapsed = w_or_e
+        if getattr(record, SHOW_WHEN_ATTR, True):
+            if now - self.last_message_now > LONG_ENOUGH:
+                w_or_e = f"{now:{TIME_FORMAT}}"
+            else:
+                w_or_e = FormattedElapsedTime(now)  # or: f"{[...]:.<{TIME_LENGTH}}".
+            setattr(record, WHEN_OR_ELAPSED_ATTR, w_or_e)
         self.last_message_now = now
 
         # Where.
-        should_show_where = getattr(record, SHOW_WHERE_ATTR, record.levelno != l.INFO)
+        should_show_where = getattr(record, SHOW_WHERE_ATTR, level != l.INFO)
         if should_show_where or self.should_monitor_memory_usage:
-            where = RecordLocation(record, should_show_where)
-        else:
-            where = None
+            where = f"{record.pathname}:{record.funcName}:{record.lineno}"
+            if should_show_where:
+                setattr(record, WHERE_ATTR, where)
+            if self.should_monitor_memory_usage:
+                self.memory_usages.append((where, CurrentMemoryUsage()))
 
         # What.
         if not isinstance(record.msg, str):
             record.msg = str(record.msg)
 
         base_t.handle(self, record)
-        self.n_events[record.levelno] += 1
+        self.n_events[level] += 1
 
-        if self.should_monitor_memory_usage:
-            self.memory_usages.append((where, CurrentMemoryUsage()))
-
-        if (self.exit_on_critical and (record.levelno is l.CRITICAL)) or (
-            self.exit_on_error and (record.levelno is l.ERROR)
+        if (self.exit_on_critical and (level is l.CRITICAL)) or (
+            self.exit_on_error and (level is l.ERROR)
         ):
             # Also works if self.exit_on_error and record.levelno is l.CRITICAL since
             # __post_init__ set self.exit_on_critical if self.exit_on_error.
@@ -230,7 +264,7 @@ class logger_t(base_t):
             {
                 "name": self.name,
                 "levelno": l.INFO,  # For management by logging.Logger.handle.
-                "msg": f"DATE: {date.strftime(DATE_FORMAT)}",
+                "msg": f"DATE: {date:{DATE_FORMAT}}",
                 SHOW_W_RULE_ATTR: True,
             }
         )
@@ -390,6 +424,27 @@ class logger_t(base_t):
         """"""
         self.AddHandler(file_handler_t, path=path)
 
+    def MakeMultiSafe(self) -> None:
+        """
+        Should not be called until after all desired handlers have been added (as a
+        better-then-nothing check, it is checked that the logger has at least one
+        handler). If handlers are added passed this call, execution might freeze or
+        crash.
+        """
+        assert self.log_server is None
+        assert self.hasHandlers()
+
+        handlers = tuple(self.handlers)  # Making a copy is necessary.
+        for handler in handlers:
+            self.removeHandler(handler)
+
+        queue = prll.Queue()
+
+        self.addHandler(queue_handler_t(queue))
+
+        self.log_server = log_server_t(queue, *handlers)
+        self.log_server.start()
+
     def __call__(self, *args, **kwargs) -> None:
         """
         For a print-like calling for print-based debugging.
@@ -401,7 +456,7 @@ class logger_t(base_t):
         path = path_t(details.filename)
         if path.is_relative_to(USER_FOLDER):
             path = path.relative_to(USER_FOLDER)
-        where = f"{str(path.with_suffix(''))}.{details.function}.{details.lineno}"
+        where = f"{str(path.with_suffix(''))}:{details.function}:{details.lineno}"
 
         self.info(separator.join(map(str, args)) + f"\n{WHERE_SEPARATOR} " + where)
 
@@ -420,7 +475,7 @@ class logger_t(base_t):
         """"""
         if isinstance(level, str):
             level = l.getLevelNamesMapping()[level.upper()]
-        message = MessageWithActualExpected(
+        message, has_actual_expected = MessageWithActualExpected(
             message,
             actual=actual,
             expected=expected,
@@ -428,19 +483,25 @@ class logger_t(base_t):
             expected_op=expected_op,
             with_final_dot=with_final_dot,
         )
-        self.log(level, message)
+        if has_actual_expected:
+            extra = {HAS_ACTUAL_EXPECTED_ATTR: True}
+        else:
+            extra = {}
+        self.log(level, message, extra=extra)
 
     def LogAsIs(self, message: str, /, *, indented: bool = False) -> None:
         """"""
         if indented:
             message = text.indent(message, LINE_INDENT)
 
+        emit_message_name = handler_extension_t.EmitMessage.__name__
+        FallbackEmitMessage = print
         for handler in self.handlers:
-            EmitMessage = getattr(
-                handler, handler_extension_t.EmitMessage.__name__, None
-            )
+            EmitMessage = getattr(handler, emit_message_name, FallbackEmitMessage)
             if EmitMessage is not None:
                 EmitMessage(message)
+                if EmitMessage is print:
+                    FallbackEmitMessage = None
 
     info_raw = LogAsIs  # To follow the convention of the logging methods info, error...
 
@@ -472,20 +533,30 @@ class logger_t(base_t):
         self.LogException(exception, level=l.CRITICAL)
         s.exit(1)
 
-    def DealWithExceptionInThread(
-        self, exc_type, exc_value, exc_traceback, _, /
-    ) -> None:
+    def DealWithExceptionInThread(self, args, /) -> None:
         """"""
-        self.DealWithException(exc_type, exc_value, exc_traceback)
+        self.DealWithException(args.exc_type, args.exc_value, args.exc_traceback)
 
     def DisplayRule(
         self, /, *, message: str | None = None, color: str = "white"
     ) -> None:
         """"""
-        for handler in self.handlers:
-            EmitRule = getattr(handler, handler_extension_t.EmitRule.__name__, None)
-            if EmitRule is not None:
-                EmitRule(text=message, color=color)
+        if message is None:
+            message = ""
+        record = l.makeLogRecord(
+            {
+                "name": self.name,
+                "levelno": l.INFO,  # For management by logging.Logger.handle.
+                "msg": message,
+                SHOW_W_RULE_ATTR: True,
+            }
+        )
+        base_t.handle(self, record)
+        # emit_rule_name = handler_extension_t.EmitRule.__name__
+        # for handler in self.handlers:
+        #     EmitRule = getattr(handler, emit_rule_name, None)
+        #     if EmitRule is not None:
+        #         EmitRule(text=message, color=color)
 
     def AddContextLevel(self, new_level: str, /) -> None:
         """"""
@@ -527,7 +598,9 @@ class logger_t(base_t):
         )
         self.staged_issues.append(issue)
 
-    def PopIssues(self, /, *, should_remove_context: bool = False) -> list[str]:
+    def PopIssues(
+        self, /, *, should_remove_context: bool = False
+    ) -> list[tuple[str, bool]]:
         """"""
         if not self.has_staged_issues:
             return []
@@ -539,10 +612,10 @@ class logger_t(base_t):
         else:
             separator = ISSUE_LEVEL_SEPARATOR
         separator_length = separator.__len__()
-        for issue in self.staged_issues:
+        for issue, has_actual_expected in self.staged_issues:
             start_idx = issue.find(separator)
             issue = issue[(start_idx + separator_length) :]
-            output.append(issue)
+            output.append((issue, has_actual_expected))
 
         self.staged_issues.clear()
 
@@ -564,13 +637,16 @@ class logger_t(base_t):
                     "Invalid commit order",
                     actual=order,
                     expected=f"One of {str(ORDER)[1:-1]}",
-                )
+                )[0]
             )
 
         if order == "when":
             issues = self.staged_issues
         else:  # order == "context"
-            issues = sorted(self.staged_issues, key=lambda _: _.context)
+            issues = sorted(
+                self.staged_issues,
+                key=lambda _: _[0].split(ISSUE_LEVEL_SEPARATOR, maxsplit=1)[1],
+            )
         """
         Format issues as an exception:
         try:
@@ -582,20 +658,43 @@ class logger_t(base_t):
             formatted = "\n".join(lines)
         """
 
-        hide_where = {SHOW_WHERE_ATTR: False}
+        extra = {SHOW_WHERE_ATTR: False}
         if unified:
-            level, _ = issues[0].split(ISSUE_LEVEL_SEPARATOR, maxsplit=1)
+            level, _ = issues[0][0].split(ISSUE_LEVEL_SEPARATOR, maxsplit=1)
             wo_level = []
-            for issue in issues:
+            any_has_actual_expected = False
+            for issue, has_actual_expected in issues:
                 _, issue = issue.split(ISSUE_LEVEL_SEPARATOR, maxsplit=1)
+                if has_actual_expected:
+                    any_has_actual_expected = True
                 wo_level.append(issue)
-            self.log(int(level), "\n".join(wo_level), stacklevel=2, extra=hide_where)
+            if any_has_actual_expected:
+                extra[HAS_ACTUAL_EXPECTED_ATTR] = True
+            self.log(int(level), "\n".join(wo_level), stacklevel=2, extra=extra)
         else:
-            for issue in issues:
+            for issue, has_actual_expected in issues:
                 level, issue = issue.split(ISSUE_LEVEL_SEPARATOR, maxsplit=1)
-                self.log(int(level), issue, stacklevel=2, extra=hide_where)
+                if has_actual_expected:
+                    extra[HAS_ACTUAL_EXPECTED_ATTR] = True
+                self.log(int(level), issue, stacklevel=2, extra=extra)
+                if has_actual_expected:
+                    del extra[HAS_ACTUAL_EXPECTED_ATTR]
         self.staged_issues.clear()
 
+    def StoragePath(self, suffix: str, /) -> path_t:
+        """
+        Use as staticmethod if needed.
+        """
+        for handler in self.handlers:
+            if (path := getattr(handler, "baseFilename", None)) is not None:
+                output = path_t(path).with_suffix(suffix)
+                if output.exists():
+                    output = NewTemporaryFile(suffix)
+
+                return output
+
+        return NewTemporaryFile(suffix)
+
     def __enter__(self) -> None:
         """"""
         pass
@@ -611,6 +710,13 @@ class logger_t(base_t):
         _ = self.context_levels.pop()
         return False
 
+    def __del__(self) -> None:
+        """"""
+        if (prll.current_process().name == MAIN_PROCESS_NAME) and (
+            self.log_server is not None
+        ):
+            self.log_server.stop()
+
 
 def _HandleForWarnings(interceptor: base_t, /) -> logger_handle_h:
     """"""

logger_36/type/loggers.py

@@ -22,7 +22,6 @@ class loggers_t(dict[h.Hashable, logger_t]):
         *,
         name: str | None = None,
         level: int = l.NOTSET,
-        should_record_messages: bool = False,
         exit_on_error: bool = False,
         exit_on_critical: bool = False,
         activate_wrn_interceptions: bool = True,
@@ -31,7 +30,6 @@ class loggers_t(dict[h.Hashable, logger_t]):
     ) -> None:
         """"""
         logger = logger_t(
-            should_record_messages=should_record_messages,
             exit_on_error=exit_on_error,
             exit_on_critical=exit_on_critical,
             name_=name,

logger_36/version.py

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