logger-36 2023.4__tar.gz → 2023.6__tar.gz

{logger-36-2023.4 → logger-36-2023.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: logger-36
-Version: 2023.4
+Version: 2023.6
 Summary: Simple logger using rich_
 Home-page: https://src.koda.cnrs.fr/eric.debreuve/logger-36/
 Author: Eric Debreuve

{logger-36-2023.4 → logger-36-2023.6}/logger_36/main.py

@@ -46,29 +46,27 @@ try:
     from psutil import Process as process_t
 
     _PROCESS = process_t()
-    _GIGA_SCALING = 1.0 / (1024**3)
-
-    def UsedMemoryInGb() -> float:
-        """"""
-        return round(_GIGA_SCALING * _PROCESS.memory_info().rss, 1)
-
+    _MEGA_SCALING = 1.0 / (1024.0**2)
+    _GIGA_SCALING = _MEGA_SCALING / 1024.0
 except ModuleNotFoundError:
     _PROCESS = None
-
-    def UsedMemoryInGb() -> float:
-        """"""
-        return 0.0
+    _MEGA_SCALING = _GIGA_SCALING = 0.0
 
 
 # This module is certainly imported early. Therefore, the current time should be close enough to the real start time.
 _START_TIME = time.time()
 
+_TERMINAL_WIDTH = 1000
+_TAB_SIZE = 5
 
+_WHERE_SEPARATOR = "@"
+# Tab size is set by console_t so that the dash is aligned for all log levels (might not work for file handlers though)
 _MESSAGE_FORMAT = (
-    "%(asctime)s[%(levelname)s]\t- "
-    "%(message)s @ "
-    "%(module)s:%(funcName)s:%(lineno)d"
+    f"%(asctime)s[%(levelname)s]\t- "
+    f"%(message)s {_WHERE_SEPARATOR} "
+    f"%(module)s:%(funcName)s:%(lineno)d"
 )
+_NEXT_LINE_PROLOGUE = "\n" + (27 + _TAB_SIZE) * " "
 _DATE_FORMAT = "%Y-%m-%d@%H:%M:%S"
 
 _SYSTEM_DETAILS = (
@@ -93,15 +91,52 @@ _SYSTEM_DETAILS = {_dtl.capitalize(): getattr(pltf, _dtl)() for _dtl in _SYSTEM_
 _MAX_DETAIL_NAME_LENGTH = max(map(len, _SYSTEM_DETAILS.keys()))
 
 
-# TODO: might be simpler/better to use filters (https://devdocs.io/python~3.10/howto/logging-cookbook#context-info) or a
-#     logging.LoggerAdapter
+# Alternative implementations: using logging.Filter or logging.LoggerAdapter
+
+
 class _handler_extension:
-    formatter: lggg.Formatter = None
-    show_memory_usage: bool = False
+    __slots__ = ("formatter", "show_memory_usage")
+    formatter: lggg.Formatter
+    show_memory_usage: bool
 
     def __init__(self) -> None:
         """"""
         self.formatter = lggg.Formatter(fmt=_MESSAGE_FORMAT, datefmt=_DATE_FORMAT)
+        self.show_memory_usage = False
+
+    def FormattedMessage(
+        self, record: lggg.LogRecord, /
+    ) -> tuple[str, list[str] | None]:
+        """
+        Note: "message" is not yet an attribute of record (it will be set by format()); Use "msg" instead.
+        """
+        if not isinstance(record.msg, str):
+            record.msg = str(record.msg)
+        if "\n" in record.msg:
+            original_message = record.msg
+            lines = original_message.splitlines()
+            record.msg = lines[0]
+        else:
+            original_message = lines = None
+
+        formatted = self.formatter.format(record)
+
+        # Revert the record message to its original value for subsequent handlers
+        if original_message is not None:
+            record.msg = original_message
+
+        return formatted, lines
+
+    def MemoryUsage(self) -> str:
+        """"""
+        if self.show_memory_usage:
+            usage = _PROCESS.memory_info().rss
+            if usage > _GIGA_SCALING:
+                return f" :{round(_GIGA_SCALING * usage, 1)}GB"
+            else:
+                return f" :{round(_MEGA_SCALING * usage, 1)}MB"
+
+        return ""
 
 
 class console_handler_t(lggg.Handler, _handler_extension):
@@ -116,7 +151,7 @@ class console_handler_t(lggg.Handler, _handler_extension):
     _ACTUAL: ClassVar[str] = r" Actual=[^.]+\."
     _EXPECTED: ClassVar[str] = r" Expected([!<>]=|: )[^.]+\."
 
-    console: console_t = None
+    console: console_t
 
     def __init__(self, /, *, level=lggg.NOTSET) -> None:
         """"""
@@ -125,33 +160,28 @@ class console_handler_t(lggg.Handler, _handler_extension):
 
         self.setFormatter(self.formatter)
         self.console = console_t(
-            record=True, force_terminal=True, width=1000, tab_size=5
+            record=True, force_terminal=True, width=_TERMINAL_WIDTH, tab_size=_TAB_SIZE
         )
 
     def emit(self, record: lggg.LogRecord, /) -> None:
         """"""
         cls = self.__class__
 
-        formatted = self.formatter.format(record)
-        if self.show_memory_usage:
-            memory_usage = f" :{UsedMemoryInGb()}Gb"
-        else:
-            memory_usage = ""
-        if "\n" in formatted:
-            lines = formatted.splitlines()
-            highlighted = text_t(lines[0])
-            highlighted.append(f" +{ElapsedTime()}{memory_usage}\n", style="green")
-            highlighted.append("    " + "\n    ".join(lines[1:]))
-        else:
-            highlighted = text_t(formatted)
-            highlighted.append(f" +{ElapsedTime()}{memory_usage}", style="green")
+        formatted, lines = self.FormattedMessage(record)
+
+        highlighted = text_t(formatted)
+        highlighted.append(f" +{ElapsedTime()}{self.MemoryUsage()}", style="green")
+        if lines is not None:
+            highlighted.append(
+                _NEXT_LINE_PROLOGUE + _NEXT_LINE_PROLOGUE.join(lines[1:])
+            )
 
         highlighted.stylize("dodger_blue2", end=19)
         highlighted.highlight_words(
             (f"[{record.levelname}]",), style=cls._LEVEL_COLOR[record.levelno]
         )
         highlighted.highlight_regex(
-            f"@ {record.module}:{record.funcName}:{record.lineno}",
+            f"{_WHERE_SEPARATOR} {record.module}:{record.funcName}:{record.lineno}",
             style=cls._GRAY_STYLE,
         )
         highlighted.highlight_regex(cls._ACTUAL, style="red")
@@ -161,26 +191,23 @@ class console_handler_t(lggg.Handler, _handler_extension):
 
 
 class file_handler_t(lggg.FileHandler, _handler_extension):
-    def __init__(self, file: str, *args, **kwargs) -> None:
+    def __init__(self, file: str | path_t, *args, **kwargs) -> None:
         """"""
-        lggg.FileHandler.__init__(self, file, *args, **kwargs)
+        lggg.FileHandler.__init__(self, str(file), *args, **kwargs)
         _handler_extension.__init__(self)
 
         self.setFormatter(self.formatter)
 
     def emit(self, record: lggg.LogRecord, /) -> None:
         """"""
-        formatted = self.formatter.format(record)
-        if self.show_memory_usage:
-            memory_usage = f" :{UsedMemoryInGb()}Gb"
-        else:
-            memory_usage = ""
-        if "\n" in formatted:
-            lines = formatted.splitlines()
-            next_lines = "\n    ".join(lines[1:])
-            message = f"{lines[0]} +{ElapsedTime()}{memory_usage}\n    {next_lines}"
+        formatted, lines = self.FormattedMessage(record)
+        formatted = formatted.replace("\t", (9 - record.levelname.__len__()) * " ")
+
+        if lines is None:
+            message = f"{formatted} +{ElapsedTime()}{self.MemoryUsage()}"
         else:
-            message = f"{formatted} +{ElapsedTime()}{memory_usage}"
+            next_lines = _NEXT_LINE_PROLOGUE.join(lines[1:])
+            message = f"{formatted} +{ElapsedTime()}{self.MemoryUsage()}{_NEXT_LINE_PROLOGUE}{next_lines}"
 
         print(message, file=self.stream)
         self.stream.flush()
@@ -213,7 +240,7 @@ def AddFileHandler(file: Union[str, path_t], /) -> None:
 def SaveLOGasHTML(file: Union[str, path_t], /) -> None:
     """"""
     if file.exists():
-        raise ValueError(f"{file}: File already exists")
+        print(f'Cannot save logging record as HTML: File "{file}" already exists')
 
     console = None
     found = False
@@ -225,7 +252,7 @@ def SaveLOGasHTML(file: Union[str, path_t], /) -> None:
         with open(file, "w") as accessor:
             accessor.write(console.export_html())
 
-    raise ValueError("Cannot save logging record as HTML: Handler has no RICH console")
+    print("Cannot save logging record as HTML: No handler has a RICH console")
 
 
 def WhereFunction(function: Any, /) -> str:

logger-36-2023.6/logger_36/test.py

@@ -0,0 +1,50 @@
+# 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 pathlib import Path as path_t
+from tempfile import TemporaryDirectory
+
+from logger_36 import LOGGER, AddFileHandler
+
+
+with TemporaryDirectory() as tmp_folder:
+    tmp_folder = path_t(tmp_folder)
+    tmp_file = tmp_folder / "log.txt"
+
+    AddFileHandler(tmp_file)
+
+    for level in ("debug", "info", "warning", "error", "critical"):
+        LogMessage = getattr(LOGGER, level)
+        LogMessage(f"{level.capitalize()} message")
+        LogMessage(f"Multi-line\n{level.capitalize()}\nmessage")
+
+    content = open(tmp_file, "r").read()
+    print(f"\n{content}")

{logger-36-2023.4 → logger-36-2023.6}/logger_36/version.py

@@ -29,4 +29,4 @@
 # The fact that you are presently reading this means that you have had
 # knowledge of the CeCILL license and that you accept its terms.
 
-__version__ = "2023.4"
+__version__ = "2023.6"

{logger-36-2023.4 → logger-36-2023.6}/logger_36.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: logger-36
-Version: 2023.4
+Version: 2023.6
 Summary: Simple logger using rich_
 Home-page: https://src.koda.cnrs.fr/eric.debreuve/logger-36/
 Author: Eric Debreuve

{logger-36-2023.4 → logger-36-2023.6}/logger_36.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ setup.py
 documentation/wiki/description.asciidoc
 logger_36/__init__.py
 logger_36/main.py
+logger_36/test.py
 logger_36/version.py
 logger_36.egg-info/PKG-INFO
 logger_36.egg-info/SOURCES.txt