bear-utils 0.0.1__py3-none-any.whl

bear_utils/logger_manager/loggers/file_logger.py

@@ -0,0 +1,151 @@
+"""A file-based logger that writes log messages to files, styling is disabled as it is not applicable for file output."""
+
+from logging import DEBUG
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, override
+
+from rich.theme import Theme
+
+from bear_utils.logger_manager._common import FIVE_MEGABYTES
+
+from .console_logger import ConsoleLogger
+from .sub_logger import SubConsoleLogger
+
+if TYPE_CHECKING:
+    from bear_utils.logger_manager._styles import LoggerExtraInfo
+
+
+class FileLogger(ConsoleLogger):
+    """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,
+    and maintains the same interface as other loggers.
+
+    Features:
+    - File logging with rotation
+    - Rich-style method generation (info, error, debug, etc.)
+    - Consistent print() interface
+    - Exception tracebacks in file format
+    - JSON logging support
+
+    Example:
+        logger = FileLogger.get_instance(
+            init=True,
+            name="FileLogger",
+            file_path="app.log",
+            max_bytes=10*1024*1024,
+            backup_count=5
+        )
+        logger.info("This goes to the file")
+        logger.error("This error is logged to file")
+    """
+
+    def __init__(
+        self,
+        theme: Theme | None = None,
+        name: str = "FileLogger",
+        level: int = DEBUG,
+        file_path: str = "app.log",
+        max_bytes: int = FIVE_MEGABYTES,
+        backup_count: int = 5,
+        *_,
+        **kwargs,
+    ) -> None:
+        """Initialize the FileLogger with file path and rotation settings."""
+        self.file_path = Path(file_path)  # TODO: Add more options for filename patterns (timestamps, process IDs, etc.)
+        self.max_bytes = max_bytes
+        self.backup_count = backup_count
+        ConsoleLogger.__init__(
+            self,
+            name=name,
+            level=level,
+            file=True,
+            console=False,
+            queue_handler=kwargs.pop("queue_handler", False),
+            file_path=self.file_path,
+            max_bytes=self.max_bytes,
+            backup_count=self.backup_count,
+            theme=theme,
+            style_disabled=True,
+            logger_mode=True,
+            **kwargs,
+        )
+
+    @override
+    def get_sub_logger(self, namespace: str, **kwargs: Any) -> SubConsoleLogger:
+        return SubConsoleLogger(self, namespace, **kwargs)
+
+    @override
+    def replacement_method(self, msg: object, *args, **kwargs) -> None:
+        """Handle logging method calls with proper file logging integration."""
+        extra: LoggerExtraInfo = kwargs.pop("injected_extra")
+        if kwargs.get("extra"):
+            extra.update(kwargs.pop("extra"))
+        if extra.get("namespace"):
+            msg = f"<{extra.get('namespace')}> {msg}"
+        if self.stack_tracker.not_set:
+            self.stack_tracker.record_start()
+
+        self.log(
+            extra.get("log_level", DEBUG),
+            msg,
+            extra,
+            *args,
+            **kwargs,
+        )
+
+    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.
+        """
+        try:
+            # For file logging, we want to use the logging system rather than direct file writing
+            # This ensures proper formatting, rotation, etc.
+            if exc_info is not None:
+                # Log with exception info
+                self.error(f"{msg}", exc_info=exc_info, extra=extra)
+            else:
+                # Regular info log
+                self.info(f"{msg}", extra=extra)
+
+            if extra:
+                # Log extra data as JSON-like format
+                self.info(f"Extra data: {extra}")
+        except Exception as e:
+            print(f"FileLogger: Failed to write to log file. Message: {msg}, Error: {e}")
+
+    def get_file_size(self) -> int:
+        """Get current size of the log file in bytes."""
+        if self.file_path.exists():
+            return self.file_path.stat().st_size
+        return 0
+
+    def get_file_path(self) -> Path:
+        """Get the current log file path."""
+        return self.file_path
+
+    def rotate_file(self) -> None:
+        """Manually trigger file rotation."""
+        if hasattr(self.file_handler, "doRollover"):
+            self.file_handler.doRollover()
+
+    @override
+    def exit(self) -> None:
+        """Clean up file resources."""
+        if hasattr(self, "file_handler"):
+            self.file_handler.flush()
+            self.file_handler.close()
+            self.removeHandler(self.file_handler)
+
+        # Call parent exit
+        super().exit()

bear_utils/logger_manager/loggers/simple_logger.py

@@ -0,0 +1,98 @@
+"""Simple logger implementation with log levels and timestamped output."""
+
+from io import StringIO
+from typing import TextIO
+
+from bear_utils.constants import STDERR, STDOUT, NullFile
+from bear_utils.logger_manager._log_level import LogLevel
+from bear_utils.time import EpochTimestamp
+
+VERBOSE: LogLevel = LogLevel.VERBOSE
+DEBUG: LogLevel = LogLevel.DEBUG
+INFO: LogLevel = LogLevel.INFO
+WARNING: LogLevel = LogLevel.WARNING
+ERROR: LogLevel = LogLevel.ERROR
+SUCCESS: LogLevel = LogLevel.SUCCESS
+FAILURE: LogLevel = LogLevel.FAILURE
+
+
+class SimpleLogger[T: TextIO]:
+    """A simple logger that writes messages to stdout, stderr, or StringIO with a timestamp."""
+
+    def __init__(self, level: str | int | LogLevel = "DEBUG", file: T = STDERR) -> None:
+        """Initialize the logger with a minimum log level and output file."""
+        self.level: LogLevel = LogLevel.get(level, default=DEBUG)
+        self.file: T = file  # Can be STDOUT, STDERR, StringIO, NullFile or other TextIO Objects
+        self.buffer: list[str] = []
+
+    def print(self, msg: object, end: str = "\n") -> None:
+        """Print the message to the specified file with an optional end character."""
+        print(msg, end=end, file=self.file)
+
+    def _log(self, level: LogLevel, msg: object, end: str = "\n", *args, **kwargs) -> None:
+        timestamp: str = EpochTimestamp.now().to_string()
+        try:
+            self.buffer.append(f"[{timestamp}] {level.value}: {msg}")
+            if args:
+                self.buffer.append(" ".join(str(arg) for arg in args))
+            if kwargs:
+                for key, value in kwargs.items():
+                    self.buffer.append(f"{key}={value}")
+            self.print(f"{end}".join(self.buffer))
+        except Exception as e:
+            self.print(f"[{timestamp}] {level.value}: {msg} - Error: {e}")
+        finally:
+            self.buffer.clear()
+
+    def log(self, level: LogLevel, msg: object, *args, **kwargs) -> None:
+        """Log a message at the specified level."""
+        if level.value >= self.level.value:
+            self._log(level, msg, *args, **kwargs)
+
+    def verbose(self, msg: object, *args, **kwargs) -> None:
+        """Alias for debug level logging."""
+        self.log(VERBOSE, msg, *args, **kwargs)
+
+    def debug(self, msg: object, *args, **kwargs) -> None:
+        """Log a debug message."""
+        self.log(DEBUG, msg, *args, **kwargs)
+
+    def info(self, msg: object, *args, **kwargs) -> None:
+        """Log an info message."""
+        self.log(INFO, msg, *args, **kwargs)
+
+    def warning(self, msg: object, *args, **kwargs) -> None:
+        """Log a warning message."""
+        self.log(WARNING, msg, *args, **kwargs)
+
+    def error(self, msg: object, *args, **kwargs) -> None:
+        """Log an error message."""
+        self.log(ERROR, 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)
+
+
+__all__ = [
+    "STDERR",
+    "STDOUT",
+    "LogLevel",
+    "NullFile",
+    "SimpleLogger",
+]
+
+# Example usage:
+if __name__ == "__main__":
+    logger = SimpleLogger(file=StringIO())
+    logger_two = SimpleLogger(level="INFO", file=NullFile())
+    logger.info(msg="This is an info message")
+    logger_two.info(msg="This is an info message")
+
+    value = logger.file
+    print(value.getvalue())  # Print the captured log messages from StringIO
+    # print(logger_two.file.getvalue())  # should throw a typing error since it is not a StringIO

bear_utils/logger_manager/loggers/sub_logger.py

@@ -0,0 +1,105 @@
+"""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 functools import partial
+from typing import TYPE_CHECKING, Any, Generic, TypeVar
+
+from rich.text import Text
+
+from bear_utils.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")
+
+
+class SubConsoleLogger(Generic[_T]):  # noqa: UP046
+    """SubConsoleLogger: A logger that wraps another logger with a namespace."""
+
+    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") or logger._level
+        self.logger_mode = logger.logger_mode
+        self.namespace: str = namespace
+        self._setup(self.namespace)
+
+    def print(
+        self,
+        msg: object,
+        end: str = "\n",
+        exc_info: Any = 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.
+        """
+        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.
+
+        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.
+
+        This method checks if the provided level is greater than or equal to the logger's level.
+
+        Args:
+            level (int | str): 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 trigger_buffer_flush(self) -> str | Text:
+        """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.
+        """
+        return self.logger.trigger_buffer_flush()
+
+    def _setup(self, name: str) -> None:
+        """Get an attribute from the logger.
+
+        This allows for accessing logger methods directly.
+        """
+        filter_func = self.filter_by_level
+        for style_name, og_extra in LOGGER_METHODS.items():
+            extra: LoggerExtraInfo = og_extra.copy()
+
+            extra["namespace"] = name
+
+            setattr(
+                self,
+                style_name,
+                partial(
+                    self.logger.replacement_method,
+                    injected_extra=extra,
+                    filter_func=filter_func,
+                ),
+            )
+
+    def __repr__(self) -> str:
+        """String representation of the adapter."""
+        return f"ConsoleAdapter(namespace={self.namespace}"

bear_utils/logger_manager/loggers/sub_logger.pyi

@@ -0,0 +1,23 @@
+from typing import Any, Generic, TypeVar
+
+from .base_logger import BaseLogger
+
+_T = TypeVar("_T", bound=BaseLogger)
+
+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 set_sub_level(self, level: int) -> None: ...
+    def success(self, msg: object, *args, **kwargs) -> None: ...
+    def failure(self, msg: object, *args, **kwargs) -> None: ...
+    def verbose(self, msg: object, *args, **kwargs) -> None: ...
+    def info(self, msg: object, *args, **kwargs) -> None: ...
+    def debug(self, msg: object, *args, **kwargs) -> None: ...
+    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: ...

bear_utils/monitoring/__init__.py

@@ -0,0 +1,13 @@
+"""A module for monitoring host system metrics."""
+
+from ._common import CPU, DISK, GPU, MEM, TaskChoice
+from .host_monitor import HostMonitor
+
+__all__ = [
+    "CPU",
+    "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)