logger-36 2024.1__py3-none-any.whl → 2025.4__py3-none-any.whl

logger_36/task/storage.py

@@ -1,49 +1,85 @@
-# 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.
+"""
+Copyright CNRS/Inria/UniCA
+Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2023
+SEE COPYRIGHT NOTICE BELOW
+"""
 
+import dataclasses as d
 import logging as lggg
+import re as regx
+from html.parser import HTMLParser as html_parser_t
+from io import IOBase as io_base_t
 from pathlib import Path as path_t
-from typing import TextIO
 
-from rich.console import Console as console_t
+try:
+    from rich.console import Console as console_t  # noqa
+except ModuleNotFoundError:
+    console_t = None
 
-from logger_36.instance import LOGGER
+from logger_36.instance.logger import LOGGER
 
+_BODY_END_PATTERN = r"</[bB][oO][dD][yY]>(.|\n)*$"
 
-def SaveLOGasHTML(path: str | path_t | TextIO = None) -> None:
+
+@d.dataclass(slots=True, repr=False, eq=False)
+class html_reader_t(html_parser_t):
+    source: str = ""
+    inside_body: bool = d.field(init=False, default=False)
+    body_position_start: tuple[int, int] = d.field(init=False, default=(-1, -1))
+    body_position_end: tuple[int, int] = d.field(init=False, default=(-1, -1))
+    pieces: list[str] = d.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(_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 | io_base_t | None = 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):
@@ -65,19 +101,64 @@ def SaveLOGasHTML(path: str | path_t | TextIO = None) -> None:
         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):
+        if isinstance(console, console_t) and console.record:
+            html = console.export_html()
+            if actual_file:
+                with open(path, "w") as accessor:
+                    accessor.write(html)
+            else:
+                path.write(html)
             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.warning(
+            f"{cannot_save}: No handler has a RICH console with recording ON."
+        )
+
+
+"""
+COPYRIGHT NOTICE
+
+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.
+
+SEE LICENCE NOTICE: file README-LICENCE-utf8.txt at project source root.
+
+This software is being developed by Eric Debreuve, a CNRS employee and
+member of team Morpheme.
+Team Morpheme is a joint team between Inria, CNRS, and UniCA.
+It is hosted by the Centre Inria d'Université Côte d'Azur, Laboratory
+I3S, and Laboratory iBV.
+
+CNRS: https://www.cnrs.fr/index.php/en
+Inria: https://www.inria.fr/en/
+UniCA: https://univ-cotedazur.eu/
+Centre Inria d'Université Côte d'Azur: https://www.inria.fr/en/centre/sophia/
+I3S: https://www.i3s.unice.fr/en/
+iBV: http://ibv.unice.fr/
+Team Morpheme: https://team.inria.fr/morpheme/
+"""

logger_36/time.py

@@ -0,0 +1,54 @@
+"""
+Copyright CNRS/Inria/UniCA
+Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2023
+SEE COPYRIGHT NOTICE BELOW
+"""
+
+from logger_36.catalog.logger.chronos import LogElapsedTime
+from logger_36.task.measure.chronos import ElapsedTime, TimeStamp
+
+"""
+COPYRIGHT NOTICE
+
+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.
+
+SEE LICENCE NOTICE: file README-LICENCE-utf8.txt at project source root.
+
+This software is being developed by Eric Debreuve, a CNRS employee and
+member of team Morpheme.
+Team Morpheme is a joint team between Inria, CNRS, and UniCA.
+It is hosted by the Centre Inria d'Université Côte d'Azur, Laboratory
+I3S, and Laboratory iBV.
+
+CNRS: https://www.cnrs.fr/index.php/en
+Inria: https://www.inria.fr/en/
+UniCA: https://univ-cotedazur.eu/
+Centre Inria d'Université Côte d'Azur: https://www.inria.fr/en/centre/sophia/
+I3S: https://www.i3s.unice.fr/en/
+iBV: http://ibv.unice.fr/
+Team Morpheme: https://team.inria.fr/morpheme/
+"""

logger_36/type/handler.py

@@ -0,0 +1,184 @@
+"""
+Copyright CNRS/Inria/UniCA
+Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2023
+SEE COPYRIGHT NOTICE BELOW
+"""
+
+import dataclasses as d
+import logging as lggg
+import sys as sstm
+import typing as h
+
+from logger_36.config.message import (
+    LEVEL_CLOSING,
+    LEVEL_OPENING,
+    MESSAGE_MARKER,
+    WHERE_SEPARATOR,
+)
+from logger_36.constant.error import MEMORY_MEASURE_ERROR
+from logger_36.constant.handler import HANDLER_CODES
+from logger_36.constant.message import NEXT_LINE_PROLOGUE
+from logger_36.task.format.message import MessageWithActualExpected
+from logger_36.task.measure.chronos import TimeStamp
+from logger_36.task.measure.memory import CanCheckUsage as CanCheckMemoryUsage
+
+_MEMORY_MEASURE_ERROR = MEMORY_MEASURE_ERROR
+
+
+@d.dataclass(slots=True, repr=False, eq=False)
+class handler_extension_t:
+    name: str | None = None
+    should_store_memory_usage: bool = False
+    message_width: int = -1
+    MessageFromRecord: h.Callable[..., str] = d.field(init=False)
+
+    handler: d.InitVar[lggg.Handler | None] = None
+    level: d.InitVar[int] = lggg.NOTSET
+    formatter: d.InitVar[lggg.Formatter | None] = None
+
+    def __post_init__(
+        self, handler: lggg.Handler | None, level: int, formatter: lggg.Formatter | None
+    ) -> None:
+        """"""
+        global _MEMORY_MEASURE_ERROR
+
+        if self.name in HANDLER_CODES:
+            raise ValueError(
+                MessageWithActualExpected(
+                    "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.should_store_memory_usage and not CanCheckMemoryUsage():
+            self.should_store_memory_usage = False
+            if _MEMORY_MEASURE_ERROR is not None:
+                print(_MEMORY_MEASURE_ERROR, file=sstm.stderr)
+                _MEMORY_MEASURE_ERROR = None
+
+        handler.setLevel(level)
+
+        if 0 < self.message_width < 5:
+            self.message_width = 5
+        if formatter is None:
+            self.MessageFromRecord = self._MessageFromRecord
+        else:
+            handler.setFormatter(formatter)
+            self.MessageFromRecord = handler.formatter.format
+
+    def _MessageFromRecord(
+        self,
+        record: lggg.LogRecord,
+        /,
+        *,
+        PreProcessed: h.Callable[[str], str] | None = None,
+    ) -> str:
+        """
+        See logger_36.catalog.handler.README.txt.
+        """
+        message = record.msg
+
+        if PreProcessed is not None:
+            message = PreProcessed(message)
+        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)
+            else:
+                lines = _WrappedLines([message], self.message_width)
+            message = NEXT_LINE_PROLOGUE.join(lines)
+
+        if (where := getattr(record, "where", None)) is None:
+            where = ""
+        else:
+            where = f"{NEXT_LINE_PROLOGUE}{WHERE_SEPARATOR} {where}"
+
+        return (
+            f"{record.when_or_elapsed}"
+            f"{LEVEL_OPENING}{record.level_first_letter}{LEVEL_CLOSING} "
+            f"{MESSAGE_MARKER} {message}{where}"
+        )
+
+
+def _WrappedLines(lines: list[str], message_width: int, /) -> list[str]:
+    """"""
+    output = []
+
+    for line in lines:
+        while line.__len__() > message_width:
+            if all(
+                _elm != " " for _elm in line[(message_width - 1) : (message_width + 1)]
+            ):
+                if line[message_width - 2] == " ":
+                    piece, line = (
+                        line[: (message_width - 2)].rstrip(),
+                        line[(message_width - 1) :],
+                    )
+                else:
+                    piece, line = (
+                        line[: (message_width - 1)] + "-",
+                        line[(message_width - 1) :],
+                    )
+            else:
+                piece, line = (
+                    line[:message_width].rstrip(),
+                    line[message_width:].lstrip(),
+                )
+            output.append(piece)
+
+        output.append(line)
+
+    return output
+
+
+"""
+COPYRIGHT NOTICE
+
+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.
+
+SEE LICENCE NOTICE: file README-LICENCE-utf8.txt at project source root.
+
+This software is being developed by Eric Debreuve, a CNRS employee and
+member of team Morpheme.
+Team Morpheme is a joint team between Inria, CNRS, and UniCA.
+It is hosted by the Centre Inria d'Université Côte d'Azur, Laboratory
+I3S, and Laboratory iBV.
+
+CNRS: https://www.cnrs.fr/index.php/en
+Inria: https://www.inria.fr/en/
+UniCA: https://univ-cotedazur.eu/
+Centre Inria d'Université Côte d'Azur: https://www.inria.fr/en/centre/sophia/
+I3S: https://www.i3s.unice.fr/en/
+iBV: http://ibv.unice.fr/
+Team Morpheme: https://team.inria.fr/morpheme/
+"""

logger_36/type/issue.py

@@ -0,0 +1,91 @@
+"""
+Copyright CNRS/Inria/UniCA
+Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2023
+SEE COPYRIGHT NOTICE BELOW
+"""
+
+import logging as lggg
+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.task.format.message import MessageWithActualExpected
+
+issue_t = str
+
+
+def NewIssue(
+    context: str,
+    separator: str,
+    message: str,
+    /,
+    *,
+    level: int = lggg.ERROR,
+    actual: h.Any = NOT_PASSED,
+    expected: h.Any | None = None,
+    expected_is_choices: bool = False,
+    expected_op: expected_op_h = "=",
+    with_final_dot: bool = True,
+) -> issue_t:
+    """"""
+    if context.__len__() == 0:
+        context = ISSUE_BASE_CONTEXT
+    message = MessageWithActualExpected(
+        message,
+        actual=actual,
+        expected=expected,
+        expected_is_choices=expected_is_choices,
+        expected_op=expected_op,
+        with_final_dot=with_final_dot,
+    )
+
+    return f"{level}{ISSUE_LEVEL_SEPARATOR}{context}{separator}{message}"
+
+
+"""
+COPYRIGHT NOTICE
+
+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.
+
+SEE LICENCE NOTICE: file README-LICENCE-utf8.txt at project source root.
+
+This software is being developed by Eric Debreuve, a CNRS employee and
+member of team Morpheme.
+Team Morpheme is a joint team between Inria, CNRS, and UniCA.
+It is hosted by the Centre Inria d'Université Côte d'Azur, Laboratory
+I3S, and Laboratory iBV.
+
+CNRS: https://www.cnrs.fr/index.php/en
+Inria: https://www.inria.fr/en/
+UniCA: https://univ-cotedazur.eu/
+Centre Inria d'Université Côte d'Azur: https://www.inria.fr/en/centre/sophia/
+I3S: https://www.i3s.unice.fr/en/
+iBV: http://ibv.unice.fr/
+Team Morpheme: https://team.inria.fr/morpheme/
+"""