bear-utils 0.0.1__py3-none-any.whl

bear_utils/logger_manager/loggers/base_logger.py

@@ -0,0 +1,244 @@
+"""BaseLogger: A comprehensive console logger that is the foundation for all other loggers."""
+
+from functools import partial
+from io import StringIO
+import sys
+from typing import Any, Self
+
+from prompt_toolkit.formatted_text import ANSI, FormattedText, to_formatted_text
+from prompt_toolkit.shortcuts import print_formatted_text
+from rich.text import Text
+from rich.theme import Theme
+from rich.traceback import Traceback
+from singleton_base import SingletonBase
+
+from bear_utils.logger_manager._common import ExecValues, StackLevelTracker
+from bear_utils.logger_manager._styles import DEFAULT_THEME, LOGGER_METHODS, LoggerExtraInfo
+from bear_utils.logger_manager.loggers._console import LogConsole
+
+from ._level_sin import INFO, add_level_name, check_level, lvl_exists
+from .sub_logger import SubConsoleLogger
+
+# TODO: Needs some work since this is so tightly coupled with the ConsoleLogger
+
+
+class BaseLogger(SingletonBase):
+    """BaseLogger: A comprehensive console logger that is the foundation for all other loggers."""
+
+    def __init__(
+        self,
+        output_handler: Any = None,
+        theme: Theme | None = None,
+        style_disabled: bool = False,
+        logger_mode: bool = False,
+        **kwargs,
+    ) -> None:
+        """Initialize the BaseLogger with an optional style_disabled flag.
+
+        This flag can be used to disable styled output in the logger.
+        """
+        self.output_handler = output_handler or self._default_output
+        self._level: int = kwargs.get("level", INFO)
+        self.stack_tracker: StackLevelTracker = StackLevelTracker()
+        self.logger_mode: bool = logger_mode
+        self.theme: Theme = DEFAULT_THEME if theme is None else theme
+        self.style_disabled: bool = style_disabled
+        self.console: LogConsole[StringIO] = self.get_console(self.theme, style_disabled)
+        self.console_buffer: StringIO = self.console.file
+        self.backup_console = LogConsole(theme=self.theme, highlight=True, force_terminal=True)
+        self._generate_style_methods()
+
+    @staticmethod
+    def get_console(theme: Theme, style_disabled: bool) -> LogConsole:
+        """Create and return a Console instance with the specified theme and styling options."""
+        if style_disabled:
+            console = LogConsole(
+                file=StringIO(),
+                highlight=False,
+                force_terminal=True,
+                style=None,  # Disable styling
+            )
+        else:
+            console: LogConsole = LogConsole(
+                file=StringIO(),
+                highlight=False,
+                force_terminal=True,
+                color_system="truecolor",
+                theme=theme,
+            )
+        return console
+
+    def _default_output(self, msg: object, _: LoggerExtraInfo, *args, **kwargs) -> None:
+        """Default output handler that prints to console."""
+        if not self.logger_mode:
+            self.print(msg, *args, **kwargs)
+
+    def __enter__(self) -> Self:
+        """Enter the context manager, returning the ConsoleLogger instance.
+
+        This allows for using the logger in a with statement.
+        """
+        return self
+
+    def __exit__(self, exc_type: object, exc_value: object, traceback: object) -> None:
+        """Exit the context manager, cleaning up resources.
+
+        This is called when the with statement is exited.
+        """
+        self.exit()
+
+    def trigger_buffer_flush(self) -> str | Text:
+        """Flush buffered messages to console output."""
+        return "No buffering handler available."
+
+    def set_base_level(self, level: int | str) -> None:
+        """Set the logging level for the console.
+
+        This method allows changing the logging level dynamically.
+
+        This isn't actually a logging logger so we are having to add this while avoiding messing with
+        any subclasses that do subclass Logger.
+
+        Args:
+            level (int): The logging level to set. This should be a valid logging level constant.
+        """
+        self._level = check_level(level)
+
+    def filter_by_level(self, level: str | int) -> bool:
+        """Filter method to determine if a message should be logged based on its level.
+
+        This method checks if the provided level is greater than or equal to the logger's level.
+
+        Args:
+            level (int): The logging level of the message.
+
+        Returns:
+            bool: True if the message should be logged, False otherwise.
+        """
+        level = check_level(level)
+        return level >= self._level
+
+    def get_sub_logger(self, namespace: str, **kwargs) -> "SubConsoleLogger":
+        """Get a sub-logger with a specific namespace."""
+        return SubConsoleLogger(self, namespace, **kwargs)  # type: ignore[return-value]
+
+    def _generate_style_methods(self) -> None:
+        """Generate dynamic logging methods with proper log level registration."""
+        for style_name, extra in LOGGER_METHODS.items():
+            if not lvl_exists(extra["log_level"]):  # I'd rather if things crash than silently fail
+                add_level_name(extra["log_level"], extra.get("style_name"))
+            setattr(self, style_name, partial(self.replacement_method, injected_extra=extra.copy()))
+
+    def replacement_method(self, msg: object, *args, **kwargs) -> None:
+        """Replacement method for logging messages with additional context."""
+        if self.stack_tracker.not_set:
+            self.stack_tracker.record_start()
+        filter_func = kwargs.pop("filter_func", self.filter_by_level)
+        extra: LoggerExtraInfo = kwargs.pop("injected_extra") | kwargs.pop("extra", {})
+        kwargs["style"] = extra.pop("style", None)
+        if extra.get("namespace"):
+            msg = f"<{extra.get('namespace')}> {msg}"
+        if filter_func(extra.get("log_level", self._level)):
+            self.output_handler(msg, extra, *args, **kwargs)
+
+    def print(
+        self,
+        msg: object,
+        end: str = "\n",
+        exc_info: object | None = None,
+        extra: dict | None = None,
+        *_,
+        **kwargs,
+    ) -> None | str:
+        """Print a message to the console with the specified formatting.
+
+        This method allows for printing messages with additional context and formatting.
+        """
+        if exc_info is not None:
+            try:
+                exception: Traceback = self._get_exception(manual=True)
+                self._print(exception, end=end, **kwargs)
+            except Exception as e:
+                print(
+                    f"ConsoleLogger: Error printing exception traceback. Message: {msg} Exception: {exc_info} Error: {e}"
+                )
+        self._print(msg, end, style=kwargs.pop("style", None))
+        if extra:
+            self._print(msg=extra, end=end, json=True, indent=4)
+
+    def print_json(
+        self,
+        json: str | None = None,
+        data: dict | None = None,
+        indent: int = 2,
+        sort: bool = False,
+        **kwargs,
+    ) -> None:
+        """Just a pass-through to the console.print_json method."""
+        self.console.print_json(json=json, data=data, indent=indent, sort_keys=sort, **kwargs)
+
+    def raw_print(self, msg: object, end: str = "\n", *_, **kwargs) -> None:
+        """Use the underlying console directly and bypass all the extra formatting and handling.
+
+        Args:
+            msg (object): The message to print.
+            end (str, optional): The string appended after the message. Defaults to new line.
+        """
+        self.backup_console.print(msg, end=end, style=kwargs.pop("style", "white"), **kwargs)
+
+    def _print(self, msg: object, end: str, json: bool = False, *args, **kwargs) -> None:
+        """Print a message to the console with the specified formatting.
+
+        This method allows for printing messages with additional context and formatting.
+        """
+        try:
+            if json:
+                self.print_json(msg, *args, **kwargs)  # type: ignore[arg-type]
+            else:
+                self.console.print(msg, end="", style=kwargs.pop("style", "white"))
+            formatted_text: FormattedText = to_formatted_text(ANSI(self.console_buffer.getvalue()))
+            print_formatted_text(formatted_text, end=end)
+            self._reset_buffer()
+        except Exception as e:
+            print(
+                f"{self.__class__.__name__.upper()}: Error printing message. Message: {msg} Exception: {e}. "
+                "Please check the console buffer for more details."
+            )
+            self._reset_buffer()
+
+    def _extract_exception_values(self, exc_info: Any) -> ExecValues | None:
+        """Extract exception values in a clean, reusable way."""
+        if isinstance(exc_info, BaseException):
+            exc_tuple = (type(exc_info), exc_info, exc_info.__traceback__)
+        elif exc_info is True:
+            exc_tuple = sys.exc_info()
+        else:
+            exc_tuple = exc_info
+        if exc_tuple:
+            exc_type, exc_value, exc_traceback = exc_tuple
+            if exc_type is not None and exc_value is not None and exc_traceback is not None:
+                return {"exc_type": exc_type, "exc_value": exc_value, "exc_traceback": exc_traceback}
+        return None
+
+    def _get_exception(self, manual: bool = False, exec_values: ExecValues | None = None) -> Traceback:
+        if manual and exec_values:
+            return Traceback.from_exception(
+                exc_type=exec_values["exc_type"],
+                exc_value=exec_values["exc_value"],
+                traceback=exec_values["exc_traceback"],
+                show_locals=True,
+                width=100,
+            )
+        return Traceback(show_locals=True, width=100)
+
+    def _reset_buffer(self) -> None:
+        """Reset the console buffer."""
+        self.console_buffer.truncate(0)
+        self.console_buffer.seek(0)
+
+    def exit(self) -> None:
+        """Exit the console logger.
+
+        This method is called when the program exits to clean up resources.
+        """
+        self.console_buffer.close()

bear_utils/logger_manager/loggers/base_logger.pyi

@@ -0,0 +1,51 @@
+from io import StringIO
+from typing import Any, Self
+
+from rich.console import Console
+from rich.text import Text
+from rich.theme import Theme
+from rich.traceback import Traceback
+from singleton_base import SingletonBase
+
+from bear_utils.logger_manager._common import ExecValues, StackLevelTracker
+
+from .sub_logger import SubConsoleLogger
+
+class BaseLogger(SingletonBase):
+    output_handler: Any
+    stack_tracker: StackLevelTracker
+    theme: Theme
+    _level: int
+    style_disabled: bool
+    console: Console
+    console_buffer: StringIO
+    logger_mode: bool
+    sub_logger: dict[str, SubConsoleLogger]
+    # fmt: off
+    def __init__(self, output_handler: Any  = None, theme: Theme | None = ..., style_disabled: bool = ..., logger_mode: bool = ..., **kwargs) -> None: ...
+    @staticmethod
+    def get_console(theme: Theme, style_disabled: bool) -> Console: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(self, exc_type: object, exc_value: object, traceback: object) -> None: ...
+    def _generate_style_methods(self, **kwargs) -> None: ...
+    def get_sub_logger(self, namespace: str, **kwargs: Any) -> SubConsoleLogger: ...
+    def replacement_method(self, msg: object, *args: Any, **kwargs: Any) -> None: ...
+    def print(self, msg: object, end: str="\n", exc_info:str|None=None, extra: dict | None = None, *args, **kwargs) -> None | str: ...
+    def print_json(self, data: Any | None = ..., indent: int = ..., sort: bool = ...) -> None: ...
+    def set_base_level(self, level: int) -> None: ...
+    def filter_by_level(self, level: int) -> bool: ...
+    def trigger_buffer_flush(self) -> str | Text: ...
+    def _print(self, msg: object, end: str, json: bool = ..., *args: Any, **kwargs: Any) -> None: ...
+    def _get_exception(self, manual: bool = ..., exec_values: ExecValues | None = ...) -> Traceback: ...
+    def _extract_exception_values(self, exc_info: str | None) -> ExecValues | None: ...
+    def _reset_buffer(self) -> None: ...
+    def exit(self) -> None: ...
+    def debug(self, msg: object, *args: Any, **kwargs: Any) -> None: ...
+    def info(self, msg: object, *args: Any, **kwargs: Any) -> None: ...
+    def exception(self, msg: object, *args: Any, **kwargs: Any) -> None: ...
+    def warning(self, msg: object, *args: Any, **kwargs: Any) -> None: ...
+    def error(self, msg: object, *args: Any, **kwargs: Any) -> None: ...
+    def critical(self, msg: object, *args: Any, **kwargs: Any) -> None: ...
+    def success(self, msg: object, *args: Any, **kwargs: Any) -> None: ...
+    def failure(self, msg: object, *args: Any, **kwargs: Any) -> None: ...
+    def verbose(self, msg: object, *args: Any, **kwargs: Any) -> None: ...

bear_utils/logger_manager/loggers/basic_logger/__init__.py

@@ -0,0 +1,5 @@
+"""A basic logger to have around just in case the user doesn't already have one."""
+
+from .logger import BasicLogger
+
+__all__ = ["BasicLogger"]

bear_utils/logger_manager/loggers/basic_logger/logger.py

@@ -0,0 +1,80 @@
+"""Basic logger using the Rich library."""
+
+from collections.abc import Callable
+
+from rich import inspect
+from rich.console import Console
+from rich.theme import Theme
+
+THEME: dict[str, str] = {
+    "info": "dim green",
+    "debug": "bold blue",
+    "warning": "bold yellow",
+    "error": "bold red",
+    "exception": "bold red",
+    "success": "bold green",
+    "failure": "bold red underline",
+    "verbose": "bold blue",
+}
+
+
+class BasicLogger:
+    """A basic logger that uses the Rich library to print messages to the console."""
+
+    def __init__(self) -> None:
+        """Initialize the BasicLogger with a Rich Console instance."""
+        self.console = Console(theme=Theme(THEME))
+        for level in THEME:
+            method = self.replacement_method(level)
+            setattr(self, level, method)
+
+    def replacement_method(self, level: str) -> Callable:
+        """Create a method that logs messages at the specified level."""
+
+        def method(msg: object, **kwargs) -> None:
+            """Log a message at the specified level with the given style.
+
+            Args:
+                msg (object): The message to log.
+                **kwargs: Additional keyword arguments for formatting.
+            """
+            self.log(level, msg, **kwargs)
+
+        return method
+
+    def log(self, level: str, msg: object, **kwargs) -> None:
+        """Log a message at the specified level.
+
+        Args:
+            level (str): The logging level (e.g., 'info', 'debug', 'warning', etc.).
+            msg (object): The message to log.
+            **kwargs: Additional keyword arguments for formatting.
+        """
+        self.console.print(msg, style=level, **kwargs)
+
+    def print(self, msg: object, **kwargs) -> None:
+        """Print a message to the console with the specified style.
+
+        Args:
+            msg (object): The message to print.
+            **kwargs: Additional keyword arguments for formatting.
+        """
+        self.console.print(msg, **kwargs)
+
+    def inspect(self, obj: object, **kwargs) -> None:
+        """Inspect an object and print its details to the console.
+
+        Args:
+            obj (object): The object to inspect.
+            **kwargs: Additional keyword arguments for formatting.
+        """
+        inspect(obj, console=self.console, **kwargs)
+
+    def print_json(self, data: object, **kwargs) -> None:
+        """Print a JSON object to the console.
+
+        Args:
+            data (object): The JSON data to print.
+            **kwargs: Additional keyword arguments for formatting.
+        """
+        self.console.print_json(data=data, **kwargs)

bear_utils/logger_manager/loggers/basic_logger/logger.pyi

@@ -0,0 +1,19 @@
+from collections.abc import Callable
+
+from rich.console import Console
+
+class BasicLogger:
+    def __init__(self, console: Console | None = None) -> None: ...
+    def info(self, msg: object, **kwargs) -> None: ...
+    def debug(self, msg: object, **kwargs) -> None: ...
+    def warning(self, msg: object, **kwargs) -> None: ...
+    def error(self, msg: object, **kwargs) -> None: ...
+    def exception(self, msg: object, **kwargs) -> None: ...
+    def success(self, msg: object, **kwargs) -> None: ...
+    def failure(self, msg: object, **kwargs) -> None: ...
+    def verbose(self, msg: object, **kwargs) -> None: ...
+    def print(self, msg: object, style: str | None = None, **kwargs) -> None: ...
+    def log(self, level: str, msg: object, **kwargs) -> None: ...
+    def inspect(self, obj: object, **kwargs) -> None: ...
+    def print_json(self, data: object, **kwargs) -> None: ...
+    def replacement_method(self, level: str) -> Callable: ...

bear_utils/logger_manager/loggers/buffer_logger.py

@@ -0,0 +1,57 @@
+"""BufferLogger: A buffer-based logger that writes styled log messages to a buffer for later retrieval."""
+
+from logging import DEBUG
+from typing import Any, override
+
+from rich.theme import Theme
+
+from .console_logger import ConsoleLogger
+from .sub_logger import SubConsoleLogger
+
+
+class BufferLogger(ConsoleLogger):
+    """A buffer-based logger that writes styled log messages to a buffer.
+
+    Combines Python's logging framework with Rich console styling, but outputs
+    to a buffer instead of console or file. Supports buffering of log messages,
+
+    Features:
+    - Buffering of log messages
+    - Rich-style method generation (info, error, debug, etc.)
+    - Consistent print() interface
+    - Exception tracebacks in buffer format
+
+    Example:
+        logger = BufferLogger.get_instance(
+            init=True,
+            name="BufferLogger",
+        )
+        logger.info("This goes to the buffer")
+        logger.error("This error is logged to buffer")
+    """
+
+    def __init__(
+        self,
+        theme: Theme | None = None,
+        name: str = "BufferLogger",
+        level: int = DEBUG,
+        *_,
+        **kwargs,
+    ) -> None:
+        """Initialize the BufferLogger with buffering settings."""
+        ConsoleLogger.__init__(
+            self,
+            name=name,
+            level=level,
+            file=False,
+            console=False,
+            buffering=True,
+            queue_handler=kwargs.pop("queue_handler", False),
+            theme=theme,
+            logger_mode=True,
+            **kwargs,
+        )
+
+    @override
+    def get_sub_logger(self, namespace: str, **kwargs: Any) -> SubConsoleLogger:
+        return SubConsoleLogger(self, namespace, **kwargs)