bear-utils 0.0.1__py3-none-any.whl

bear_utils/logger_manager/_console_junk.py

@@ -0,0 +1,135 @@
+from collections.abc import Callable
+from io import StringIO
+from logging import Formatter, Handler, LogRecord
+from logging.handlers import BufferingHandler
+import threading
+from typing import Any
+
+from prompt_toolkit import print_formatted_text
+from prompt_toolkit.output.defaults import create_output
+from rich.text import Text
+
+from bear_utils.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: Callable, buffer_output: Callable):
+        super().__init__()
+        self.print_func: Callable = print_func
+        self.buffer_func: Callable = buffer_output
+
+    def emit(self, record: LogRecord, return_str: bool = False) -> Any:
+        """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 = bool(exec_values)
+        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 | None = None,
+        return_auto: bool = False,
+    ):
+        super().__init__(capacity=capacity)
+        # should come with a formatter before getting here
+        self.console_handler: ConsoleHandler = console_handler or ConsoleHandler(
+            print_func=lambda **kwargs: None, buffer_output=lambda **kwargs: ""
+        )
+        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) -> None:
+        """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/logger_manager/_log_level.py

@@ -0,0 +1,50 @@
+from typing import Literal
+
+from bear_utils.constants._meta import IntValue as Value, RichIntEnum
+
+FAILURE: Literal[45] = 45
+ERROR: Literal[40] = 40
+WARNING: Literal[30] = 30
+WARN: Literal[30] = WARNING
+INFO: Literal[20] = 20
+SUCCESS: Literal[15] = 15
+DEBUG: Literal[10] = 10
+VERBOSE: Literal[5] = 5
+NOTSET: Literal[0] = 0
+
+
+class LogLevel(RichIntEnum):
+    """Enumeration for logging levels."""
+
+    NOTSET = Value(NOTSET, "NOTSET", default=NOTSET)
+    VERBOSE = Value(VERBOSE, "VERBOSE", default=VERBOSE)
+    DEBUG = Value(DEBUG, "DEBUG", default=DEBUG)
+    INFO = Value(INFO, "INFO", default=INFO)
+    WARNING = Value(WARNING, "WARNING", default=WARNING)
+    ERROR = Value(ERROR, "ERROR", default=ERROR)
+    FAILURE = Value(FAILURE, "FAILURE", default=FAILURE)
+    SUCCESS = Value(SUCCESS, "SUCCESS", default=SUCCESS)
+
+
+level_to_name = {
+    FAILURE: "FAILURE",
+    ERROR: "ERROR",
+    WARNING: "WARNING",
+    INFO: "INFO",
+    SUCCESS: "SUCCESS",
+    DEBUG: "DEBUG",
+    VERBOSE: "VERBOSE",
+    NOTSET: "NOTSET",
+}
+
+name_to_level = {
+    "FAILURE": FAILURE,
+    "ERROR": ERROR,
+    "WARN": WARNING,
+    "WARNING": WARNING,
+    "INFO": INFO,
+    "SUCCESS": SUCCESS,
+    "DEBUG": DEBUG,
+    "VERBOSE": VERBOSE,
+    "NOTSET": NOTSET,
+}

bear_utils/logger_manager/_styles.py

@@ -0,0 +1,95 @@
+from typing import NotRequired, Required, TypedDict
+
+from rich.theme import Theme
+
+from bear_utils.logger_manager._log_level import (
+    DEBUG,
+    ERROR,
+    FAILURE,
+    INFO,
+    SUCCESS,
+    VERBOSE,
+    WARNING,
+)
+
+
+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"] 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/logger_manager/logger_protocol.py

@@ -0,0 +1,42 @@
+# ruff: noqa: D102
+"""A protocol for logging classes for general use."""
+
+from typing import Protocol, runtime_checkable
+
+
+@runtime_checkable
+class LoggerProtocol(Protocol):
+    """A protocol for logging classes with extra methods."""
+
+    def debug(self, msg: object, *args, **kwargs) -> None: ...
+
+    def info(self, msg: object, *args, **kwargs) -> None: ...
+
+    def warning(self, msg: object, *args, **kwargs) -> None: ...
+
+    def error(self, msg: object, *args, **kwargs) -> None: ...
+
+    def verbose(self, msg: object, *args, **kwargs) -> None: ...
+
+    def success(self, msg: object, *args, **kwargs) -> None: ...
+
+    def failure(self, msg: object, *args, **kwargs) -> None: ...
+
+
+@runtime_checkable
+class AsyncLoggerProtocol(Protocol):
+    """A protocol for asynchronous logging classes."""
+
+    async def debug(self, msg: object, *args, **kwargs) -> None: ...
+
+    async def info(self, msg: object, *args, **kwargs) -> None: ...
+
+    async def warning(self, msg: object, *args, **kwargs) -> None: ...
+
+    async def error(self, msg: object, *args, **kwargs) -> None: ...
+
+    async def verbose(self, msg: object, *args, **kwargs) -> None: ...
+
+    async def success(self, msg: object, *args, **kwargs) -> None: ...
+
+    async def failure(self, msg: object, *args, **kwargs) -> None: ...

bear_utils/logger_manager/loggers/__init__.py

@@ -0,0 +1 @@
+"""A module with all of the loggers used in the logger manager."""

bear_utils/logger_manager/loggers/_console.py

@@ -0,0 +1,223 @@
+from collections.abc import Callable, Mapping
+from datetime import datetime
+import sys
+import threading
+from time import monotonic
+from typing import TYPE_CHECKING, Literal, TextIO, cast
+
+from rich._log_render import FormatTimeCallable, LogRender
+from rich._null_file import NULL_FILE
+from rich.console import COLOR_SYSTEMS, Console, ConsoleThreadLocals, RenderHook, _is_jupyter, detect_legacy_windows
+from rich.emoji import EmojiVariant
+from rich.highlighter import NullHighlighter, ReprHighlighter
+from rich.style import StyleType
+from rich.text import Text
+from rich.theme import Theme, ThemeStack
+from rich.themes import DEFAULT
+
+from bear_utils.logger_manager._log_level import LogLevel
+
+if TYPE_CHECKING:
+    from rich.color import ColorSystem
+    from rich.live import Live
+    from rich.segment import Segment
+
+HighlighterType = Callable[[str, Text], Text] | Text
+JUPYTER_DEFAULT_COLUMNS = 115
+JUPYTER_DEFAULT_LINES = 100
+WINDOWS = sys.platform == "win32"
+
+_null_highlighter = NullHighlighter()
+
+
+class LogConsole[T: TextIO](Console):
+    """A Console from Rich that has added methods named after the logger methods."""
+
+    def __init__(
+        self,
+        *,
+        color_system: Literal["auto", "standard", "256", "truecolor", "windows"] | None = "auto",
+        force_terminal: bool | None = None,
+        force_jupyter: bool | None = None,
+        force_interactive: bool | None = None,
+        soft_wrap: bool = False,
+        theme: Theme | None = None,
+        stderr: bool = False,
+        file: T | None = None,
+        quiet: bool = False,
+        width: int | None = None,
+        height: int | None = None,
+        style: StyleType | None = None,
+        no_color: bool | None = None,
+        tab_size: int = 8,
+        record: bool = False,
+        markup: bool = True,
+        emoji: bool = True,
+        emoji_variant: EmojiVariant | None = None,
+        highlight: bool = True,
+        log_time: bool = True,
+        log_path: bool = True,
+        log_time_format: str | FormatTimeCallable = "[%X]",
+        highlighter: HighlighterType | None = ReprHighlighter(),  # type: ignore[assignment] # noqa: B008
+        legacy_windows: bool | None = None,
+        safe_box: bool = True,
+        get_datetime: Callable[[], datetime] | None = None,
+        get_time: Callable[[], float] | None = None,
+        _environ: Mapping[str, str] | None = None,
+        level: str | int | LogLevel = LogLevel.INFO,
+    ):
+        # Copy of os.environ allows us to replace it for testing
+        if _environ is not None:
+            self._environ = _environ
+
+        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
+        if self.is_jupyter:
+            if width is None:
+                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
+                if jupyter_columns is not None and jupyter_columns.isdigit():
+                    width = int(jupyter_columns)
+                else:
+                    width = JUPYTER_DEFAULT_COLUMNS
+            if height is None:
+                jupyter_lines = self._environ.get("JUPYTER_LINES")
+                if jupyter_lines is not None and jupyter_lines.isdigit():
+                    height = int(jupyter_lines)
+                else:
+                    height = JUPYTER_DEFAULT_LINES
+
+        self.tab_size = tab_size
+        self.record = record
+        self._markup = markup
+        self._emoji = emoji
+        self._emoji_variant: EmojiVariant | None = emoji_variant
+        self._highlight = highlight
+        self.legacy_windows: bool = (
+            (detect_legacy_windows() and not self.is_jupyter) if legacy_windows is None else legacy_windows
+        )
+
+        if width is None:
+            columns = self._environ.get("COLUMNS")
+            if columns is not None and columns.isdigit():
+                width = int(columns) - self.legacy_windows
+        if height is None:
+            lines = self._environ.get("LINES")
+            if lines is not None and lines.isdigit():
+                height = int(lines)
+
+        self.soft_wrap = soft_wrap
+        self._width = width
+        self._height = height
+
+        self._color_system: ColorSystem | None
+
+        self._force_terminal = None
+        if force_terminal is not None:
+            self._force_terminal = force_terminal
+
+        self._file: T | None = file
+        self.quiet = quiet
+        self.stderr = stderr
+
+        if color_system is None:
+            self._color_system = None
+        elif color_system == "auto":
+            self._color_system = self._detect_color_system()
+        else:
+            self._color_system = COLOR_SYSTEMS[color_system]
+
+        self._lock = threading.RLock()
+        self._log_render = LogRender(
+            show_time=log_time,
+            show_path=log_path,
+            time_format=log_time_format,
+        )
+        self.highlighter: HighlighterType = highlighter or _null_highlighter  # type: ignore[assignment]
+        self.safe_box = safe_box
+        self.get_datetime = get_datetime or datetime.now
+        self.get_time = get_time or monotonic
+        self.style = style
+        self.no_color = no_color if no_color is not None else self._environ.get("NO_COLOR", "") != ""
+        self.is_interactive = (
+            (self.is_terminal and not self.is_dumb_terminal) if force_interactive is None else force_interactive
+        )
+
+        self._record_buffer_lock = threading.RLock()
+        self._thread_locals = ConsoleThreadLocals(theme_stack=ThemeStack(DEFAULT if theme is None else theme))
+        self._record_buffer: list[Segment] = []
+        self._render_hooks: list[RenderHook] = []
+        self._live: Live | None = None
+        self._is_alt_screen = False
+        self.level: LogLevel = LogLevel.get(level, default=LogLevel.INFO)
+
+    @property
+    def file(self) -> T:
+        """Get the file object to write to."""
+        file = self._file or (sys.stderr if self.stderr else sys.stdout)
+        file = getattr(file, "rich_proxied_file", file)
+        if file is None:
+            file = NULL_FILE
+        return cast("T", file)
+
+    @file.setter
+    def file(self, new_file: T) -> None:  # type: ignore[override]
+        """Set a new file object."""
+        self._file = new_file
+
+    def _log(self, level: LogLevel, msg: object, *args, **kwargs) -> None:
+        """Log a message at the specified level.
+
+        Args:
+            level (LogLevel): The log level for the message. We aren't using this parameter in the current implementation,
+            msg (object): The message to log.
+            *args: Additional positional arguments.
+            **kwargs: Additional keyword arguments.
+        """
+        if level.value >= self.level.value:
+            """Log a message at the specified level."""
+            with self._lock:
+                if not self.quiet:
+                    self.log(msg, *args, **kwargs)
+
+    def info(self, msg: object, *args, **kwargs) -> None:
+        """Log an informational message to the console."""
+        self._log(LogLevel.INFO, msg, *args, **kwargs)
+
+    def warning(self, msg: object, *args, **kwargs) -> None:
+        """Log a warning message to the console."""
+        self._log(LogLevel.WARNING, msg, *args, **kwargs)
+
+    def error(self, msg: object, *args, **kwargs) -> None:
+        """Log an error message to the console."""
+        self._log(LogLevel.ERROR, msg, *args, **kwargs)
+
+    def debug(self, msg: object, *args, **kwargs) -> None:
+        """Log a debug message to the console."""
+        self._log(LogLevel.DEBUG, msg, *args, **kwargs)
+
+    def verbose(self, msg: object, *args, **kwargs) -> None:
+        """Log a verbose message to the console."""
+        self._log(LogLevel.VERBOSE, msg, *args, **kwargs)
+
+    def success(self, msg: object, *args, **kwargs) -> None:
+        """Log a success message to the console."""
+        self._log(LogLevel.SUCCESS, msg, *args, **kwargs)
+
+    def failure(self, msg: object, *args, **kwargs) -> None:
+        """Log a failure message to the console."""
+        self._log(LogLevel.FAILURE, msg, *args, **kwargs)
+
+    def exception(self, msg: object, *args, **kwargs) -> None:
+        """Log an exception message to the console."""
+        self._log(LogLevel.ERROR, msg, *args, **kwargs)
+
+
+if __name__ == "__main__":
+    from io import StringIO
+
+    console = LogConsole(file=StringIO())
+
+    console.info("This is an info message")
+
+    value = console.file
+
+    print(value.getvalue())  # Print the captured log messages from StringIO

bear_utils/logger_manager/loggers/_level_sin.py

@@ -0,0 +1,61 @@
+"""This is some terrible sinning that should not exist, don't look at it. It doesn't exist if you don't look at it."""
+
+from logging import addLevelName
+import threading
+from typing import Literal
+
+ERROR: Literal[40] = 40
+WARNING: Literal[30] = 30
+WARN: Literal[30] = WARNING
+INFO: Literal[20] = 20
+DEBUG: Literal[10] = 10
+NOTSET: Literal[0] = 0
+
+level_to_name = {
+    ERROR: "ERROR",
+    WARNING: "WARNING",
+    INFO: "INFO",
+    DEBUG: "DEBUG",
+    NOTSET: "NOTSET",
+}
+
+name_to_level = {
+    "ERROR": ERROR,
+    "WARN": WARNING,
+    "WARNING": WARNING,
+    "INFO": INFO,
+    "DEBUG": DEBUG,
+    "NOTSET": NOTSET,
+}
+
+_lock = threading.RLock()
+
+
+def lvl_exists(level: int | str) -> bool:
+    """Check if a logging level already exists."""
+    with _lock:
+        level = check_level(level, fail=False)
+        return level in level_to_name
+
+
+def add_level_name(level: int, name: str) -> None:
+    """Add a custom logging level name."""
+    with _lock:
+        if level in level_to_name:
+            raise ValueError(f"Level {level} already exists with name {level_to_name[level]}")
+        level_to_name[level] = name.upper()
+        name_to_level[name.upper()] = level
+        addLevelName(level=level, levelName=name)
+
+
+def check_level(level: int | str | None, fail: bool = True) -> int:
+    """Validate and normalize logging level to integer."""
+    if isinstance(level, str) and level.upper() in name_to_level:
+        return name_to_level[level.upper()]
+    if isinstance(level, int) and level in level_to_name:
+        return level
+    if fail:
+        if not isinstance(level, (int | str)):
+            raise TypeError(f"Level must be int or str, got {type(level).__name__}: {level!r}")
+        raise ValueError(f"Invalid logging level: {level!r}. Valid levels are: {list(name_to_level.keys())}")
+    return 999  # Return a high value to indicate invalid level

bear_utils/logger_manager/loggers/_logger.py

@@ -0,0 +1,19 @@
+from logging import Logger
+
+from bear_utils.logger_manager._log_level import FAILURE, SUCCESS, VERBOSE
+
+
+class LoggerExtra(Logger):
+    """A custom logger that just includes a few extra methods."""
+
+    def verbose(self, msg: object, *args, **kwargs) -> None:
+        """Log a verbose message."""
+        self.log(VERBOSE, msg, *args, **kwargs)
+
+    def success(self, msg: object, *args, **kwargs) -> None:
+        """Log a success message."""
+        self.log(SUCCESS, msg, *args, **kwargs)
+
+    def failure(self, msg: object, *args, **kwargs) -> None:
+        """Log a failure message."""
+        self.log(FAILURE, msg, *args, **kwargs)