bear-utils 0.7.11__py3-none-any.whl

bear_utils/logging/logger_manager/_console_junk.py

@@ -0,0 +1,131 @@
+import threading
+from collections.abc import Callable
+from io import StringIO
+from logging import Formatter, Handler, LogRecord
+from logging.handlers import BufferingHandler
+
+from prompt_toolkit import print_formatted_text
+from prompt_toolkit.output.defaults import create_output
+from rich.text import Text
+
+from ...constants.date_related import DATE_TIME_FORMAT
+from ._common import SIMPLE_FORMAT, VERBOSE_CONSOLE_FORMAT, ExecValues
+from ._styles import LoggerExtraInfo
+
+
+def get_extra(record: LogRecord) -> LoggerExtraInfo:
+    """Get extra information from the log record."""
+    extra: LoggerExtraInfo = {
+        "style_name": record.__dict__.get("style_name", ""),
+        "style": record.__dict__.get("style", ""),
+        "log_level": record.__dict__.get("log_level", ""),
+        "log_level_style": record.__dict__.get("log_level_style", ""),
+        "namespace": record.__dict__.get("namespace", ""),
+    }
+    return extra
+
+
+def extract_exec_info(record: LogRecord) -> dict[str, ExecValues] | None:
+    """Extract execution info from the log record."""
+    exec_values: dict[str, ExecValues] | None = record.__dict__.get("exec_values", {})
+    if exec_values is not None:
+        return exec_values
+    return None
+
+
+class ConsoleHandler(Handler):
+    def __init__(self, print_func, buffer_output):
+        super().__init__()
+        self.print_func: Callable = print_func
+        self.buffer_func: Callable = buffer_output
+
+    def emit(self, record: LogRecord, return_str: bool = False):
+        """
+        Emit a log record either to console or return as string.
+
+        Args:
+            record: The LogRecord to emit
+            return_str: If True, return formatted string instead of printing
+
+        Returns:
+            str if return_str=True, None otherwise
+        """
+        formatted_msg: str = self.format(record)
+        extra: LoggerExtraInfo = get_extra(record)
+        exec_values: dict[str, ExecValues] | None = extract_exec_info(record)
+        exc_info: bool = True if exec_values is not None else False
+        style_name = extra.get("style_name", "")
+
+        print_kwargs = {
+            "msg": formatted_msg,
+            "style": style_name,
+            "exc_info": exc_info if exc_info is not None else False,
+            "exec_values": exec_values,
+            "return_str": return_str,
+        }
+        if return_str:
+            return self.buffer_func(**print_kwargs)
+
+        return self.print_func(**print_kwargs)
+
+
+class ConsoleFormatter(Formatter):
+    def __init__(self, fmt: str = SIMPLE_FORMAT, datefmt: str = DATE_TIME_FORMAT):
+        super().__init__(fmt=fmt, datefmt=datefmt)
+        self.log_format: str = fmt
+
+    def format(self, record: LogRecord) -> str:
+        extra: LoggerExtraInfo = get_extra(record)
+        if self.log_format == VERBOSE_CONSOLE_FORMAT:
+            log_level_color: str = extra["log_level_style"]
+            style_name: str = extra.get("style_name", "")
+            dynamic_format = self.log_format.format(
+                log_level_color,
+                style_name.upper(),
+                log_level_color,
+            )
+            temp_formatter = Formatter(fmt=dynamic_format, datefmt=self.datefmt)
+            return temp_formatter.format(record)
+
+        if self.log_format == SIMPLE_FORMAT:
+            record.msg = f"{record.msg}"
+
+        return super().format(record)
+
+
+class ConsoleBuffering(BufferingHandler):
+    def __init__(
+        self,
+        capacity: int = 9999,
+        console_handler=ConsoleHandler(print_func=lambda **kwargs: None, buffer_output=lambda **kwargs: ""),
+        return_auto: bool = False,
+    ):
+        super().__init__(capacity=capacity)
+        self.console_handler: ConsoleHandler = console_handler  # should come with a formatter before getting here
+        self._lock = threading.RLock()
+        self.flush_auto = return_auto
+
+    def flush_to_output(self) -> Text:
+        """Flush all buffered records to the console handler."""
+        with self._lock:
+            output_buffer = StringIO()
+            output = create_output(stdout=output_buffer)
+            for record in self.buffer:
+                formatted_msg = self.console_handler.emit(record, return_str=True)
+                print_formatted_text(formatted_msg, output=output, end="\n")
+        output = output_buffer.getvalue()
+        output_buffer.close()
+        self.buffer.clear()
+        return Text.from_ansi(output)
+
+    def trigger_flush(self):
+        """Immediately flush all buffered records to console."""
+        self.flush()
+
+    def flush(self) -> None:
+        """Flush all buffered records to the console handler."""
+        if self.flush_auto:
+            with self._lock:
+                for record in self.buffer:
+                    self.console_handler.emit(record)
+                self.buffer.clear()

bear_utils/logging/logger_manager/_styles.py

@@ -0,0 +1,91 @@
+from logging import DEBUG, ERROR, INFO, WARNING
+from typing import Literal, NotRequired, Required, TypedDict
+
+from rich.theme import Theme
+
+VERBOSE: Literal[5] = 5
+SUCCESS: Literal[15] = 15
+FAILURE: Literal[45] = 45
+
+
+class LoggerExtraInfo(TypedDict):
+    """Type definition for extra info that can be added to log records."""
+
+    style_name: Required[str]
+    style: Required[str]
+    namespace: NotRequired[str]
+    log_level: Required[int]
+    log_level_style: Required[str]
+
+
+LOGGER_METHODS: dict[str, LoggerExtraInfo] = {
+    "info": {
+        "style_name": "info",
+        "style": "dim green",
+        "log_level": INFO,
+        "log_level_style": "black on white",
+    },
+    "debug": {
+        "style_name": "debug",
+        "style": "bold blue",
+        "log_level": DEBUG,
+        "log_level_style": "black on blue",
+    },
+    "warning": {
+        "style_name": "warning",
+        "style": "bold yellow",
+        "log_level": WARNING,
+        "log_level_style": "yellow on black",
+    },
+    "error": {
+        "style_name": "error",
+        "style": "bold red",
+        "log_level": ERROR,
+        "log_level_style": "bold white on red",
+    },
+    "exception": {
+        "style_name": "exception",
+        "style": "bold red",
+        "log_level": ERROR,
+        "log_level_style": "bold white on red",
+    },
+    "success": {
+        "style_name": "success",
+        "style": "bold green",
+        "log_level": SUCCESS,
+        "log_level_style": "black on bright_green",
+    },
+    "failure": {
+        "style_name": "failure",
+        "style": "bold red underline",
+        "log_level": FAILURE,
+        "log_level_style": "bold red on white",
+    },
+    "verbose": {
+        "style_name": "verbose",
+        "style": "bold blue",
+        "log_level": VERBOSE,
+        "log_level_style": "black on bright_blue",
+    },
+}
+
+
+def get_method(name: str) -> LoggerExtraInfo:
+    """
+    Get the name info from the logger methods.
+
+    Args:
+        name (str): The name of the logger method.
+
+    Returns:
+        LoggerExtraInfo | dict: The info of the logger method or an empty dict if not found.
+    """
+    if not LOGGER_METHODS.get(name):
+        raise ValueError(f"Logger method '{name}' does not exist. Available methods: {list(LOGGER_METHODS.keys())}")
+    return LOGGER_METHODS[name]
+
+
+DEFAULT_STYLES: dict[str, str] = {**{method: info["style"].upper() for method, info in LOGGER_METHODS.items()}}
+"""Just the styles of the logger methods, used to create the theme."""
+
+DEFAULT_THEME = Theme(styles=DEFAULT_STYLES)

bear_utils/logging/logger_manager/loggers/_base_logger.py

@@ -0,0 +1,238 @@
+import sys
+from functools import partial
+from io import StringIO
+from typing import Self
+
+from prompt_toolkit.formatted_text import ANSI, FormattedText, to_formatted_text
+from prompt_toolkit.shortcuts import print_formatted_text
+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 .._common import ExecValues, StackLevelTracker
+from .._styles import DEFAULT_THEME, LOGGER_METHODS, LoggerExtraInfo
+from ._level_sin import INFO, add_level_name, check_level, lvl_exists
+from ._sub_logger import SubConsoleLogger
+
+
+class BaseLogger(SingletonBase):
+    def __init__(
+        self,
+        output_handler=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: Console = self.get_console(self.theme, style_disabled)
+        self.console_buffer: StringIO = self.console.file  # type: ignore
+        self.backup_console = Console(theme=self.theme, highlight=True, force_terminal=True)
+        self._generate_style_methods()
+
+    @staticmethod
+    def get_console(theme: Theme, style_disabled: bool) -> Console:
+        if style_disabled:
+            console = Console(
+                file=StringIO(),
+                highlight=False,
+                force_terminal=True,
+                style=None,  # Disable styling
+            )
+        else:
+            console: Console = Console(
+                file=StringIO(),
+                highlight=False,
+                force_terminal=True,
+                color_system="truecolor",
+                theme=theme,
+            )
+        return console
+
+    def _default_output(self, msg: object, extra: 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, exc_value, traceback) -> 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:
+        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":
+        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=None,
+        extra: dict | None = None,
+        *args,
+        **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,
+    ):
+        """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", *args, **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 "\n".
+        """
+        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(data=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) -> 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/logging/logger_manager/loggers/_base_logger.pyi

@@ -0,0 +1,50 @@
+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 .._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 = 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: Any, exc_value: Any, traceback: Any) -> 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=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) -> 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/logging/logger_manager/loggers/_buffer_logger.py

@@ -0,0 +1,55 @@
+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,
+        *args,
+        **kwargs,
+    ) -> None:
+        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)