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

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,34 +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
 
-# 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 = date_time_t.now()
+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_AND_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

@@ -8,7 +8,14 @@ import logging as l
 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
 
@@ -19,53 +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():
-        logger.warning(f'{cannot_save}: File "{path}" already exists.')
-        return
-
-    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.")
+    records = logger_t.Records(logger)
+    if records is None:
+        logger.warning(
+            f"{CANNOT_SAVE_RECORDS}: 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)
@@ -73,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,21 +8,16 @@ 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,
+    TIME_PLACEHOLDER,
+    WHERE_PROLOGUE,
+    CONTEXT_LENGTH_p_1,
 )
-from logger_36.constant.message import NEXT_LINE_PROLOGUE
 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,
-    MIN_HALF_RULE_LENGTH,
-    RULE_CHARACTER,
-)
+from logger_36.constant.rule import DEFAULT_RULE, MIN_HALF_RULE_LENGTH
 from logger_36.extension.line import WrappedLines
 
 
@@ -56,42 +51,41 @@ class extension_t:
         raise NotImplementedError
 
     def MessageFromRecord(
-        self, record: l.LogRecord, /, *, rule_color: str | None = None
-    ) -> tuple[str, bool]:
+        self, record: l.LogRecord, /, *, rule_color: str = "black"
+    ) -> 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:
         """
@@ -122,7 +116,7 @@ class extension_t:
         self.EmitMessage(self.Rule(text=text, color=color))
 
 
-class handler_t(l.Handler, extension_t):
+class non_file_handler_t(l.Handler, extension_t):
     def __init__(
         self,
         name: str | None,
@@ -160,10 +154,10 @@ class file_handler_t(l.FileHandler, extension_t):
         __post_init__(self, level)
 
 
-any_handler_t = handler_t | file_handler_t
+handler_h = non_file_handler_t | file_handler_t
 
 
-def __post_init__(handler: any_handler_t, level: int) -> None:
+def __post_init__(handler: handler_h, level: int) -> None:
     """"""
     handler.setLevel(level)
 

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,
+    )
 
 
 """