SwiftGUI_Logging 0.0.2__tar.gz → 0.1.0__tar.gz

{swiftgui_logging-0.0.2 → swiftgui_logging-0.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SwiftGUI_Logging
-Version: 0.0.2
+Version: 0.1.0
 Summary: A collection of helpful logging-functionality based on the logging package
 License-Expression: Apache-2.0
 License-File: LICENSE

{swiftgui_logging-0.0.2 → swiftgui_logging-0.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "SwiftGUI_Logging"
-version = "0.0.2"
+version = "0.1.0"
 packages = [
     { include = "SwiftGUI_Logging", from = "src" }
 ]

swiftgui_logging-0.1.0/src/SwiftGUI_Logging/Configs/ExceptionLogging.py

@@ -0,0 +1,69 @@
+import SwiftGUI_Logging as sgl
+from pathlib import Path
+import logging
+from datetime import datetime as dt
+import io
+import shutil
+
+def exceptions_to_file(
+        filepath: str | Path,
+        logger: str | logging.Logger = "",
+        buffer_size: int = 5000,
+        trigger_level: int = logging.ERROR,
+        log_level: int = logging.DEBUG,
+        reraise: bool = False,
+        datetime_format: str = "_%Y-%m-%d_%H-%M-%S",
+        formatter_format: str = "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+):
+    """
+    Buffers the last n logging-entries.
+    If the program executes as expected, nothing happens.
+    If an exception crashes the program, the whole buffer is logged to a file, including the exception.
+
+    This is also true if the logger receives a report of loglevel higher than the specified trigger.
+
+    Every filesave generates its own file with a timestamp in the name.
+
+    :param filepath: Path to a log-file WITHOUT THE TIMESTAMP. The timestamp is added at the end before the suffix.
+    :param logger: You can specify which logger should receive the exception-logs.
+    :param buffer_size: How many reports are saved before the first ones are overritten again
+    :param trigger_level: Level at which the exceptions are treated. Reports at and above this level trigger a file-write
+    :param log_level: Logs below this level are ignored and not written to the file
+    :param reraise: True, if the exception should still be raised, even though it was logged. Good for debugging purposes
+    :param datetime_format: Format of the timestamp that extends the filename
+    :param formatter_format: Format of the log-entries in the file
+    :return:
+    """
+    filepath = Path(filepath)
+    filepath.parent.mkdir(parents=True, exist_ok=True)
+
+    filepath = filepath.parent / (filepath.stem + dt.now().strftime(datetime_format) + filepath.suffix)
+
+    if isinstance(logger, str):
+        logger = logging.getLogger(logger)
+
+    logger.setLevel(log_level)
+
+    stream = io.StringIO()
+    stream_handler = logging.StreamHandler(stream)
+    stream_handler.setFormatter(
+        logging.Formatter(formatter_format)
+    )
+    buffer_handler = sgl.MemoryHandlerRotatingBuffer(buffer_size, trigger_level, target=stream_handler)
+
+    logger.addHandler(buffer_handler)
+
+    def exception_occured(*_):
+        stream.seek(0)
+        if not stream.read(1):
+            # Nothing to report
+            print("Nothing to report")
+            return
+
+        with open(filepath, "w") as f:
+            stream.seek(0)
+            #f.write(stream.read())
+            shutil.copyfileobj(stream, f)
+
+    sgl.reroute_exceptions(logger, reraise=reraise, loglevel=trigger_level, pass_text_to_function=exception_occured)
+

swiftgui_logging-0.1.0/src/SwiftGUI_Logging/Configs/__init__.py

@@ -0,0 +1,3 @@
+
+from .ExceptionLogging import exceptions_to_file
+

swiftgui_logging-0.1.0/src/SwiftGUI_Logging/ExceptionHandling.py

@@ -0,0 +1,64 @@
+import logging.handlers
+import traceback
+import sys
+from typing import Callable, Any
+
+
+def reroute_exceptions(
+        logger: logging.Logger = logging.getLogger(),
+        loglevel: int = logging.CRITICAL,
+        *,
+        logger_warnings: logging.Logger = None,
+        loglevel_warnings: int = logging.WARNING,
+        reraise: bool = False,
+        print_to_console: bool = False,
+        pass_text_to_function: Callable[[str], Any] = None,
+):
+    """
+    Catch all unhandled exceptions and log them
+
+    :param logger: The logger where EXCEPTIONS go
+    :param loglevel: The loglevel for EXCEPTIONS
+    :param logger_warnings: The logger where WARNINGS go
+    :param loglevel_warnings: The level of logging for WARNINGS
+    :param reraise: True, if the exception should be raised again
+    :param pass_text_to_function: Pass a function/method and the exception-text is passed to it
+    :param print_to_console: True, if the text should be printed to the console using print(...)
+    :return:
+    """
+    if logger_warnings is None:
+        logger_warnings = logger
+
+    if loglevel_warnings is None:
+        loglevel_warnings = loglevel
+
+    def catch(exctype, value, tb):
+        text = "".join(traceback.format_exception(exctype, value, tb))
+
+        if issubclass(exctype, Warning):    # Warnings
+            if logger_warnings is not None:
+                logger_warnings.log(
+                    loglevel_warnings,
+                    text,
+                )
+        elif issubclass(exctype, Exception):    # Real exceptions
+            if logger is not None:
+                logger.log(
+                    loglevel,
+                    text,
+                )
+        else:
+            # Keyboard interrupts and such
+            sys.__excepthook__(exctype, value, tb)
+            return  # Not really necessary
+
+        if pass_text_to_function:
+            pass_text_to_function(text)
+
+        if print_to_console:
+            print(text)
+
+        if reraise:
+            sys.__excepthook__(exctype, value, tb)
+
+    sys.excepthook = catch

swiftgui_logging-0.1.0/src/SwiftGUI_Logging/MemoryHandlerRotatingBuffer.py

@@ -0,0 +1,31 @@
+import logging.handlers
+
+
+class MemoryHandlerRotatingBuffer(logging.handlers.MemoryHandler):
+
+    def __init__(self, capacity, flushLevel=logging.ERROR, target=None):
+        """
+        This handler saves the last n records.
+        Following records replace the oldest ones.
+        If something with a higher level than 'flushLevel' is logged, the handler passes all entries to another, specified handler.
+
+        THE BUFFER STILL FLUSHES WHEN THE SCRIPT ENDS, I COULDN'T AVOID THAT...
+        Happy for suggestions.
+
+        :param capacity: How many records to buffer before the oldest ones get deleted
+        :param flushLevel: At which level of record the whole buffer is passed to the target-handler
+        :param target: Handler to receive all records if necessary
+        """
+        super().__init__(capacity, flushLevel, target, flushOnClose=False)
+
+    def shouldFlush(self, record):
+        """
+        New records are checked if the "flushing-condition" is met.
+        :param record:
+        :return:
+        """
+        if len(self.buffer) > self.capacity:    # Remove 0th element so the buffer doesn't "overflow"
+            self.buffer.pop(0)
+
+        return record.levelno >= self.flushLevel
+

swiftgui_logging-0.1.0/src/SwiftGUI_Logging/Utils.py

@@ -0,0 +1,12 @@
+import logging
+
+
+def disable_root_handlers():
+    """
+    Remove all root handlers so the root handler does nothing.
+    Useful when you want to generate the logging-system from ground up
+    :return:
+    """
+    logging.getLogger().handlers.clear()
+    logging.getLogger().addHandler(logging.NullHandler())
+

swiftgui_logging-0.1.0/src/SwiftGUI_Logging/__init__.py

@@ -0,0 +1,9 @@
+
+from .ExceptionHandling import reroute_exceptions
+from .MemoryHandlerRotatingBuffer import MemoryHandlerRotatingBuffer
+from .Utils import disable_root_handlers
+
+from . import Configs
+
+
+

swiftgui_logging-0.0.2/src/SwiftGUI_Logging/__init__.py

@@ -1,3 +0,0 @@
-
-from . import test
-print("WIP")