bear-utils 0.7.21__py3-none-any.whl → 0.7.22__py3-none-any.whl

bear_utils/logging/logger_manager/loggers/_console_logger.py

@@ -1,27 +1,29 @@
 # region Imports
+from contextlib import suppress
 from functools import cached_property
 from logging import DEBUG, Formatter, Handler, Logger
 from logging.handlers import QueueHandler, QueueListener, RotatingFileHandler
 from queue import Queue
-from typing import override
+from typing import TYPE_CHECKING, override
 
 from prompt_toolkit import PromptSession
 from rich.text import Text
 from rich.theme import Theme
-from rich.traceback import Traceback
 
 from bear_utils.constants.date_related import DATE_TIME_FORMAT
+from bear_utils.logging.logger_manager._common import FIVE_MEGABYTES, VERBOSE_CONSOLE_FORMAT, VERBOSE_FORMAT, ExecValues
+from bear_utils.logging.logger_manager._console_junk import ConsoleBuffering, ConsoleFormatter, ConsoleHandler
 
-from .._common import FIVE_MEGABYTES, VERBOSE_CONSOLE_FORMAT, VERBOSE_FORMAT, ExecValues
-from .._console_junk import ConsoleBuffering, ConsoleFormatter, ConsoleHandler
 from ._base_logger import BaseLogger
 
+if TYPE_CHECKING:
+    from rich.traceback import Traceback
+
 # endregion Imports
 
 
 class ConsoleLogger(Logger, BaseLogger):
-    """
-    A comprehensive console logger that combines Python's logging framework with Rich console styling.
+    """A comprehensive console logger that combines Python's logging framework with Rich console styling.
 
     This logger provides styled console output with configurable file logging, queue handling,
     buffering, and interactive input capabilities. It dynamically creates logging methods
@@ -53,7 +55,7 @@ class ConsoleLogger(Logger, BaseLogger):
         file: bool = False,
         queue_handler: bool = False,
         buffering: bool = False,
-        *args,
+        *_,
         **kwargs,
     ) -> None:
         Logger.__init__(self, name=name, level=level)
@@ -82,7 +84,14 @@ class ConsoleLogger(Logger, BaseLogger):
                 **kwargs,
             )
 
-    def _handle_enable_booleans(self, file, console, buffering, queue_handler, **kwargs) -> None:
+    def _handle_enable_booleans(
+        self,
+        file: bool,
+        console: bool,
+        buffering: bool,
+        queue_handler: bool,
+        **kwargs,
+    ) -> None:
         """Configure logging handlers based on initialization parameters."""
         if console or buffering:
             self.console_handler: ConsoleHandler = ConsoleHandler(self.print, self.output_buffer)
@@ -138,16 +147,16 @@ class ConsoleLogger(Logger, BaseLogger):
         if hasattr(self, "queue_handler"):
             self.queue_handler.setLevel(level)
 
-    def _console_output(self, msg: object, extra, *args, **kwargs) -> None:
+    def _console_output(self, msg: object, extra: dict, *args, **kwargs) -> None:
         """Console-specific output handler that integrates with logging module."""
         if not self.logger_mode:
             self.print(msg, *args, **kwargs)
         else:
             kwargs.pop("style", None)
             self.log(
-                level=extra.get("log_level", DEBUG),
-                msg=msg,
-                extra=extra,
+                extra.get("log_level", DEBUG),
+                msg,
+                extra,
                 *args,
                 **kwargs,
             )
@@ -156,7 +165,7 @@ class ConsoleLogger(Logger, BaseLogger):
 
     # region Utility Methods
 
-    async def input(self, msg: str, style="info", **kwargs) -> str:
+    async def input(self, msg: str, style: str = "info", **kwargs) -> str:
         """Display a styled prompt and return user input asynchronously."""
         if not self.session:
             self.session = PromptSession(**kwargs)
@@ -164,7 +173,13 @@ class ConsoleLogger(Logger, BaseLogger):
         return await self.session.prompt_async()
 
     def output_buffer(
-        self, msg: object, end="\n", exc_info=None, exec_values: ExecValues | None = None, *args, **kwargs
+        self,
+        msg: object,
+        end: str = "\n",
+        exc_info: str | None = None,
+        exec_values: ExecValues | None = None,
+        *_,
+        **kwargs,
     ) -> str:
         """Capture console output to a string buffer without printing to terminal."""
         if exc_info and exec_values:
@@ -179,20 +194,25 @@ class ConsoleLogger(Logger, BaseLogger):
 
     # region Enhanced Print Methods
 
-    def print(self, msg: object, end="\n", exc_info=None, extra: dict | None = None, *args, **kwargs) -> None | str:
-        """
-        Print styled messages with enhanced exception handling and JSON support.
+    def print(
+        self,
+        msg: object,
+        end: str = "\n",
+        exc_info: str | None = None,
+        extra: dict | None = None,
+        *args,
+        **kwargs,
+    ) -> None | str:
+        """Print styled messages with enhanced exception handling and JSON support.
 
         Extends the base print method with proper exception tracebacks and
         integrated JSON printing for structured data output.
         """
         if exc_info is not None:
-            try:
+            with suppress(ValueError):
                 self._print(self._get_exception(), end=end, width=100, show_locals=True, **kwargs)
-            except ValueError:
-                ...
 
-        self._print(msg, end=end, *args, **kwargs)
+        self._print(msg, end, *args, **kwargs)
 
         if extra:
             self._print(msg=extra, end=end, json=True, indent=4)
@@ -203,9 +223,17 @@ class ConsoleLogger(Logger, BaseLogger):
         return self.stack_tracker.record_end()
 
     @override
-    def _log(self, level, msg, args, exc_info=None, extra=None, stack_info=False, stacklevel=None):
-        """
-        Custom logging implementation with enhanced exception handling.
+    def _log(  # type: ignore[override]
+        self,
+        level: int,
+        msg: object,
+        args: tuple,
+        exc_info: str | None = None,
+        extra: dict | None = None,
+        stack_info: bool = False,
+        stacklevel: int | None = None,
+    ) -> None:
+        """Custom logging implementation with enhanced exception handling.
 
         Overrides the standard logging._log method to provide better exception
         value extraction for Rich traceback integration while respecting log levels.
@@ -219,8 +247,8 @@ class ConsoleLogger(Logger, BaseLogger):
         final_extra = extra or {}
 
         if exc_info is not None:
-            exec_values = self._extract_exception_values(exc_info)
-            if exec_values:
+            exec_values: ExecValues | None = self._extract_exception_values(exc_info)
+            if exec_values is not None:
                 final_extra = {**final_extra, "exec_values": exec_values}
 
         record = self.makeRecord(

bear_utils/logging/logger_manager/loggers/_console_logger.pyi

@@ -1,16 +1,16 @@
-from logging import DEBUG, Logger
+from logging import Logger
 from logging.handlers import QueueHandler, RotatingFileHandler
 from typing import Any
 
 from rich.text import Text
 from rich.theme import Theme
 
-from .._console_junk import ConsoleBuffering, ConsoleHandler
+from bear_utils.logging.logger_manager._console_junk import ConsoleBuffering, ConsoleHandler
+
 from ._base_logger import BaseLogger
 from ._sub_logger import SubConsoleLogger
 
 class ConsoleLogger(Logger, BaseLogger):
-
     name: str
     level: int
     file: bool
@@ -18,13 +18,13 @@ class ConsoleLogger(Logger, BaseLogger):
     buffer_handler: ConsoleBuffering
     console_handler: ConsoleHandler
     file_handler: RotatingFileHandler
-    sub_logger: dict[str, "SubConsoleLogger[ConsoleLogger]"]
+    sub_logger: dict[str, SubConsoleLogger[ConsoleLogger]]
 
     def __init__(
         self,
         theme: Theme | None = None,
         name: str = "ConsoleLogger",
-        level: int = DEBUG,
+        level: int = ...,
         disabled: bool = True,
         queue_handler: bool = False,
         buffering: bool = False,
@@ -34,21 +34,7 @@ class ConsoleLogger(Logger, BaseLogger):
         logger_mode: bool = True,
         *args,
         **kwargs,
-    ) -> None:
-        """
-        A general purpose console logger that that by default is a wrapper around both Rich and Python's logging module.
-
-        Args:
-            theme (Theme | None): The theme for the logger.
-            name (str): The name of the logger.
-            level (int): The logging level.
-            disabled (bool): Whether the logger is disabled.
-            queue_handler (bool): Whether to use a queue handler.
-            buffering (bool): Whether to use buffering.
-            file (bool): Whether to log to a file.
-            style_disabled (bool): Whether to disable styling.
-            logger_mode (bool): Whether to enable logger mode.
-        """
+    ) -> None: ...
     # fmt: off
     def debug(self, msg: object, *args, **kwargs: Any) -> None: ...
     def info(self, msg: object, *args, **kwargs: Any) -> None: ...
@@ -60,5 +46,5 @@ class ConsoleLogger(Logger, BaseLogger):
     def set_base_level(self, level: int) -> None: ...
     def input(self, msg: str, style: str = "info") -> str: ...
     def trigger_buffer_flush(self) -> str | Text: ...
-    def print(self, msg: object, end: str="\n", exc_info=None, extra: dict | None = None, *args, **kwargs) -> None | str: ...
+    def print(self, msg: object, end: str="\n", exc_info:str|None=None, extra: dict | None = None, *args, **kwargs) -> None | str: ...
     def exit(self) -> None: ...

bear_utils/logging/logger_manager/loggers/_file_logger.py

@@ -1,20 +1,20 @@
 from logging import DEBUG
 from pathlib import Path
-from typing import Any, override
+from typing import TYPE_CHECKING, Any, override
 
 from rich.theme import Theme
 
-from bear_utils.constants.date_related import DATE_TIME_FORMAT
+from bear_utils.logging.logger_manager._common import FIVE_MEGABYTES
 
-from .._common import FIVE_MEGABYTES
-from .._styles import LoggerExtraInfo
 from ._console_logger import ConsoleLogger
 from ._sub_logger import SubConsoleLogger
 
+if TYPE_CHECKING:
+    from bear_utils.logging.logger_manager._styles import LoggerExtraInfo
+
 
 class FileLogger(ConsoleLogger):
-    """
-    A file-based logger that writes styled log messages to files.
+    """A file-based logger that writes styled log messages to files.
 
     Combines Python's logging framework with Rich console styling, but outputs
     to files instead of console. Supports file rotation, custom formatting,
@@ -47,7 +47,7 @@ class FileLogger(ConsoleLogger):
         file_path: str = "app.log",
         max_bytes: int = FIVE_MEGABYTES,
         backup_count: int = 5,
-        *args,
+        *_,
         **kwargs,
     ) -> None:
         self.file_path = Path(file_path)  # TODO: Add more options for filename patterns (timestamps, process IDs, etc.)
@@ -85,16 +85,23 @@ class FileLogger(ConsoleLogger):
             self.stack_tracker.record_start()
 
         self.log(
-            level=extra.get("log_level", DEBUG),
-            msg=msg,
-            extra=extra,
+            extra.get("log_level", DEBUG),
+            msg,
+            extra,
             *args,
             **kwargs,
         )
 
-    def print(self, msg: object, end: str = "\n", exc_info=None, extra: dict | None = None, *args, **kwargs) -> None:
-        """
-        Print a message to the file with proper formatting.
+    def print(
+        self,
+        msg: object,
+        _: str = "\n",
+        exc_info: str | None = None,
+        extra: dict | None = None,
+        *__,
+        **___,
+    ) -> None:
+        """Print a message to the file with proper formatting.
 
         Maintains the same interface as other loggers but writes to file instead of console.
         """

bear_utils/logging/logger_manager/loggers/_level_sin.py

@@ -1,5 +1,5 @@
-import threading
 from logging import addLevelName
+import threading
 from typing import Literal
 
 ERROR: Literal[40] = 40
@@ -9,14 +9,14 @@ INFO: Literal[20] = 20
 DEBUG: Literal[10] = 10
 NOTSET: Literal[0] = 0
 
-_levelToName = {
+level_to_name = {
     ERROR: "ERROR",
     WARNING: "WARNING",
     INFO: "INFO",
     DEBUG: "DEBUG",
     NOTSET: "NOTSET",
 }
-_nameToLevel = {
+name_to_level = {
     "ERROR": ERROR,
     "WARN": WARNING,
     "WARNING": WARNING,
@@ -32,27 +32,27 @@ 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 _levelToName
+        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 _levelToName:
-            raise ValueError(f"Level {level} already exists with name {_levelToName[level]}")
-        _levelToName[level] = name.upper()
-        _nameToLevel[name.upper()] = level
-        addLevelName(level, name)
+        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, fail: bool = True) -> int:
+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 _nameToLevel:
-        return _nameToLevel[level.upper()]
-    if isinstance(level, int) and level in _levelToName:
+    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)):
+        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(_nameToLevel.keys())}")
+        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/logging/logger_manager/loggers/_logger.py

@@ -4,15 +4,13 @@ from ._base_logger import BaseLogger
 
 
 class ExtraBaseLogger(Logger, BaseLogger):
-    """
-    Base logger class that extends the standard logging.Logger and BaseLogger.
+    """Base logger class that extends the standard logging.Logger and BaseLogger.
+
     This class is intended to be used as a base for custom loggers that require
     additional functionality or attributes.
     """
 
-    def __init__(self, name, level=0, **kwargs):
-        """
-        Initialize the ExtraBaseLogger with a name and level.
-        """
+    def __init__(self, name: str, level: int = 0, **kwargs):
+        """Initialize the ExtraBaseLogger with a name and level."""
         super().__init__(name, level)
         BaseLogger.__init__(self, **kwargs)

bear_utils/logging/logger_manager/loggers/_sub_logger.py

@@ -1,5 +1,4 @@
-"""
-Logger adapter module that provides an alternative to SubLogger using standard library tools.
+"""Logger adapter module that provides an alternative to SubLogger using standard library tools.
 
 This implementation shows how to use LoggerAdapter and contextvars to maintain
 all the functionality of the existing SubLogger while reducing complexity.
@@ -10,26 +9,26 @@ from typing import TYPE_CHECKING, Any, Generic, TypeVar
 
 from rich.text import Text
 
-from .._styles import LOGGER_METHODS, LoggerExtraInfo
+from bear_utils.logging.logger_manager._styles import LOGGER_METHODS, LoggerExtraInfo
+
 from ._level_sin import check_level
 
 if TYPE_CHECKING:
     from ._base_logger import BaseLogger
 
-T = TypeVar("T", bound="BaseLogger")
+_T = TypeVar("_T", bound="BaseLogger")
 
 
-class SubConsoleLogger(Generic[T]):
-    def __init__(self, logger: T, namespace: str, **kwargs) -> None:
-        """
-        Initialize the SubConsoleLogger with a logger and a namespace.
+class SubConsoleLogger(Generic[_T]):  # noqa: UP046
+    def __init__(self, logger: _T, namespace: str, **kwargs) -> None:
+        """Initialize the SubConsoleLogger with a logger and a namespace.
 
         Args:
             logger: The underlying logger to wrap with a namespace.
             namespace: The namespace to prefix log messages with
         """
-        self.logger: T = logger
-        self._level: int = kwargs.get("level", None) or logger._level
+        self.logger: _T = logger
+        self._level: int = kwargs.get("level") or logger._level
         self.logger_mode = logger.logger_mode
         self.namespace: str = namespace
         self._setup(self.namespace)
@@ -40,27 +39,24 @@ class SubConsoleLogger(Generic[T]):
         end: str = "\n",
         exc_info: Any = None,
         extra: dict | None = None,
-        *args,
+        *_,
         **kwargs,
     ) -> None | str:
-        """
-        Print a message to the console with the specified formatting.
+        """Print a message to the console with the specified formatting.
 
         This method allows for printing messages with additional context and formatting.
         """
         return self.logger.print(msg, end=end, exc_info=exc_info, extra=extra, **kwargs)
 
     def set_sub_level(self, level: int) -> None:
-        """
-        Set the logging level for the logger.
+        """Set the logging level for the logger.
 
         This method allows changing the logging level dynamically.
         """
         self._level = level
 
     def filter_by_level(self, level: int | str) -> bool:
-        """
-        Filter method to determine if a message should be logged based on its level.
+        """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.
 
@@ -71,12 +67,10 @@ class SubConsoleLogger(Generic[T]):
             bool: True if the message should be logged, False otherwise.
         """
         level = check_level(level)
-        bool_check = level >= self._level
-        return bool_check
+        return level >= self._level
 
     def trigger_buffer_flush(self) -> str | Text:
-        """
-        Flush buffered messages to console output.
+        """Flush buffered messages to console output.
 
         This method is used to ensure that any buffered log messages are printed
         to the console, similar to the SubLogger's buffer flush functionality.
@@ -84,8 +78,7 @@ class SubConsoleLogger(Generic[T]):
         return self.logger.trigger_buffer_flush()
 
     def _setup(self, name: str) -> None:
-        """
-        Get an attribute from the logger.
+        """Get an attribute from the logger.
 
         This allows for accessing logger methods directly.
         """

bear_utils/logging/logger_manager/loggers/_sub_logger.pyi

@@ -1,31 +1,17 @@
-"""
-Logger adapter module that provides an alternative to SubLogger using standard library tools.
-
-This implementation shows how to use LoggerAdapter and contextvars to maintain
-all the functionality of the existing SubLogger while reducing complexity.
-"""
-
 from typing import Any, Generic, TypeVar
 
 from ._base_logger import BaseLogger
 
-T = TypeVar("T", bound=BaseLogger)
-
-class SubConsoleLogger(Generic[T]):
-    """
-    Enhanced logger adapter that supports style-based logging and namespace prefixing.
-
-    This class provides an alternative to the SubLogger implementation while
-    maintaining compatibility with the existing ConsoleLogger.
-    """
+_T = TypeVar("_T", bound=BaseLogger)
 
-    logger: T
+class SubConsoleLogger(Generic[_T]):  # noqa: UP046
+    logger: _T
     _level: int
     namespace: str
     extra: dict[str, Any] | None
     log_level: int
     # fmt: off
-    def __init__(self, logger: T, namespace: str, **kwargs) -> None: ...
+    def __init__(self, logger: _T, namespace: str, **kwargs) -> None: ...
     def set_sub_level(self, level: int) -> None: ...
     def success(self, msg: object, *args, **kwargs) -> None: ...
     def failure(self, msg: object, *args, **kwargs) -> None: ...
@@ -35,4 +21,3 @@ class SubConsoleLogger(Generic[T]):
     def warning(self, msg: object, *args, **kwargs) -> None: ...
     def error(self, msg: object, *args, **kwargs) -> None: ...
     def print(self, msg: object, end: str = "\n", exc_info: Any = None, extra: dict | None = None, *args, **kwargs: Any) -> None | str: ...
-    def __repr__(self) -> str: ...

bear_utils/logging/loggers.py

@@ -1,7 +1,5 @@
-from ..constants.date_related import DATE_TIME_FORMAT
-from .logger_manager._common import FIVE_MEGABYTES, SIMPLE_FORMAT, VERBOSE_CONSOLE_FORMAT, VERBOSE_FORMAT, ExecValues
-from .logger_manager._console_junk import ConsoleBuffering, ConsoleFormatter, ConsoleHandler
-from .logger_manager._styles import DEFAULT_THEME, LOGGER_METHODS, VERBOSE, LoggerExtraInfo, get_method
+"""A module for logging utilities."""
+
 from .logger_manager.loggers._base_logger import BaseLogger
 from .logger_manager.loggers._buffer_logger import BufferLogger
 from .logger_manager.loggers._console_logger import ConsoleLogger
@@ -31,22 +29,21 @@ def get_logger(
         style_disabled (bool): Whether to disable styling.
         logger_mode (bool): Whether the logger is in logger mode.
         **kwargs: Additional keyword arguments for customization.
+
     Returns:
         BaseLogger | ConsoleLogger | BufferLogger| FileLogger: An instance of the appropriate logger.
     """
     if (not console and not file) and buffering:
         return BufferLogger(queue_handler=queue_handler, **kwargs)
-    elif (console and file) or (console and buffering):
+    if (console and file) or (console and buffering):
         return ConsoleLogger(queue_handler=queue_handler, buffering=buffering, **kwargs)
-    elif not console and not buffering and file:
+    if not console and not buffering and file:
         return FileLogger(queue_handler=queue_handler, **kwargs)
-    else:
-        return BaseLogger(**kwargs)
+    return BaseLogger(**kwargs)
 
 
 def get_console(namespace: str) -> tuple[BaseLogger, SubConsoleLogger]:
-    """
-    Get a console logger and a sub-logger for a specific namespace.
+    """Get a console logger and a sub-logger for a specific namespace.
 
     Args:
         namespace (str): The namespace for the sub-logger.
@@ -60,8 +57,7 @@ def get_console(namespace: str) -> tuple[BaseLogger, SubConsoleLogger]:
 
 
 def get_sub_logger(logger: BaseLogger | ConsoleLogger, namespace: str) -> SubConsoleLogger[BaseLogger | ConsoleLogger]:
-    """
-    Get a sub-logger for a specific namespace.
+    """Get a sub-logger for a specific namespace.
 
     Args:
         logger (BaseLogger): The parent logger.
@@ -70,7 +66,7 @@ def get_sub_logger(logger: BaseLogger | ConsoleLogger, namespace: str) -> SubCon
     Returns:
         SubConsoleLogger: A sub-logger instance.
     """
-    if not isinstance(logger, (BaseLogger, ConsoleLogger)):
+    if not isinstance(logger, (BaseLogger | ConsoleLogger)):
         raise TypeError("Expected logger to be an instance of BaseLogger or ConsoleLogger")
 
     return SubConsoleLogger(logger=logger, namespace=namespace)

bear_utils/monitoring/__init__.py

@@ -1,10 +1,13 @@
-from .host_monitor import CPU, DISK, GPU, MEM, HostMonitor, TaskChoice
+"""A module for monitoring host system metrics."""
+
+from ._common import CPU, DISK, GPU, MEM, TaskChoice
+from .host_monitor import HostMonitor
 
 __all__ = [
-    "TaskChoice",
-    "HostMonitor",
     "CPU",
-    "MEM",
     "DISK",
     "GPU",
+    "MEM",
+    "HostMonitor",
+    "TaskChoice",
 ]

bear_utils/monitoring/_common.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from enum import StrEnum
+from typing import Literal
+
+
+class TaskChoice(StrEnum):
+    """Enum for task choices."""
+
+    CPU = "cpu"
+    MEM = "mem"
+    DISK = "disk"
+    GPU = "gpu"
+
+
+CPU = TaskChoice.CPU
+MEM = TaskChoice.MEM
+DISK = TaskChoice.DISK
+GPU = TaskChoice.GPU
+
+CPU_MEM: tuple[Literal[TaskChoice.CPU], Literal[TaskChoice.MEM]] = (CPU, MEM)
+CPU_MEM_GPU: tuple[Literal[TaskChoice.CPU], Literal[TaskChoice.MEM], Literal[TaskChoice.GPU]] = (CPU, MEM, GPU)
+ALL_TASKS: tuple[
+    Literal[TaskChoice.CPU],
+    Literal[TaskChoice.MEM],
+    Literal[TaskChoice.DISK],
+    Literal[TaskChoice.GPU],
+] = (CPU, MEM, DISK, GPU)