logger-36 2023.13__py3-none-any.whl → 2024.2__py3-none-any.whl

logger_36/task/storage.py

@@ -0,0 +1,144 @@
+# Copyright CNRS/Inria/UCA
+# Contributor(s): Eric Debreuve (since 2023)
+#
+# eric.debreuve@cnrs.fr
+#
+# This software is governed by the CeCILL  license under French law and
+# abiding by the rules of distribution of free software.  You can  use,
+# modify and/ or redistribute the software under the terms of the CeCILL
+# license as circulated by CEA, CNRS and INRIA at the following URL
+# "http://www.cecill.info".
+#
+# As a counterpart to the access to the source code and  rights to copy,
+# modify and redistribute granted by the license, users are provided only
+# with a limited warranty  and the software's author,  the holder of the
+# economic rights,  and the successive licensors  have only  limited
+# liability.
+#
+# In this respect, the user's attention is drawn to the risks associated
+# with loading,  using,  modifying and/or developing or reproducing the
+# software by the user in light of its specific status of free software,
+# that may mean  that it is complicated to manipulate,  and  that  also
+# therefore means  that it is reserved for developers  and  experienced
+# professionals having in-depth computer knowledge. Users are therefore
+# encouraged to load and test the software's suitability as regards their
+# requirements in conditions enabling the security of their systems and/or
+# data to be ensured and,  more generally, to use and operate it in the
+# same conditions as regards security.
+#
+# The fact that you are presently reading this means that you have had
+# knowledge of the CeCILL license and that you accept its terms.
+
+import dataclasses as dtcl
+import logging as lggg
+import re as regx
+import typing as h
+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
+except ModuleNotFoundError:
+    console_t = None
+
+from logger_36.instance import LOGGER
+
+
+@dtcl.dataclass(slots=True, repr=False, eq=False)
+class html_reader_t(html_parser_t):
+    BODY_END_PATTERN: h.ClassVar[str] = r"</[bB][oO][dD][yY]>(.|\n)*$"
+
+    source: str = ""
+    inside_body: bool = dtcl.field(init=False, default=False)
+    body_position_start: tuple[int, int] = dtcl.field(init=False, default=(-1, -1))
+    body_position_end: tuple[int, int] = dtcl.field(init=False, default=(-1, -1))
+    pieces: list[str] = dtcl.field(init=False, default_factory=list)
+
+    def __post_init__(self) -> None:
+        """"""
+        html_parser_t.__init__(self)
+        self.source = self.source.strip()
+        self.feed(self.source)
+
+    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]], /) -> None:
+        """"""
+        if tag == "body":
+            self.body_position_start = self.getpos()
+            self.inside_body = True
+
+    def handle_endtag(self, tag: str, /) -> None:
+        """"""
+        if tag == "body":
+            self.body_position_end = self.getpos()
+            self.inside_body = False
+
+    def handle_data(self, data: str, /) -> None:
+        """"""
+        if self.inside_body:
+            self.pieces.append(data)
+
+    @property
+    def body(self) -> str:
+        """"""
+        output = self.source.splitlines()
+        output = "\n".join(
+            output[self.body_position_start[0] : (self.body_position_end[0] + 1)]
+        )
+        output = output[self.body_position_start[1] :]
+        output = regx.sub(self.__class__.BODY_END_PATTERN, "", output, count=1)
+
+        return output.strip()
+
+    @property
+    def body_as_text(self) -> str:
+        """"""
+        return "".join(self.pieces).strip()
+
+
+def SaveLOGasHTML(path: str | path_t | h.TextIO = None) -> None:
+    """
+    From first console handler found.
+    """
+    cannot_save = "Cannot save logging record as HTML"
+
+    if console_t is None:
+        LOGGER.warning(f"{cannot_save}: The Rich console cannot be imported.")
+        return
+
+    if path is None:
+        for handler in LOGGER.handlers:
+            if isinstance(handler, lggg.FileHandler):
+                path = path_t(handler.baseFilename).with_suffix(".htm")
+                break
+        if path is None:
+            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
+
+    console = None
+    found = False
+    for handler in LOGGER.handlers:
+        console = getattr(handler, "console", None)
+        if found := isinstance(console, console_t):
+            break
+
+    if found:
+        html = console.export_html()
+        if actual_file:
+            with open(path, "w") as accessor:
+                accessor.write(html)
+        else:
+            path.write(html)
+    else:
+        LOGGER.warning(f"{cannot_save}: No handler has a RICH console.")

logger_36/type/extension.py

@@ -29,94 +29,106 @@
 # The fact that you are presently reading this means that you have had
 # knowledge of the CeCILL license and that you accept its terms.
 
+import dataclasses as dtcl
 import logging as lggg
 import sys as sstm
-from typing import Callable
+import typing as h
 
-from logger_36.config import DATE_TIME_FORMAT, MESSAGE_FORMAT
-from logger_36.constant import LOG_LEVEL_LENGTH, NEXT_LINE_PROLOGUE
-from logger_36.measure.chronos import ElapsedTime
-from logger_36.measure.memory import CurrentUsage as CurrentMemoryUsage
-from logger_36.measure.memory import WithAutoUnit as MemoryWithAutoUnit
+from logger_36.config.message import TIME_FORMAT, WHERE_FORMAT
+from logger_36.constant.handler import HANDLER_CODES
+from logger_36.constant.memory import MEMORY_MEASURE_ERROR
+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.measure.chronos import TimeStamp
+from logger_36.task.measure.memory import CanCheckMemory
 
 
+@dtcl.dataclass(slots=True, repr=False, eq=False)
 class handler_extension_t:
-    __slots__ = ("formatter", "show_memory_usage", "max_memory_usage", "exit_on_error")
-    formatter: lggg.Formatter
-    show_memory_usage: bool
-    max_memory_usage: int
-    exit_on_error: bool
+    name: str | None = None
+    show_where: bool = True
+    show_memory_usage: bool = False
+    FormattedRecord: h.Callable[[lggg.LogRecord], str] = dtcl.field(init=False)
 
-    def __init__(self) -> None:
+    handler: dtcl.InitVar[lggg.Handler | None] = None
+    level: dtcl.InitVar[int] = lggg.NOTSET
+    formatter: dtcl.InitVar[lggg.Formatter | None] = None
+
+    def __post_init__(
+        self, handler: lggg.Handler | None, level: int, formatter: lggg.Formatter | None
+    ) -> None:
         """"""
-        self.formatter = lggg.Formatter(fmt=MESSAGE_FORMAT, datefmt=DATE_TIME_FORMAT)
-        self.show_memory_usage = False
-        self.max_memory_usage = -1
-        self.exit_on_error = False
+        if self.name in HANDLER_CODES:
+            raise ValueError(
+                FormattedMessage(
+                    "Invalid handler name",
+                    actual=self.name,
+                    expected=f"a name not in {str(HANDLER_CODES)[1:-1]}",
+                )
+            )
+
+        if self.name is None:
+            self.name = TimeStamp()
+
+        if self.show_memory_usage and not CanCheckMemory():
+            self.show_memory_usage = False
+            print(MEMORY_MEASURE_ERROR, file=sstm.stderr)
+
+        handler.setLevel(level)
 
-    def MessageLines(
+        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
+
+    def FormattedLines(
         self,
         record: lggg.LogRecord,
         /,
         *,
-        PreProcessed: Callable[[str], str] | None = None,
-        should_fully_format: bool = False,
+        PreProcessed: h.Callable[[str], str] | None = None,
+        should_join_lines: bool = False,
     ) -> tuple[str, str | None]:
         """
-        Note: "message" is not yet an attribute of record (it will be set by format());
-        Use "msg" instead.
+        See logger_36.catalog.handler.README.txt.
         """
-        if not isinstance(record.msg, str):
-            record.msg = str(record.msg)
+        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:
-            record.msg = PreProcessed(record.msg)
-        if "\n" in record.msg:
-            original_message = record.msg
-            lines = original_message.splitlines()
-            record.msg = lines[0]
+            message = PreProcessed(message)
+        if "\n" in message:
+            lines = message.splitlines()
             next_lines = NEXT_LINE_PROLOGUE.join(lines[1:])
             next_lines = f"{NEXT_LINE_PROLOGUE}{next_lines}"
+            message = lines[0]
         else:
-            original_message = next_lines = None
-
-        # The record is shared between handlers, so do not re-assign if already there.
-        if not hasattr(record, "elapsed_time"):
-            record.elapsed_time = ElapsedTime()
-        # Re-assign for each handler in case they have different show properties.
-        if self.show_memory_usage:
-            record.memory_usage = self.FormattedMemoryUsage()
-        else:
-            record.memory_usage = ""
+            next_lines = None
 
-        padding = (LOG_LEVEL_LENGTH - record.levelname.__len__() - 1) * " "
-        first_line = self.formatter.format(record).replace("\t", padding)
+        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 = ""
+            else:
+                record.where = WHERE_FORMAT.format(
+                    module=record.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.
-        if original_message is not None:
-            record.msg = original_message
+        record.msg = original_message
 
-        if should_fully_format:
+        if should_join_lines:
             if next_lines is None:
                 return first_line, None
             else:
                 return f"{first_line}{next_lines}", None
         else:
             return first_line, next_lines
-
-    def FormattedMemoryUsage(self) -> str:
-        """"""
-        if self.show_memory_usage:
-            usage = CurrentMemoryUsage()
-            if usage > self.max_memory_usage:
-                self.max_memory_usage = usage
-
-            usage, unit = MemoryWithAutoUnit(usage, 1)
-
-            return f" :{usage}{unit}"
-        else:
-            return ""
-
-    def ExitOrNotIfError(self, record: lggg.LogRecord, /) -> None:
-        """"""
-        if self.exit_on_error and (record.levelno in (lggg.ERROR, lggg.CRITICAL)):
-            sstm.exit(1)

logger_36/type/issue.py

@@ -0,0 +1,57 @@
+# Copyright CNRS/Inria/UCA
+# Contributor(s): Eric Debreuve (since 2023)
+#
+# eric.debreuve@cnrs.fr
+#
+# This software is governed by the CeCILL  license under French law and
+# abiding by the rules of distribution of free software.  You can  use,
+# modify and/ or redistribute the software under the terms of the CeCILL
+# license as circulated by CEA, CNRS and INRIA at the following URL
+# "http://www.cecill.info".
+#
+# As a counterpart to the access to the source code and  rights to copy,
+# modify and redistribute granted by the license, users are provided only
+# with a limited warranty  and the software's author,  the holder of the
+# economic rights,  and the successive licensors  have only  limited
+# liability.
+#
+# In this respect, the user's attention is drawn to the risks associated
+# with loading,  using,  modifying and/or developing or reproducing the
+# software by the user in light of its specific status of free software,
+# that may mean  that it is complicated to manipulate,  and  that  also
+# therefore means  that it is reserved for developers  and  experienced
+# professionals having in-depth computer knowledge. Users are therefore
+# encouraged to load and test the software's suitability as regards their
+# requirements in conditions enabling the security of their systems and/or
+# data to be ensured and,  more generally, to use and operate it in the
+# same conditions as regards security.
+#
+# The fact that you are presently reading this means that you have had
+# knowledge of the CeCILL license and that you accept its terms.
+
+import typing as h
+
+from logger_36.config.issue import BASE_CONTEXT
+from logger_36.constant.generic import NOT_PASSED
+from logger_36.task.format.message import FormattedMessage
+
+issue_t = str
+
+
+def NewIssue(
+    context: str,
+    separator: str,
+    message: str,
+    /,
+    *,
+    actual: h.Any = NOT_PASSED,
+    expected: h.Any | None = None,
+) -> issue_t:
+    """"""
+    if context.__len__() == 0:
+        context = BASE_CONTEXT
+    message = FormattedMessage(
+        message, actual=actual, expected=expected, with_final_dot=False
+    )
+
+    return f"{context}{separator}{message}"