SwiftGUI_Logging 0.0.2__tar.gz → 0.1.1__tar.gz

swiftgui_logging-0.1.1/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: SwiftGUI_Logging
+Version: 0.1.1
+Summary: A collection of helpful logging-functionality based on the logging package
+License-Expression: Apache-2.0
+License-File: LICENSE
+Author: Eric aka CheesecakeTV
+Author-email: cheesecaketv53+pypi@gmail.com
+Requires-Python: >=3.10
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Project-URL: Documentation, https://github.com/CheesecakeTV/SwiftGUI-Docs
+Project-URL: Repository, https://github.com/CheesecakeTV/SwiftGUI-Logging
+Project-URL: issues, https://github.com/CheesecakeTV/SwiftGUI/issues
+Description-Content-Type: text/markdown
+
+
+# SwiftGUI-Logging: Motivation
+A small package ment to extend logging to better fit actual applications.
+
+Before getting into the logging-package, I usually implemented 
+something like this (but more complicated):
+```py
+def main():
+    ...
+
+if __name__ == "__main__":
+    try:
+        main()  # Run the main program
+    except Exception as ex: # An exception occured
+        with open("Crashlog.txt", "w") as f:    # Save exception to file
+            f.write(str(ex))
+```
+If `main()` causes an exception, the file `Crashlog.txt` is created
+containing information about the exception.
+That means, only "the interesting logs" take up storage space.
+
+Unfortunately, you can't implement such a functionality using the 
+logging-package.
+
+Until now.
+
+SwiftGUI-Logging provides a very easy way to set up crashlogs that 
+are fully compatible with the logging-package.
+
+# Basic usage
+## Installation
+Install the package by running this on your terminal:
+```bash
+pip install SwiftGUI_Logging
+```
+
+## Crashlogging to a file
+Simply call `SwiftGUI_Logging.Configs.exceptions_to_file(filepath)` 
+to set up the crashlogger.
+
+That's all.
+
+Example:
+```py
+import time
+import SwiftGUI_Logging as sgl
+import logging
+
+def main():
+    for i in range(10):
+        logging.debug(f"Test {i}")
+        print(i)
+        time.sleep(0.25)
+
+    logging.info("Crashing the program now")
+
+    1 / 0   # Cause a ZeroDivisionError, which crashes the program
+
+if __name__ == '__main__':
+    sgl.Configs.exceptions_to_file("Crashlogs/Crash.log") # Set up the crash-log
+    main()  # Execute program
+```
+
+You'll find that the directory `Crashlogs` was created.
+After the program executes, the directory contains a file like
+`Crash_2026-02-24_16-16-38.log`.
+
+As you can see, the time of the crash was inserted into the 
+filename, so that multiple crashlogs don't overwrite each other.
+
+`sgl.Configs.exceptions_to_file` can do a bit more, but for most programs,
+the default configuration is fine.
+
+## Other functionality
+`SwiftGUI_Logging` provides some other functionality, but these
+aren't nearly as important as the `exceptions_to_file`-function.
+
+A detailed documentation will follow.
+
+# SwiftGUI
+This package was written as an addition to 
+my Python GUI-package `SwiftGUI`:
+https://github.com/CheesecakeTV/SwiftGUI
+
+Since `SwiftGUI_Logging` itself has nothing to to with GUIs, 
+it is its own package.
+
+Consider checking out `SwiftGUI` if you want to easily create 
+user-interfaces for python.
+If you already know the package `PySimpleGUI`, you'll learn the 
+basics of`SwiftGUI` with little to no effort.
+
+
+

swiftgui_logging-0.1.1/README.md

@@ -0,0 +1,93 @@
+
+# SwiftGUI-Logging: Motivation
+A small package ment to extend logging to better fit actual applications.
+
+Before getting into the logging-package, I usually implemented 
+something like this (but more complicated):
+```py
+def main():
+    ...
+
+if __name__ == "__main__":
+    try:
+        main()  # Run the main program
+    except Exception as ex: # An exception occured
+        with open("Crashlog.txt", "w") as f:    # Save exception to file
+            f.write(str(ex))
+```
+If `main()` causes an exception, the file `Crashlog.txt` is created
+containing information about the exception.
+That means, only "the interesting logs" take up storage space.
+
+Unfortunately, you can't implement such a functionality using the 
+logging-package.
+
+Until now.
+
+SwiftGUI-Logging provides a very easy way to set up crashlogs that 
+are fully compatible with the logging-package.
+
+# Basic usage
+## Installation
+Install the package by running this on your terminal:
+```bash
+pip install SwiftGUI_Logging
+```
+
+## Crashlogging to a file
+Simply call `SwiftGUI_Logging.Configs.exceptions_to_file(filepath)` 
+to set up the crashlogger.
+
+That's all.
+
+Example:
+```py
+import time
+import SwiftGUI_Logging as sgl
+import logging
+
+def main():
+    for i in range(10):
+        logging.debug(f"Test {i}")
+        print(i)
+        time.sleep(0.25)
+
+    logging.info("Crashing the program now")
+
+    1 / 0   # Cause a ZeroDivisionError, which crashes the program
+
+if __name__ == '__main__':
+    sgl.Configs.exceptions_to_file("Crashlogs/Crash.log") # Set up the crash-log
+    main()  # Execute program
+```
+
+You'll find that the directory `Crashlogs` was created.
+After the program executes, the directory contains a file like
+`Crash_2026-02-24_16-16-38.log`.
+
+As you can see, the time of the crash was inserted into the 
+filename, so that multiple crashlogs don't overwrite each other.
+
+`sgl.Configs.exceptions_to_file` can do a bit more, but for most programs,
+the default configuration is fine.
+
+## Other functionality
+`SwiftGUI_Logging` provides some other functionality, but these
+aren't nearly as important as the `exceptions_to_file`-function.
+
+A detailed documentation will follow.
+
+# SwiftGUI
+This package was written as an addition to 
+my Python GUI-package `SwiftGUI`:
+https://github.com/CheesecakeTV/SwiftGUI
+
+Since `SwiftGUI_Logging` itself has nothing to to with GUIs, 
+it is its own package.
+
+Consider checking out `SwiftGUI` if you want to easily create 
+user-interfaces for python.
+If you already know the package `PySimpleGUI`, you'll learn the 
+basics of`SwiftGUI` with little to no effort.
+
+

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

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

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

@@ -0,0 +1,75 @@
+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)
+
+    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)
+    )
+
+    def exception_occured(*_):
+        nonlocal stream
+        stream.seek(0)
+
+        if not stream.read(1):
+            # Nothing to report
+            return
+
+        # Add current datetime to filename
+        actual_filepath = filepath.parent / (filepath.stem + dt.now().strftime(datetime_format) + filepath.suffix)
+
+        with open(actual_filepath, "w") as f:
+            stream.seek(0)
+            shutil.copyfileobj(stream, f)
+
+        stream.close()
+        stream = io.StringIO()  # "Clear" the buffer
+        stream_handler.setStream(stream)
+
+    buffer_handler = sgl.MemoryHandlerRotatingBuffer(buffer_size, trigger_level, target=stream_handler, call_after_flushing=exception_occured)
+
+    logger.addHandler(buffer_handler)
+
+    sgl.reroute_exceptions(logger, reraise=reraise, loglevel=trigger_level, pass_text_to_function=exception_occured)
+

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

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

swiftgui_logging-0.1.1/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.1/src/SwiftGUI_Logging/MemoryHandlerRotatingBuffer.py

@@ -0,0 +1,39 @@
+import logging.handlers
+from typing import Callable
+
+
+class MemoryHandlerRotatingBuffer(logging.handlers.MemoryHandler):
+
+    def __init__(self, capacity, flushLevel=logging.ERROR, target=None, call_after_flushing: Callable = 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 call_after_flushing: Call this function after passing the entries to the target
+        :param target: Handler to receive all records if necessary
+        """
+        super().__init__(capacity, flushLevel, target, flushOnClose=False)
+        self.call_after_flushing = call_after_flushing if call_after_flushing else lambda *_:_
+
+    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
+
+    def flush(self):
+        super().flush()
+        self.call_after_flushing()
+
+

swiftgui_logging-0.1.1/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.1/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/PKG-INFO

@@ -1,21 +0,0 @@
-Metadata-Version: 2.4
-Name: SwiftGUI_Logging
-Version: 0.0.2
-Summary: A collection of helpful logging-functionality based on the logging package
-License-Expression: Apache-2.0
-License-File: LICENSE
-Author: Eric aka CheesecakeTV
-Author-email: cheesecaketv53+pypi@gmail.com
-Requires-Python: >=3.10
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: OS Independent
-Project-URL: Documentation, https://github.com/CheesecakeTV/SwiftGUI-Docs
-Project-URL: Repository, https://github.com/CheesecakeTV/SwiftGUI-Logging
-Project-URL: issues, https://github.com/CheesecakeTV/SwiftGUI/issues
-Description-Content-Type: text/markdown
-
-
-# SwiftGUI-Logging
-
-Still WIP
-

swiftgui_logging-0.0.2/README.md

@@ -1,4 +0,0 @@
-
-# SwiftGUI-Logging
-
-Still WIP

swiftgui_logging-0.0.2/src/SwiftGUI_Logging/__init__.py

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