bear-utils 0.8.26__py3-none-any.whl → 0.9.0__py3-none-any.whl

bear_utils/logger_manager/__init__.py

@@ -3,12 +3,14 @@
 from typing import Any
 
 from bear_utils.logger_manager._common import VERBOSE_CONSOLE_FORMAT
-from bear_utils.logger_manager._styles import VERBOSE
+from bear_utils.logger_manager._log_level import DEBUG, ERROR, FAILURE, INFO, SUCCESS, VERBOSE, WARNING, LogLevel
+from bear_utils.logger_manager._styles import DEFAULT_THEME
 from bear_utils.logger_manager.logger_protocol import AsyncLoggerProtocol, LoggerProtocol
+from bear_utils.logger_manager.loggers._console import LogConsole
 from bear_utils.logger_manager.loggers.base_logger import BaseLogger
 from bear_utils.logger_manager.loggers.buffer_logger import BufferLogger
 from bear_utils.logger_manager.loggers.console_logger import ConsoleLogger
-from bear_utils.logger_manager.loggers.fastapi_logger import ServerLogger
+from bear_utils.logger_manager.loggers.fastapi_logger import LoggingClient, LoggingServer
 from bear_utils.logger_manager.loggers.file_logger import FileLogger
 from bear_utils.logger_manager.loggers.simple_logger import SimpleLogger
 from bear_utils.logger_manager.loggers.sub_logger import SubConsoleLogger
@@ -80,15 +82,25 @@ def get_sub_logger(
 
 
 __all__ = [
+    "DEBUG",
+    "DEFAULT_THEME",
+    "ERROR",
+    "FAILURE",
+    "INFO",
+    "SUCCESS",
     "VERBOSE",
     "VERBOSE_CONSOLE_FORMAT",
+    "WARNING",
     "AsyncLoggerProtocol",
     "BaseLogger",
     "BufferLogger",
     "ConsoleLogger",
     "FileLogger",
+    "LogConsole",
+    "LogLevel",
     "LoggerProtocol",
-    "ServerLogger",
+    "LoggingClient",
+    "LoggingServer",
     "SimpleLogger",
     "SubConsoleLogger",
     "get_console",

bear_utils/logger_manager/_log_level.py

@@ -1,9 +1,6 @@
-from functools import cached_property
-from typing import Any, Literal, overload
+from typing import Literal
 
-from pydantic import BaseModel, Field, field_validator
-
-from bear_utils.extras.wrappers.add_methods import add_comparison_methods
+from bear_utils.constants._meta import RichIntEnum, Value
 
 FAILURE: Literal[45] = 45
 ERROR: Literal[40] = 40
@@ -40,87 +37,14 @@ name_to_level = {
 }
 
 
-@add_comparison_methods("value")
-class LogLevel(BaseModel):
-    """Model to represent a logging level."""
-
-    name: str = Field(default="NOTSET", description="Name of the logging level")
-    value: int = Field(default=NOTSET, description="Numeric value of the logging level")
-
-    @field_validator("value")
-    @classmethod
-    def validate_value(cls, value: int) -> int:
-        if value not in level_to_name:
-            raise ValueError(f"Invalid logging level value: {value!r}. Valid values are: {list(level_to_name.keys())}")
-        return value
-
-    @field_validator("name")
-    @classmethod
-    def validate_name(cls, name: str) -> str:
-        if name not in name_to_level:
-            raise ValueError(f"Invalid logging level name: {name!r}. Valid names are: {list(name_to_level.keys())}")
-        return name
-
-
-class LogLevels(BaseModel):
-    """Model to represent a collection of logging levels."""
-
-    notset: LogLevel = Field(default=LogLevel(name="NOTSET", value=NOTSET))
-    verbose: LogLevel = Field(default=LogLevel(name="VERBOSE", value=VERBOSE))
-    debug: LogLevel = Field(default=LogLevel(name="DEBUG", value=DEBUG))
-    info: LogLevel = Field(default=LogLevel(name="INFO", value=INFO))
-    success: LogLevel = Field(default=LogLevel(name="SUCCESS", value=SUCCESS))
-    warning: LogLevel = Field(default=LogLevel(name="WARNING", value=WARNING))
-    error: LogLevel = Field(default=LogLevel(name="ERROR", value=ERROR))
-    failure: LogLevel = Field(default=LogLevel(name="FAILURE", value=FAILURE))
-
-    model_config = {"arbitrary_types_allowed": True, "extra": "forbid"}
-
-    @cached_property
-    def keys(self) -> list[str]:
-        """Get the names of all logging levels."""
-        return [key.upper() for key in LogLevels.model_fields]
-
-    @cached_property
-    def levels(self):  # noqa: ANN202
-        item_dict: dict[str, Any] = {
-            level_name.lower(): getattr(self, level_name.lower()).value for level_name in self.keys
-        }
-        return item_dict.items()
-
-    def get_int(self, name: str) -> int:
-        """Get the integer value of a logging level by name."""
-        if not hasattr(self, name):
-            raise ValueError(f"Invalid logging level name: {name!r}. Valid names are: {self.keys}")
-        return getattr(self, name).value
-
-    @overload
-    def get(self, v: LogLevel) -> LogLevel: ...
-
-    @overload
-    def get(self, v: str) -> LogLevel: ...
-
-    @overload
-    def get(self, v: int) -> LogLevel: ...
-
-    def get(self, v: int | str | LogLevel) -> LogLevel:
-        """Get a logging level by name or value."""
-        if isinstance(v, LogLevel):
-            return v
-        if isinstance(v, str) and v.lower() in self.keys:
-            return getattr(self, v.lower())
-        if isinstance(v, int):
-            for level_name, level_value in self.levels:
-                if level_value == v:
-                    return getattr(self, level_name.lower())
-        return self.notset  # Default to NOTSET if no match found
-
-    def get_name(self, value: int) -> str:
-        """Get the name of a logging level by its integer value."""
-        for level_name, level_value in self.levels:
-            if level_value == value:
-                return level_name
-        raise ValueError(f"Invalid logging level value: {value!r}. Valid values are: {self.keys}")
-
+class LogLevel(RichIntEnum):
+    """Enumeration for logging levels."""
 
-log_levels = LogLevels()
+    NOTSET = Value(NOTSET, "NOTSET")
+    VERBOSE = Value(VERBOSE, "VERBOSE")
+    DEBUG = Value(DEBUG, "DEBUG")
+    INFO = Value(INFO, "INFO")
+    WARNING = Value(WARNING, "WARNING")
+    ERROR = Value(ERROR, "ERROR")
+    FAILURE = Value(FAILURE, "FAILURE")
+    SUCCESS = Value(SUCCESS, "SUCCESS")

bear_utils/logger_manager/logger_protocol.py

@@ -1,3 +1,4 @@
+# ruff: noqa: D102
 """A protocol for logging classes for general use."""
 
 from typing import Protocol, runtime_checkable
@@ -5,41 +6,37 @@ from typing import Protocol, runtime_checkable
 
 @runtime_checkable
 class LoggerProtocol(Protocol):
-    """A protocol for logging classes."""
+    """A protocol for logging classes with extra methods."""
 
-    def debug(self, msg: object, *args, **kwargs) -> None:
-        """Log a debug message."""
-        ...
+    def debug(self, msg: object, *args, **kwargs) -> None: ...
 
-    def info(self, msg: object, *args, **kwargs) -> None:
-        """Log an info message."""
-        ...
+    def info(self, msg: object, *args, **kwargs) -> None: ...
 
-    def warning(self, msg: object, *args, **kwargs) -> None:
-        """Log a warning message."""
-        ...
+    def warning(self, msg: object, *args, **kwargs) -> None: ...
 
-    def error(self, msg: object, *args, **kwargs) -> None:
-        """Log an error message."""
-        ...
+    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:
-        """Log a debug message asynchronously."""
-        ...
+    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 info(self, msg: object, *args, **kwargs) -> None:
-        """Log an info message asynchronously."""
-        ...
+    async def verbose(self, msg: object, *args, **kwargs) -> None: ...
 
-    async def warning(self, msg: object, *args, **kwargs) -> None:
-        """Log a warning message asynchronously."""
-        ...
+    async def success(self, msg: object, *args, **kwargs) -> None: ...
 
-    async def error(self, msg: object, *args, **kwargs) -> None:
-        """Log an error message asynchronously."""
-        ...
+    async def failure(self, msg: object, *args, **kwargs) -> None: ...

bear_utils/logger_manager/loggers/_console.py

@@ -0,0 +1,204 @@
+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
+
+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,
+    ):
+        # 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
+
+    @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 info(self, msg: object, *args, **kwargs) -> None:
+        """Log an informational message to the console."""
+        self.log(msg, *args, **kwargs)
+
+    def warning(self, msg: object, *args, **kwargs) -> None:
+        """Log a warning message to the console."""
+        self.log(msg, *args, **kwargs)
+
+    def error(self, msg: object, *args, **kwargs) -> None:
+        """Log an error message to the console."""
+        self.log(msg, *args, **kwargs)
+
+    def debug(self, msg: object, *args, **kwargs) -> None:
+        """Log a debug message to the console."""
+        self.log(msg, *args, **kwargs)
+
+    def verbose(self, msg: object, *args, **kwargs) -> None:
+        """Log a verbose message to the console."""
+        self.log(msg, *args, **kwargs)
+
+    def success(self, msg: object, *args, **kwargs) -> None:
+        """Log a success message to the console."""
+        self.log(msg, *args, **kwargs)
+
+    def failure(self, msg: object, *args, **kwargs) -> None:
+        """Log a failure message to the console."""
+        self.log(msg, *args, **kwargs)
+
+    def exception(self, msg: object, *args, **kwargs) -> None:
+        """Log an exception message to the console."""
+        self.log(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/_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)

bear_utils/logger_manager/loggers/base_logger.py

@@ -7,7 +7,6 @@ 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.console import Console
 from rich.text import Text
 from rich.theme import Theme
 from rich.traceback import Traceback
@@ -15,6 +14,7 @@ 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
@@ -43,23 +43,23 @@ class BaseLogger(SingletonBase):
         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[assignment]
-        self.backup_console = Console(theme=self.theme, highlight=True, force_terminal=True)
+        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) -> Console:
+    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 = Console(
+            console = LogConsole(
                 file=StringIO(),
                 highlight=False,
                 force_terminal=True,
                 style=None,  # Disable styling
             )
         else:
-            console: Console = Console(
+            console: LogConsole = LogConsole(
                 file=StringIO(),
                 highlight=False,
                 force_terminal=True,