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

logger_36/__init__.py

@@ -29,16 +29,11 @@
 # 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 logging as lggg
-
 from logger_36.instance import LOGGER
 from logger_36.main import (
+    AddConsoleHandler,
     AddFileHandler,
     AddGenericHandler,
-    SetExitOnError,
-    SetLOGLevel,
+    AddRichConsoleHandler,
 )
-from logger_36.type.console import console_handler_t
 from logger_36.version import __version__
-
-LOGGER.addHandler(console_handler_t(level=lggg.INFO))

logger_36/catalog/config/console_rich.py

@@ -0,0 +1,49 @@
+# 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 logging as lggg
+
+from rich.color import Color as color_t
+from rich.style import Style as style_t
+
+DATE_TIME_COLOR: str = "dodger_blue2"
+LEVEL_COLOR: dict[int, str | style_t] = {
+    lggg.DEBUG: "orchid",
+    lggg.INFO: "white",
+    lggg.WARNING: "yellow",
+    lggg.ERROR: "orange1",
+    lggg.CRITICAL: "red",
+}
+ACTUAL_COLOR: str = "red"
+EXPECTED_COLOR: str = "green"
+ELAPSED_TIME_COLOR: str = "green"
+
+GRAY_STYLE: style_t = style_t(color=color_t.from_rgb(150, 150, 150))

logger_36/catalog/handler/console.py

@@ -0,0 +1,80 @@
+# 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 typing as h
+
+from logger_36.constant.record import SHOW_W_RULE_ATTR
+from logger_36.task.format.rule import RuleAsText
+from logger_36.type.extension import handler_extension_t
+
+
+@dtcl.dataclass(slots=True, repr=False, eq=False)
+class console_handler_t(lggg.Handler):
+    extension: handler_extension_t = dtcl.field(init=False)
+    FormattedLines: h.Callable[..., tuple[str, str | None]] = dtcl.field(init=False)
+
+    name: dtcl.InitVar[str | None] = None
+    level: dtcl.InitVar[int] = lggg.NOTSET
+    show_where: dtcl.InitVar[bool] = True
+    show_memory_usage: dtcl.InitVar[bool] = False
+    formatter: dtcl.InitVar[lggg.Formatter | None] = None
+
+    def __post_init__(
+        self,
+        name: str | None,
+        level: int,
+        show_where: bool,
+        show_memory_usage: bool,
+        formatter: lggg.Formatter | None,
+    ) -> None:
+        """"""
+        lggg.Handler.__init__(self)
+
+        self.extension = handler_extension_t(
+            name=name,
+            show_where=show_where,
+            show_memory_usage=show_memory_usage,
+            handler=self,
+            level=level,
+            formatter=formatter,
+        )
+
+        self.FormattedLines = self.extension.FormattedLines
+
+    def emit(self, record: lggg.LogRecord, /) -> None:
+        """"""
+        if hasattr(record, SHOW_W_RULE_ATTR):
+            message = RuleAsText(record.msg)
+        else:
+            message, _ = self.FormattedLines(record, should_join_lines=True)
+        print(message)

logger_36/{type/console.py → catalog/handler/console_rich.py}

@@ -29,68 +29,95 @@
 # 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
-from typing import ClassVar
-
-from rich.color import Color as color_t
+import typing as h
+
+from logger_36.catalog.config.console_rich import (
+    ACTUAL_COLOR,
+    DATE_TIME_COLOR,
+    ELAPSED_TIME_COLOR,
+    EXPECTED_COLOR,
+    GRAY_STYLE,
+    LEVEL_COLOR,
+)
+from logger_36.config.message import (
+    ACTUAL_PATTERNS,
+    ELAPSED_TIME_SEPARATOR,
+    EXPECTED_PATTERNS,
+    LEVEL_CLOSING,
+    WHERE_SEPARATOR,
+)
+from logger_36.constant.message import TIME_LENGTH
+from logger_36.constant.record import SHOW_W_RULE_ATTR
+from logger_36.task.format.rule import Rule
+from logger_36.type.extension import handler_extension_t
 from rich.console import Console as console_t
-from rich.markup import escape as PreProcessedForRich
-from rich.style import Style as style_t
+from rich.console import RenderableType as renderable_t
+from rich.markup import escape as EscapedForRich
 from rich.text import Text as text_t
 
-from logger_36.config import ELAPSED_TIME_SEPARATOR, LEVEL_CLOSING, WHERE_SEPARATOR
-from logger_36.constant import DATE_TIME_LENGTH
-from logger_36.type.extension import handler_extension_t
-
 
-class console_handler_t(lggg.Handler, handler_extension_t):
-    TAB_SIZE: ClassVar[int] = 5  # => CONTEXT_SEPARATOR aligned for all log levels.
-    DATE_TIME_COLOR: ClassVar[str] = "dodger_blue2"
-    LEVEL_COLOR: ClassVar[dict[int, str | style_t]] = {
-        lggg.DEBUG: "orchid",
-        lggg.INFO: "white",
-        lggg.WARNING: "yellow",
-        lggg.ERROR: "orange1",
-        lggg.CRITICAL: "red",
-    }
-    ELAPSED_TIME_COLOR: ClassVar[str] = "green"
-    ACTUAL_COLOR: ClassVar[str] = "red"
-    EXPECTED_COLOR: ClassVar[str] = "green"
-    GRAY_STYLE: ClassVar[style_t] = style_t(color=color_t.from_rgb(150, 150, 150))
-    ACTUAL_PATTERNS: ClassVar[tuple[str]] = (r" Actual=[^.]+;",)
-    EXPECTED_PATTERNS: ClassVar[tuple[str]] = (r" Expected([!<>]=|: )[^.]+\.",)
-
-    console: console_t
-
-    def __init__(self, /, *, level: int = lggg.NOTSET) -> None:
+@dtcl.dataclass(slots=True, repr=False, eq=False)
+class console_rich_handler_t(lggg.Handler):
+    extension: handler_extension_t = dtcl.field(init=False)
+    console: console_t = dtcl.field(init=False)
+    FormattedLines: h.Callable[..., tuple[str, str | None]] = dtcl.field(init=False)
+
+    name: dtcl.InitVar[str | None] = None
+    level: dtcl.InitVar[int] = lggg.NOTSET
+    show_where: dtcl.InitVar[bool] = True
+    show_memory_usage: dtcl.InitVar[bool] = False
+    formatter: dtcl.InitVar[lggg.Formatter | None] = None
+
+    rich_kwargs: dtcl.InitVar[dict[str, h.Any] | None] = None
+
+    def __post_init__(
+        self,
+        name: str | None,
+        level: int,
+        show_where: bool,
+        show_memory_usage: bool,
+        formatter: lggg.Formatter | None,
+        rich_kwargs: dict[str, h.Any] | None,
+    ) -> None:
         """"""
-        lggg.Handler.__init__(self, level=level)
-        handler_extension_t.__init__(self)
+        lggg.Handler.__init__(self)
+
+        self.extension = handler_extension_t(
+            name=name,
+            show_where=show_where,
+            show_memory_usage=show_memory_usage,
+            handler=self,
+            level=level,
+            formatter=formatter,
+        )
 
-        self.setFormatter(self.formatter)
+        if rich_kwargs is None:
+            rich_kwargs = {}
         self.console = console_t(
-            tab_size=self.__class__.TAB_SIZE,
             highlight=False,
             force_terminal=True,
             record=True,
+            **rich_kwargs,
         )
 
+        self.FormattedLines = self.extension.FormattedLines
+
     def emit(self, record: lggg.LogRecord, /) -> None:
         """"""
-        first_line, next_lines = self.MessageLines(
-            record, PreProcessed=PreProcessedForRich
-        )
-        highlighted = self.__class__.HighlightedVersion(
-            first_line, next_lines, record.levelno
-        )
-        self.console.print(highlighted, crop=False, overflow="ignore")
-
-        self.ExitOrNotIfError(record)
+        cls = self.__class__
+        if hasattr(record, SHOW_W_RULE_ATTR):
+            richer = Rule(record.msg, DATE_TIME_COLOR)
+        else:
+            first, next_s = self.FormattedLines(record, PreProcessed=EscapedForRich)
+            richer = cls.HighlightedVersion(first, next_s, record.levelno)
+        self.console.print(richer, crop=False, overflow="ignore")
 
     @classmethod
     def HighlightedVersion(
         cls, first_line: str, next_lines: str | None, log_level: int, /
-    ) -> text_t:
+    ) -> renderable_t:
         """"""
         output = text_t(first_line)
 
@@ -102,21 +129,19 @@ class console_handler_t(lggg.Handler, handler_extension_t):
             WHERE_SEPARATOR, context_end, elapsed_time_separator
         )
 
-        output.stylize(cls.DATE_TIME_COLOR, end=DATE_TIME_LENGTH)
+        output.stylize(DATE_TIME_COLOR, end=TIME_LENGTH)
         output.stylize(
-            cls.LEVEL_COLOR[log_level],
-            start=DATE_TIME_LENGTH,
+            LEVEL_COLOR[log_level],
+            start=TIME_LENGTH,
             end=context_end + 1,
         )
-        output.stylize(
-            cls.GRAY_STYLE, start=where_separator, end=elapsed_time_separator
-        )
-        output.stylize(cls.ELAPSED_TIME_COLOR, start=elapsed_time_separator)
+        output.stylize(GRAY_STYLE, start=where_separator, end=elapsed_time_separator)
+        output.stylize(ELAPSED_TIME_COLOR, start=elapsed_time_separator)
 
         if next_lines is not None:
             output.append(next_lines)
 
-        output.highlight_words(cls.ACTUAL_PATTERNS, style=cls.ACTUAL_COLOR)
-        output.highlight_words(cls.EXPECTED_PATTERNS, style=cls.EXPECTED_COLOR)
+        _ = output.highlight_regex(ACTUAL_PATTERNS, style=ACTUAL_COLOR)
+        _ = output.highlight_regex(EXPECTED_PATTERNS, style=EXPECTED_COLOR)
 
         return output

logger_36/catalog/handler/file.py

@@ -0,0 +1,90 @@
+# 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 typing as h
+from pathlib import Path as path_t
+
+from logger_36.constant.record import SHOW_W_RULE_ATTR
+from logger_36.task.format.rule import RuleAsText
+from logger_36.type.extension import handler_extension_t
+
+
+@dtcl.dataclass(slots=True, repr=False, eq=False)
+class file_handler_t(lggg.FileHandler):
+
+    extension: handler_extension_t = dtcl.field(init=False)
+    FormattedLines: h.Callable[..., tuple[str, str | None]] = dtcl.field(init=False)
+
+    name: dtcl.InitVar[str | None] = None
+    level: dtcl.InitVar[int] = lggg.NOTSET
+    show_where: dtcl.InitVar[bool] = True
+    show_memory_usage: dtcl.InitVar[bool] = False
+    formatter: dtcl.InitVar[lggg.Formatter | None] = None
+
+    path: dtcl.InitVar[path_t | None] = None
+    handler_args: dtcl.InitVar[tuple[h.Any, ...] | None] = None
+    handler_kwargs: dtcl.InitVar[dict[str, h.Any] | None] = None
+
+    def __post_init__(
+        self,
+        name: str | None,
+        level: int,
+        show_where: bool,
+        show_memory_usage: bool,
+        formatter: lggg.Formatter | None,
+        path: path_t | None,
+        handler_args: tuple[h.Any],
+        handler_kwargs: dict[str, h.Any] | None,
+    ) -> None:
+        """"""
+        lggg.FileHandler.__init__(self, path, *handler_args, **handler_kwargs)
+
+        self.extension = handler_extension_t(
+            name=name,
+            show_where=show_where,
+            show_memory_usage=show_memory_usage,
+            handler=self,
+            level=level,
+            formatter=formatter,
+        )
+
+        self.FormattedLines = self.extension.FormattedLines
+
+    def emit(self, record: lggg.LogRecord, /) -> None:
+        """"""
+        if hasattr(record, SHOW_W_RULE_ATTR):
+            message = RuleAsText(record.msg)
+        else:
+            message, _ = self.FormattedLines(record, should_join_lines=True)
+        print(message, file=self.stream)
+        self.stream.flush()

logger_36/catalog/handler/generic.py

@@ -0,0 +1,150 @@
+# 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 typing as h
+
+try:
+    from rich.console import Console as console_t
+    from rich.markup import escape as EscapedForRich
+    from rich.terminal_theme import DEFAULT_TERMINAL_THEME
+except ModuleNotFoundError:
+    console_t = EscapedForRich = DEFAULT_TERMINAL_THEME = None
+
+from logger_36.catalog.handler.console_rich import console_rich_handler_t
+from logger_36.constant.record import SHOW_W_RULE_ATTR
+from logger_36.task.format.rule import Rule
+from logger_36.type.extension import handler_extension_t
+
+
+class can_show_message_p(h.Protocol):
+    def ShowMessage(self, message: str, /) -> None: ...
+
+
+interface_h = can_show_message_p | h.Callable[[str], None]
+
+
+@dtcl.dataclass(slots=True, repr=False, eq=False)
+class generic_handler_t(lggg.Handler):
+
+    extension: handler_extension_t = dtcl.field(init=False)
+    console: console_t | None = None
+    FormattedLines: h.Callable[..., tuple[str, str | None]] = dtcl.field(init=False)
+    ShowMessage: h.Callable[[str], None] = lambda _arg: None
+
+    name: dtcl.InitVar[str | None] = None
+    level: dtcl.InitVar[int] = lggg.NOTSET
+    show_where: dtcl.InitVar[bool] = True
+    show_memory_usage: dtcl.InitVar[bool] = False
+    formatter: dtcl.InitVar[lggg.Formatter | None] = None
+
+    supports_html: dtcl.InitVar[bool] = False
+    rich_kwargs: dtcl.InitVar[dict[str, h.Any] | None] = None
+    interface: dtcl.InitVar[interface_h | None] = None
+
+    def __post_init__(
+        self,
+        name: str | None,
+        level: int,
+        show_where: bool,
+        show_memory_usage: bool,
+        formatter: lggg.Formatter | None,
+        supports_html: bool,
+        rich_kwargs: dict[str, h.Any] | None,
+        interface: interface_h | None,
+    ) -> None:
+        """"""
+        lggg.Handler.__init__(self)
+
+        self.extension = handler_extension_t(
+            name=name,
+            show_where=show_where,
+            show_memory_usage=show_memory_usage,
+            handler=self,
+            level=level,
+            formatter=formatter,
+        )
+
+        if supports_html and (console_t is not None):
+            if rich_kwargs is None:
+                rich_kwargs = {}
+            self.console = console_t(
+                highlight=False,
+                force_terminal=True,
+                **rich_kwargs,
+            )
+
+        self.FormattedLines = self.extension.FormattedLines
+
+        if interface is None:
+            raise ValueError("Interface cannot be None.")
+        self.ShowMessage = getattr(
+            interface, can_show_message_p.ShowMessage.__name__, interface
+        )
+
+    def emit(self, record: lggg.LogRecord, /) -> None:
+        """"""
+        if self.console is None:
+            message, _ = self.FormattedLines(record, should_join_lines=True)
+        else:
+            if hasattr(record, SHOW_W_RULE_ATTR):
+                richer = Rule(record.msg, console_rich_handler_t.DATE_TIME_COLOR)
+            else:
+                first, next_s = self.FormattedLines(record, PreProcessed=EscapedForRich)
+                richer = console_rich_handler_t.HighlightedVersion(
+                    first, next_s, record.levelno
+                )
+            segments = self.console.render(richer)
+
+            # Inspired from the code of: rich.console.export_html.
+            html_segments = []
+            for text, style, _ in segments:
+                if text == "\n":
+                    html_segments.append("\n")
+                else:
+                    if style is not None:
+                        style = style.get_html_style(DEFAULT_TERMINAL_THEME)
+                        if (style is not None) and (style.__len__() > 0):
+                            text = f'<span style="{style}">{text}</span>'
+                    html_segments.append(text)
+            if html_segments[-1] == "\n":
+                html_segments = html_segments[:-1]
+
+            # /!\ For some reason, the widget splits the message into lines, place each
+            # line inside a pre tag, and set margin-bottom of the first and list lines
+            # to 12px. This can be seen by printing self.contents.toHtml(). To avoid the
+            # unwanted extra margins, margin-bottom is set to 0 below.
+            message = (
+                "<pre style='margin-bottom:0px'>" + "".join(html_segments) + "</pre>"
+            )
+
+        self.ShowMessage(message)

logger_36/catalog/logging/chronos.py

@@ -0,0 +1,39 @@
+# 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.
+
+from logger_36.constant.handler import HIDE_WHERE_KWARG
+from logger_36.instance import LOGGER
+from logger_36.task.measure.chronos import ElapsedTime
+
+
+def LogElapsedTime() -> None:
+    """"""
+    LOGGER.info(f"Elapsed Time: {ElapsedTime()}", **HIDE_WHERE_KWARG)

logger_36/catalog/{gpu.py → logging/gpu.py}

@@ -29,6 +29,7 @@
 # The fact that you are presently reading this means that you have had
 # knowledge of the CeCILL license and that you accept its terms.
 
+from logger_36.constant.handler import HIDE_WHERE_KWARG
 from logger_36.instance import LOGGER
 
 try:
@@ -52,5 +53,6 @@ def LogGPURelatedDetails() -> None:
         f"               CuDNN: {system_details['cudnn_version']}\n"
         f"          Tensorflow: {tsfl.version.VERSION}\n"
         f"    Tensorflow Build: {tsfl.sysconfig.get_build_info()}\n"
-        f"            TensorRT: {tsrt.__version__}"
+        f"            TensorRT: {tsrt.__version__}",
+        **HIDE_WHERE_KWARG,
     )