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

logger_36/api/{time.py → chronos.py}

@@ -4,7 +4,7 @@ Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2023
 SEE COPYRIGHT NOTICE BELOW
 """
 
-from logger_36.task.measure.chronos import ElapsedTime, TimeStamp  # noqa
+from logger_36.task.measure.chronos import FormattedElapsedTime, TimeStamp  # noqa
 
 """
 COPYRIGHT NOTICE

logger_36/catalog/handler/console_rich.py

@@ -11,6 +11,7 @@ from rich.console import Console as console_t  # noqa
 from rich.console import RenderableType as renderable_t  # noqa
 from rich.markup import escape as EscapedVersion  # noqa
 from rich.rule import Rule as rule_t  # noqa
+from rich.style import Style as style_t  # noqa
 from rich.text import Text as text_t  # noqa
 from rich.traceback import install as InstallTracebackHandler  # noqa
 
@@ -24,8 +25,9 @@ from logger_36.catalog.config.console_rich import (
     RULE_COLOR,
     WHITE_COLOR,
 )
-from logger_36.config.message import ACTUAL_PATTERNS, EXPECTED_PATTERNS, WHERE_SEPARATOR
+from logger_36.config.message import ACTUAL_PATTERNS, EXPECTED_PATTERNS
 from logger_36.constant.message import CONTEXT_LENGTH
+from logger_36.constant.record import HAS_ACTUAL_EXPECTED_ATTR
 from logger_36.type.handler import non_file_handler_t as base_t
 
 _COMMON_TRACEBACK_ARGUMENTS = ("theme", "width")
@@ -62,8 +64,13 @@ class console_rich_handler_t(base_t):
         base_t.__init__(self, name, message_width, EscapedVersion, level, kwargs)
 
         self.console = None  # console_t | None.
-        self.alternating_logs = alternating_logs
-        self._log_parity = False
+        if alternating_logs == 0:
+            self.background_style = None
+        elif alternating_logs == 1:
+            self.background_style = ALTERNATIVE_BACKGROUND_FOR_DARK
+        else:
+            self.background_style = ALTERNATIVE_BACKGROUND_FOR_LIGHT
+        self._should_style_background = False
 
         self.__post_init_local__(should_install_traceback, **kwargs)
 
@@ -104,17 +111,24 @@ class console_rich_handler_t(base_t):
 
     def emit(self, record: l.LogRecord, /) -> None:
         """"""
-        message, is_not_a_rule = self.MessageFromRecord(record, rule_color=RULE_COLOR)
+        message, is_not_a_rule, where_location = self.MessageFromRecord(
+            record, rule_color=RULE_COLOR
+        )
         if is_not_a_rule:
+            if self._should_style_background:
+                background_style = self.background_style
+            else:
+                background_style = None
             message = HighlightedVersion(
                 self.console,
                 message,
+                getattr(record, HAS_ACTUAL_EXPECTED_ATTR, False),
+                where_location,
                 record.levelno,
-                self.alternating_logs,
-                self._log_parity,
+                background_style,
             )
         self.console.print(message, crop=False, overflow="ignore")
-        self._log_parity = not self._log_parity
+        self._should_style_background = not self._should_style_background
 
     def EmitMessage(self, message: str | renderable_t, /) -> None:
         """"""
@@ -124,27 +138,24 @@ class console_rich_handler_t(base_t):
 def HighlightedVersion(
     _: console_t,
     message: str,
+    has_actual_expected: bool,
+    where_location: int | None,
     log_level: int,
-    alternating_logs: int,
-    should_tint_background: bool,
+    background_style: style_t | None,
     /,
 ) -> renderable_t:
     """"""
     output = text_t(message, WHITE_COLOR)
 
     output.stylize(LEVEL_COLOR[log_level], end=CONTEXT_LENGTH)
-    where = message.rfind(WHERE_SEPARATOR)
-    if (where >= 0) and ("\n" not in message[where:]):
-        output.stylize(GRAY_COLOR, start=where)
-    _ = output.highlight_words(ACTUAL_PATTERNS, style=ACTUAL_COLOR)
-    _ = output.highlight_regex(EXPECTED_PATTERNS, style=EXPECTED_COLOR)
-
-    if should_tint_background and (alternating_logs > 0):
-        if alternating_logs == 1:
-            style = ALTERNATIVE_BACKGROUND_FOR_DARK
-        else:
-            style = ALTERNATIVE_BACKGROUND_FOR_LIGHT
-        output.stylize(style)
+    if where_location is not None:
+        output.stylize(GRAY_COLOR, start=where_location)
+    if has_actual_expected:
+        _ = output.highlight_words(ACTUAL_PATTERNS, style=ACTUAL_COLOR)
+        _ = output.highlight_regex(EXPECTED_PATTERNS, style=EXPECTED_COLOR)
+
+    if background_style is not None:
+        output.stylize(background_style)
 
     return output
 

logger_36/catalog/handler/file.py

@@ -28,8 +28,7 @@ class file_handler_t(base_t):
 
     def emit(self, record: l.LogRecord, /) -> None:
         """"""
-        output = self.MessageFromRecord(record)
-        self.stream.write(output[0] + "\n")
+        self.stream.write(self.MessageFromRecord(record)[0] + "\n")
         self.stream.flush()
 
     def EmitMessage(self, message: str, /) -> None:

logger_36/catalog/handler/generic.py

@@ -8,16 +8,20 @@ import logging as l
 import typing as h
 
 from logger_36.catalog.config.optional import RICH_IS_AVAILABLE
+from logger_36.constant.record import HAS_ACTUAL_EXPECTED_ATTR
 
 if RICH_IS_AVAILABLE:
+    from logger_36.catalog.config.console_rich import (
+        ALTERNATIVE_BACKGROUND_FOR_DARK,
+        ALTERNATIVE_BACKGROUND_FOR_LIGHT,
+        RULE_COLOR,
+    )
+    from logger_36.catalog.handler.console_rich import HighlightedVersion
     from rich.console import Console as console_t
     from rich.markup import escape as EscapedForRich
     from rich.rule import Rule as rule_t
     from rich.terminal_theme import DEFAULT_TERMINAL_THEME
     from rich.text import Text as text_t
-
-    from logger_36.catalog.config.console_rich import RULE_COLOR
-    from logger_36.catalog.handler.console_rich import HighlightedVersion
 else:
     console_t = EscapedForRich = rule_t = DEFAULT_TERMINAL_THEME = text_t = (
         RULE_COLOR
@@ -54,8 +58,13 @@ class generic_handler_t(base_t):
         self.is_rich = False
         self.console = None  # console_t | None.
         self.console_options = None  # rich.console.ConsoleOptions | None.
-        self.alternating_logs = alternating_logs
-        self._log_parity = False
+        if alternating_logs == 0:
+            self.background_style = None
+        elif alternating_logs == 1:
+            self.background_style = ALTERNATIVE_BACKGROUND_FOR_DARK
+        else:
+            self.background_style = ALTERNATIVE_BACKGROUND_FOR_LIGHT
+        self._should_style_background = False
 
         self.__post_init_local__(supports_html)
 
@@ -94,16 +103,21 @@ class generic_handler_t(base_t):
     def emit(self, record: l.LogRecord, /) -> None:
         """"""
         if self.is_rich:
-            message, is_not_a_rule = self.MessageFromRecord(
+            message, is_not_a_rule, where_location = self.MessageFromRecord(
                 record, rule_color=RULE_COLOR
             )
             if is_not_a_rule:
+                if self._should_style_background:
+                    background_style = self.background_style
+                else:
+                    background_style = None
                 message = HighlightedVersion(
                     self.console,
                     message,
+                    getattr(record, HAS_ACTUAL_EXPECTED_ATTR, False),
+                    where_location,
                     record.levelno,
-                    self.alternating_logs,
-                    self._log_parity,
+                    background_style,
                 )
             segments = self.console.render(message, options=self.console_options)
 
@@ -132,7 +146,7 @@ class generic_handler_t(base_t):
             message = self.MessageFromRecord(record)[0]
 
         self.EmitMessage(message)
-        self._log_parity = not self._log_parity
+        self._should_style_background = not self._should_style_background
 
 
 """

logger_36/catalog/handler/memory.py

@@ -12,6 +12,10 @@ from logger_36.type.handler import non_file_handler_t as base_t
 
 formats_h = h.Literal["dict", "json", "message", "raw"]
 
+record_raw_h = dict | str | l.LogRecord
+record_h = tuple[int, record_raw_h, bool]  # level, [...], is_not_a_rule.
+records_h = list[record_h]
+
 
 class memory_handler_t(base_t):
     def __init__(
@@ -23,7 +27,7 @@ class memory_handler_t(base_t):
         base_t.__init__(self, name, message_width, None, level)
 
         self.format_ = format_
-        self.records = []
+        self.records: records_h = []
 
     @classmethod
     def New(
@@ -52,7 +56,7 @@ class memory_handler_t(base_t):
             record = json.dumps(record.__dict__)
             is_not_a_rule = True
         else:
-            record, is_not_a_rule = self.MessageFromRecord(record)
+            record, is_not_a_rule, _ = self.MessageFromRecord(record)
 
         self.records.append((level, record, is_not_a_rule))
 
@@ -67,6 +71,24 @@ class memory_handler_t(base_t):
         )
         self.emit(record)
 
+    @staticmethod
+    def IsRecord(checked: h.Any, /) -> bool:
+        """"""
+        return (
+            isinstance(checked, tuple)
+            and (checked.__len__() == 3)
+            and isinstance(checked[0], int)
+            and isinstance(checked[1], record_raw_h)
+            and isinstance(checked[2], bool)
+        )
+
+    @classmethod
+    def AreRecords(cls, checked: h.Any, /) -> bool:
+        """"""
+        return isinstance(checked, list | tuple) and (
+            (checked.__len__() == 0) or all(map(cls.IsRecord, checked))
+        )
+
 
 """
 COPYRIGHT NOTICE

logger_36/catalog/logger/chronos.py

@@ -4,14 +4,22 @@ Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2023
 SEE COPYRIGHT NOTICE BELOW
 """
 
+from datetime import datetime as date_time_t
+
+from logger_36.constant.chronos import FORMATTED_START_DATE_TIME
+from logger_36.constant.record import SHOW_WHEN_ATTR
 from logger_36.instance.logger import L
-from logger_36.task.measure.chronos import ElapsedTime
+from logger_36.task.measure.chronos import FormattedElapsedTime
 from logger_36.type.logger import logger_t
 
 
 def LogElapsedTime(*, logger: logger_t = L) -> None:
     """"""
-    logger.info(f"Elapsed Time: {ElapsedTime()}")
+    logger.info(
+        f"Elapsed Time: {FormattedElapsedTime(date_time_t.now())[1:]} "
+        f"(since {FORMATTED_START_DATE_TIME})",
+        extra={SHOW_WHEN_ATTR: False},
+    )
 
 
 """

logger_36/catalog/logger/memory.py

@@ -38,7 +38,7 @@ def LogMemoryUsages(
                     actual=max_n_samples,
                     expected=1,
                     expected_op=">=",
-                )
+                )[0]
             )
 
         where_s = list(where_s)

logger_36/config/message.py

@@ -6,12 +6,9 @@ SEE COPYRIGHT NOTICE BELOW
 
 from datetime import timedelta as time_delta_t
 
-LEVEL_OPENING = "("
-LEVEL_CLOSING = ")"
-MESSAGE_MARKER = "|"
 WHERE_SEPARATOR = "@"
 ELAPSED_TIME_SEPARATOR = "+"
-FALLBACK_MESSAGE_WIDTH = 5
+FALLBACK_MESSAGE_WIDTH = 20
 
 DATE_FORMAT = "%Y-%m-%d"
 TIME_FORMAT = "%H:%M:%S"

logger_36/constant/{date_time.py → chronos.py}

@@ -6,10 +6,14 @@ SEE COPYRIGHT NOTICE BELOW
 
 from datetime import datetime as date_time_t
 
+from logger_36.config.message import DATE_FORMAT, TIME_FORMAT
+
 # This module is imported early. Therefore, the current date and time should be close
 # enough to the real start date and time of the main script.
 START_DATE_TIME = date_time_t.now()
 
+FORMATTED_START_DATE_TIME = f"{START_DATE_TIME:{TIME_FORMAT + ' on ' + DATE_FORMAT}}"
+
 DATE_TIME_ORIGIN = date_time_t.fromtimestamp(1970, None)
 DATE_ORIGIN = DATE_TIME_ORIGIN.date()
 

logger_36/constant/error.py

@@ -23,6 +23,8 @@ MISSING_RICH_MESSAGE = (
     "Falling back to the raw console."
 )
 
+CANNOT_SAVE_RECORDS = "Cannot save logging records"
+
 """
 COPYRIGHT NOTICE
 

logger_36/constant/html.py

@@ -22,6 +22,8 @@ MINIMAL_HTML = f"""
     </html>
 """
 
+HTML_SUFFIX = ".htm"
+
 
 """
 COPYRIGHT NOTICE

logger_36/constant/message.py

@@ -9,18 +9,18 @@ import typing as h
 
 from logger_36.config.message import (
     ELAPSED_TIME_SEPARATOR,
-    LEVEL_CLOSING,
-    LEVEL_OPENING,
-    MESSAGE_MARKER,
     TIME_FORMAT,
+    WHERE_SEPARATOR,
 )
 
 TIME_LENGTH = time.strftime(TIME_FORMAT, time.gmtime(0)).__len__()
-TIME_LENGTH_m_1 = TIME_LENGTH - ELAPSED_TIME_SEPARATOR.__len__()
-LOG_LEVEL_LENGTH = 1 + LEVEL_OPENING.__len__() + LEVEL_CLOSING.__len__()
-CONTEXT_LENGTH = TIME_LENGTH + LOG_LEVEL_LENGTH
-LINE_INDENT = (CONTEXT_LENGTH + MESSAGE_MARKER.__len__() + 2) * " "
+CONTEXT_LENGTH = TIME_LENGTH + 2  # 2=<underscore><level name first letter>.
+CONTEXT_LENGTH_p_1 = CONTEXT_LENGTH + 1
+LINE_INDENT = (CONTEXT_LENGTH + 1) * " "
 NEXT_LINE_PROLOGUE = "\n" + LINE_INDENT
+WHERE_PROLOGUE = NEXT_LINE_PROLOGUE[:-2] + WHERE_SEPARATOR + " "
+
+TIME_PLACEHOLDER = TIME_LENGTH * ELAPSED_TIME_SEPARATOR
 
 expected_op_h = h.Literal[":", ": ", "=", "!=", ">=", "<="]
 EXPECTED_OP: tuple[str, ...] = h.get_args(expected_op_h)

logger_36/constant/record.py

@@ -4,6 +4,8 @@ Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2023
 SEE COPYRIGHT NOTICE BELOW
 """
 
+HAS_ACTUAL_EXPECTED_ATTR = "has_actual_expected"
+SHOW_WHEN_ATTR = "should_show_when"
 SHOW_WHERE_ATTR = "should_show_where"
 SHOW_W_RULE_ATTR = "should_show_w_rule"
 WHEN_OR_ELAPSED_ATTR = "when_or_elapsed"

logger_36/extension/{record.py → file.py}

@@ -4,33 +4,23 @@ Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2023
 SEE COPYRIGHT NOTICE BELOW
 """
 
-import logging as l
-import sys as s
-from os import sep as FOLDER_SEPARATOR
+import os as o
+import tempfile as tmps
 from pathlib import Path as path_t
 
-from logger_36.constant.path import USER_FOLDER
-from logger_36.constant.record import WHERE_ATTR
 
-
-def RecordLocation(record: l.LogRecord, should_also_store: bool, /) -> str:
+def NewTemporaryFile(
+    suffix: str, /, *, should_return_accessor: bool = False
+) -> path_t | tuple[path_t, int]:
     """"""
-    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}"
+    accessor, path = tmps.mkstemp(suffix=suffix)
+    path = path_t(path)
 
-    if should_also_store:
-        setattr(record, WHERE_ATTR, output)
+    if should_return_accessor:
+        return path, accessor
 
-    return output
+    o.close(accessor)
+    return path
 
 
 """

logger_36/extension/line.py

@@ -12,7 +12,7 @@ def WrappedLines(lines: list[str], message_width: int, /) -> list[str]:
     for line in lines:
         while line.__len__() > message_width:
             if all(
-                _elm != " " for _elm in line[(message_width - 1) : (message_width + 1)]
+                _ != " " for _ in line[(message_width - 1) : (message_width + 1)]
             ):
                 if line[message_width - 2] == " ":
                     piece, line = (

logger_36/task/format/memory.py

@@ -39,7 +39,7 @@ def FormattedUsage(
         raise ValueError(
             MessageWithActualExpected(
                 "Invalid unit", actual=unit, expected=str(STORAGE_UNITS)[1:-1]
-            )
+            )[0]
         )
 
     return value, unit

logger_36/task/format/message.py

@@ -7,8 +7,8 @@ SEE COPYRIGHT NOTICE BELOW
 import difflib as diff
 import typing as h
 
-from logger_36.constant.generic import NOT_PASSED
 from logger_36.constant.message import expected_op_h
+from logger_36.extension.sentinel import NOT_PASSED
 
 
 def MessageWithActualExpected(
@@ -20,8 +20,10 @@ def MessageWithActualExpected(
     expected_is_choices: bool = False,
     expected_op: expected_op_h = "=",
     with_final_dot: bool = True,
-) -> str:
-    """"""
+) -> tuple[str, bool]:
+    """
+    Second return: has_actual_expected.
+    """
     if actual is NOT_PASSED:
         if with_final_dot:
             if message[-1] != ".":
@@ -29,7 +31,7 @@ def MessageWithActualExpected(
         elif message[-1] == ".":
             message = message[:-1]
 
-        return message
+        return message, False
 
     if message[-1] == ".":
         message = message[:-1]
@@ -44,7 +46,7 @@ def MessageWithActualExpected(
     else:
         actual = f"{actual}:{type(actual).__name__}"
 
-    return f"{message}: Actual={actual}; {expected}{dot}"
+    return f"{message}: Actual={actual}; {expected}{dot}", True
 
 
 def _FormattedExpected(

logger_36/task/measure/chronos.py

@@ -4,32 +4,42 @@ Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2023
 SEE COPYRIGHT NOTICE BELOW
 """
 
-import time
 from datetime import datetime as date_time_t
 
-from logger_36.constant.date_time import START_DATE_TIME
+from logger_36.config.message import ELAPSED_TIME_SEPARATOR
+from logger_36.constant.chronos import START_DATE_TIME
+from logger_36.constant.message import TIME_LENGTH
 
 
 def TimeStamp(*, precision: str = "microseconds") -> str:
-    """"""
+    """
+    precision: See documentation of date_time_t.isoformat.
+    """
     return (
         date_time_t.now()
         .isoformat(timespec=precision)
-        .replace(".", "-")
+        .replace(".", "_")
         .replace(":", "-")
     )
 
 
-def ElapsedTime(*, should_return_now: bool = False) -> str | tuple[str, date_time_t]:
+def FormattedElapsedTime(
+    now: date_time_t, /, *, reference: date_time_t = START_DATE_TIME
+) -> str:
     """"""
-    now = date_time_t.now()
-    elapsed_seconds = (now - START_DATE_TIME).total_seconds()
-    output = time.strftime("%H:%M:%S", time.gmtime(elapsed_seconds))
+    output = str(now - reference)
+
+    if output.startswith("0:"):
+        output = output[2:]
     while output.startswith("00:"):
-        output = output.split(sep=":", maxsplit=1)[-1]
+        output = output[3:]
+    if output[0] == "0":
+        output = output[1:]
+
+    output = ELAPSED_TIME_SEPARATOR + output
 
-    if should_return_now:
-        return output, now
+    if output.__len__() > TIME_LENGTH:
+        return output[:TIME_LENGTH]
     return output
 
 

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: