bear-utils 0.0.1__py3-none-any.whl

bear_utils/logger_manager/loggers/console_logger.py

@@ -0,0 +1,278 @@
+"""ConsoleLogger: A comprehensive console logger that combines Python's logging framework with Rich console styling."""
+
+# 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 TYPE_CHECKING, override
+
+from prompt_toolkit import PromptSession
+from rich.text import Text
+from rich.theme import Theme
+
+from bear_utils.constants.date_related import DATE_TIME_FORMAT
+from bear_utils.logger_manager._common import FIVE_MEGABYTES, VERBOSE_CONSOLE_FORMAT, VERBOSE_FORMAT, ExecValues
+from bear_utils.logger_manager._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.
+
+    This logger provides styled console output with configurable file logging, queue handling,
+    buffering, and interactive input capabilities. It dynamically creates logging methods
+    (info, error, debug, etc.) that forward to Rich's styled console printing.
+
+    Features:
+    - Rich styled console output with themes
+    - Optional file logging with rotation
+    - Queue-based async logging
+    - Message buffering capabilities
+    - Interactive prompt integration
+    - Exception tracebacks with local variables
+
+    Example:
+        logger = ConsoleLogger.get_instance(init=True, verbose=True, name="MyLogger", level=DEBUG)
+        logger.info("This is styled info")
+        logger.error("This is styled error")
+        logger.success("This is styled success")
+    """
+
+    # region Setup
+    def __init__(
+        self,
+        theme: Theme | None = None,
+        name: str = "ConsoleLogger",
+        level: int = DEBUG,
+        disabled: bool = True,
+        console: bool = True,
+        file: bool = False,
+        queue_handler: bool = False,
+        buffering: bool = False,
+        *_,
+        **kwargs,
+    ) -> None:
+        """Initialize the ConsoleLogger with optional file, console, and buffering settings."""
+        Logger.__init__(self, name=name, level=level)
+        BaseLogger.__init__(
+            self,
+            output_handler=self._console_output,
+            theme=theme,
+            style_disabled=kwargs.get("style_disabled", False),
+            logger_mode=kwargs.get("logger_mode", True),
+            level=level,
+        )
+        self.name = name
+        self.level = level
+        self.setLevel(level)
+        self.session = None
+        self.disabled = disabled
+        self._handlers: list[Handler] = []
+        self.logger_mode: bool = kwargs.pop("logger_mode", True)
+        if self.logger_mode:
+            self.disabled = False
+            self._handle_enable_booleans(
+                file=file,
+                console=console,
+                buffering=buffering,
+                queue_handler=queue_handler,
+                **kwargs,
+            )
+
+    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)
+            self.console_handler.setFormatter(ConsoleFormatter(fmt=VERBOSE_CONSOLE_FORMAT, datefmt=DATE_TIME_FORMAT))
+            self.console_handler.setLevel(self.level)
+            if console:
+                self._handlers.append(self.console_handler)
+            if buffering:
+                self.buffer_handler: ConsoleBuffering = ConsoleBuffering(console_handler=self.console_handler)
+                self.addHandler(self.buffer_handler)
+        if file:
+            self.file_handler: RotatingFileHandler = RotatingFileHandler(
+                filename=kwargs.get("file_path", "console.log"),
+                maxBytes=kwargs.get("max_bytes", FIVE_MEGABYTES),
+                backupCount=kwargs.get("backup_count", 5),
+            )
+            self.file_handler.setFormatter(Formatter(fmt=VERBOSE_FORMAT, datefmt=DATE_TIME_FORMAT))
+            self.file_handler.setLevel(self.level)
+            self._handlers.append(self.file_handler)
+        if queue_handler:
+            self.queue = Queue()
+            self.queue_handler = QueueHandler(self.queue)
+            self.addHandler(self.queue_handler)
+            self.listener = QueueListener(self.queue, *self._handlers)
+            self.listener.start()
+        else:
+            for handler in self._handlers:
+                self.addHandler(handler)
+
+    def stop_queue_listener(self) -> None:
+        """Stop the queue listener if it exists and clean up resources."""
+        if hasattr(self, "listener"):
+            self.verbose("ConsoleLogger: QueueListener stopped and cleaned up.")
+            self.listener.stop()
+            del self.listener
+            del self.queue
+            del self.queue_handler
+
+    def trigger_buffer_flush(self) -> Text:
+        """Flush buffered messages to console output."""
+        if hasattr(self, "buffer_handler"):
+            return self.buffer_handler.flush_to_output()
+        return Text("No buffering handler available.", style="bold red")
+
+    def set_base_level(self, level: int) -> None:
+        """Set the base logging level for the console logger."""
+        super().set_base_level(level)
+        self.setLevel(level)
+        if hasattr(self, "console_handler"):
+            self.console_handler.setLevel(level)
+        if hasattr(self, "buffer_handler"):
+            self.buffer_handler.setLevel(level)
+        if hasattr(self, "queue_handler"):
+            self.queue_handler.setLevel(level)
+
+    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(
+                extra.get("log_level", DEBUG),
+                msg,
+                *args,
+                extra=extra,
+                **kwargs,
+            )
+
+    # endregion Setup
+
+    # region Utility Methods
+
+    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)
+        self.print(msg, style=style)
+        return await self.session.prompt_async()
+
+    def output_buffer(
+        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:
+            exception: Traceback = self._get_exception(manual=True, exec_values=exec_values)
+            self.console.print(exception, end=end)
+        self.console.print(msg, end="", style=kwargs.get("style", "info"))
+        output = self.console_buffer.getvalue()
+        self._reset_buffer()
+        return output
+
+    # endregion Utility Methods
+
+    # region Enhanced Print Methods
+
+    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:
+            with suppress(ValueError):
+                self._print(self._get_exception(), end=end, width=100, show_locals=True, **kwargs)
+
+        self._print(msg, end, *args, **kwargs)
+
+        if extra:
+            self._print(msg=extra, end=end, json=True, indent=4)
+
+    @cached_property
+    def stack_level(self) -> int:
+        """Cached property to retrieve the current stack level."""
+        return self.stack_tracker.record_end()
+
+    @override
+    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.
+        """
+        stacklevel = stacklevel or self.stack_level
+        try:
+            fn, lno, func, sinfo = self.findCaller(stack_info, stacklevel)
+        except ValueError:
+            fn, lno, func, sinfo = "(unknown file)", 0, "(unknown function)", None
+        final_extra = extra or {}
+        if exc_info is not None:
+            exec_values = self._extract_exception_values(exc_info)
+            if exec_values:
+                final_extra = {**final_extra, "exec_values": exec_values}
+
+        record = self.makeRecord(
+            name=self.name,
+            level=level,
+            fn=fn,
+            lno=lno,
+            msg=msg,
+            args=args,
+            exc_info=None,
+            func=func,
+            extra=final_extra,
+            sinfo=sinfo,
+        )
+
+        self.handle(record)
+
+    def exit(self) -> None:
+        """Clean up resources including queue listeners and console buffers."""
+        if hasattr(self, "queue_handler"):
+            self.queue_handler.flush()
+            self.stop_queue_listener()
+
+        self.console_buffer.close()
+
+    # endregion Enhanced Print Methods

bear_utils/logger_manager/loggers/console_logger.pyi

@@ -0,0 +1,50 @@
+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 bear_utils.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
+    queue_handler: QueueHandler
+    buffer_handler: ConsoleBuffering
+    console_handler: ConsoleHandler
+    file_handler: RotatingFileHandler
+    sub_logger: dict[str, SubConsoleLogger[ConsoleLogger]]
+
+    def __init__(
+        self,
+        theme: Theme | None = None,
+        name: str = "ConsoleLogger",
+        level: int = ...,
+        disabled: bool = True,
+        queue_handler: bool = False,
+        buffering: bool = False,
+        file: bool = False,
+        console: bool = True,
+        style_disabled: bool = False,
+        logger_mode: bool = True,
+        *args,
+        **kwargs,
+    ) -> None: ...
+    # fmt: off
+    def debug(self, msg: object, *args, **kwargs: Any) -> None: ...
+    def info(self, msg: object, *args, **kwargs: Any) -> None: ...
+    def warning(self, msg: object, *args, **kwargs: Any) -> None: ...
+    def error(self, msg: object, *args, **kwargs: Any) -> None: ...
+    def success(self, msg: object, *args, **kwargs: Any) -> None: ...
+    def failure(self, msg: object, *args, **kwargs: Any) -> None: ...
+    def verbose(self, msg: object, *args, **kwargs: Any) -> None: ...
+    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:str|None=None, extra: dict | None = None, *args, **kwargs) -> None | str: ...
+    def exit(self) -> None: ...

bear_utils/logger_manager/loggers/fastapi_logger.py

@@ -0,0 +1,333 @@
+"""FastAPI-based local logging server and HTTP logger."""
+
+import asyncio
+from collections import deque
+from pathlib import Path
+import threading
+from typing import TYPE_CHECKING, Any, Self, TextIO
+
+from fastapi import FastAPI
+from fastapi.responses import JSONResponse
+from httpx import AsyncClient
+from pydantic import BaseModel, Field, field_serializer
+from singleton_base import SingletonBase
+import uvicorn
+
+from bear_utils.constants import DEVNULL, ExitCode, HTTPStatusCode
+from bear_utils.logger_manager._log_level import LogLevel
+from bear_utils.time import EpochTimestamp
+
+if TYPE_CHECKING:
+    from httpx import Response
+
+
+VERBOSE: LogLevel = LogLevel.from_name("VERBOSE")
+DEBUG: LogLevel = LogLevel.from_name("DEBUG")
+INFO: LogLevel = LogLevel.from_name("INFO")
+WARNING: LogLevel = LogLevel.from_name("WARNING")
+ERROR: LogLevel = LogLevel.from_name("ERROR")
+FAILURE: LogLevel = LogLevel.from_name("FAILURE")
+SUCCESS: LogLevel = LogLevel.from_name("SUCCESS")
+
+
+class LogRequest(BaseModel):
+    """Request model for logging messages."""
+
+    level: LogLevel | int | str = Field(default=DEBUG, description="Log level of the message")
+    message: str = Field(default="", description="Log message content")
+    args: tuple = Field(default=(), description="Arguments for the log message")
+    kwargs: dict[str, str] = Field(default_factory=dict, description="Keyword arguments for the log message")
+
+    model_config = {
+        "arbitrary_types_allowed": True,
+    }
+
+    @field_serializer("level")
+    def serialize_level(self, value: LogLevel | int | str) -> int:
+        """Serialize the log level to an integer."""
+        return LogLevel.get(value, default=DEBUG).value
+
+
+class LoggingServer[T: TextIO](SingletonBase):
+    """A local server that writes logs to a file."""
+
+    def __init__(
+        self,
+        host: str = "localhost",
+        port: int = 8080,
+        log_file: str | Path = "server.log",
+        level: LogLevel | int | str = DEBUG,
+        file: T = DEVNULL,  # Default to DEVNULL to discard console output
+        maxlen: int = 100,
+    ) -> None:
+        """Initialize the logging server."""
+        self.host: str = host
+        self.port: int = port
+        self.log_file: Path = Path(log_file)
+        self.log_file.parent.mkdir(parents=True, exist_ok=True)
+        self.level: LogLevel = LogLevel.get(level, default=DEBUG)
+        self.app = FastAPI()
+        self.server_thread = None
+        self._running = False
+        self.logs: deque[LogRequest] = deque(maxlen=maxlen)
+        self.file: T = file
+        self._setup_routes()
+
+    @property
+    def running(self) -> bool:
+        """Check if the server is running."""
+        return self._running or (self.server_thread is not None and self.server_thread.is_alive())
+
+    def __len__(self) -> int:
+        """Get the number of logged messages."""
+        return len(self.logs)
+
+    def get_logs(self) -> list[LogRequest]:
+        """Get the list of logged messages."""
+        return list(self.logs)
+
+    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 response(
+        self,
+        status: str,
+        message: str = "",
+        status_code: HTTPStatusCode = HTTPStatusCode.SERVER_OK,
+    ) -> JSONResponse:
+        """Create a JSON response with the given content and status code."""
+        return JSONResponse(content={"status": status, "message": message}, status_code=status_code.value)
+
+    def _setup_routes(self) -> None:
+        """Set up the FastAPI routes for logging and health check."""
+
+        @self.app.post("/log")
+        async def log_message(request: LogRequest | Any) -> JSONResponse:
+            """Endpoint to log a message."""
+            request = LogRequest(
+                level=request["level"] if isinstance(request, dict) else request.level,
+                message=request["message"] if isinstance(request, dict) else request.message,
+                args=request["args"] if isinstance(request, dict) else request.args,
+                kwargs=request["kwargs"] if isinstance(request, dict) else request.kwargs,
+            )
+            level: LogLevel = LogLevel.get(request.level, default=DEBUG)
+            if level.value < self.level.value:
+                return self.response(status="ignored", message="Log level is lower than server's minimum level")
+            message = request.message
+            args = request.args
+            kwargs: dict[str, str] | Any = request.kwargs
+            success: ExitCode = self.write_log(level, message, *args, **kwargs)
+            self.logs.append(request)
+            if success != ExitCode.SUCCESS:
+                return self.response(
+                    status="error", message="Failed to write log", status_code=HTTPStatusCode.SERVER_ERROR
+                )
+            return self.response(status="success", status_code=HTTPStatusCode.SERVER_OK)
+
+        @self.app.get("/health")
+        async def health_check() -> JSONResponse:
+            return JSONResponse(
+                content={"status": "healthy"},
+                status_code=HTTPStatusCode.SERVER_OK,
+            )
+
+    def write_log(
+        self,
+        level: LogLevel,
+        message: str,
+        end: str = "\n",
+        *args,
+        **kwargs,
+    ) -> ExitCode:
+        """Write a log entry to the file - same logic as original logger."""
+        timestamp: str = EpochTimestamp.now().to_string()
+        log_entry: str = f"[{timestamp}] {level}: {message}"
+        buffer = []
+        try:
+            buffer.append(log_entry)
+            if args:
+                buffer.append(f"{end}".join(str(arg) for arg in args))
+            if kwargs:
+                for key, value in kwargs.items():
+                    buffer.append(f"{key}={value}{end}")
+            if kwargs.pop("console", False):
+                self.print(f"{end}".join(buffer))
+            with open(self.log_file, "a", encoding="utf-8") as f:
+                for line in buffer:
+                    f.write(f"{line}{end}")
+            return ExitCode.SUCCESS
+        except Exception:
+            self.print(f"[{timestamp}] {level}: {message}")
+            return ExitCode.FAILURE
+
+    async def start(self) -> None:
+        """Start the logging server in a separate thread."""
+        if self._running:
+            return
+
+        def _run_server() -> None:
+            """Run the FastAPI server in a new event loop."""
+            uvicorn.run(self.app, host=self.host, port=self.port, log_level="error")
+
+        self.server_thread = threading.Thread(target=_run_server)
+        self.server_thread.daemon = True
+        self.server_thread.start()
+        self._running = True
+        self.write_log(DEBUG, f"Logging server started on {self.host}:{self.port}")
+
+    async def stop(self) -> None:
+        """Stop the logging server."""
+        if self._running:
+            self._running = False
+            if self.server_thread is not None:
+                self.server_thread.join(timeout=1)
+                self.server_thread = None
+            self.write_log(DEBUG, "Logging server stopped")
+
+    async def __aenter__(self) -> Self:
+        """Start the logging server."""
+        if not self.running:
+            await self.start()
+        else:
+            self.write_log(DEBUG, "Logging server is already running")
+        return self
+
+    async def __aexit__(self, exc_type: object, exc_val: object, exc_tb: object) -> None:
+        """Stop the logging server."""
+        await self.stop()
+
+
+class LoggingClient[T: TextIO]:
+    """Logger that calls HTTP endpoints but behaves like SimpleLogger."""
+
+    def __init__(
+        self,
+        server_url: str | None = None,
+        host: str = "http://localhost",
+        port: int = 8080,
+        level: LogLevel | int | str = DEBUG,
+        file: T = DEVNULL,  # Default to DEVNULL to discard console output
+    ) -> None:
+        """Initialize the ServerLogger."""
+        self.host: str = host
+        self.port: int = port
+        self.server_url: str = server_url or f"{self.host}:{self.port}"
+        self.level: LogLevel = LogLevel.get(level, default=DEBUG)
+        self.client: AsyncClient = AsyncClient(timeout=5.0)
+        self.file: T = file
+
+    async def post(self, url: str, json: dict) -> "Response":
+        """Send a POST request to the server."""
+        return await self.client.post(url=url, json=json)
+
+    async def _log(self, request: LogRequest) -> None:
+        """Same interface as SimpleLogger._log but calls HTTP endpoint."""
+        try:
+            response: Response = await self.post(url=f"{self.server_url}/log", json=request.model_dump())
+            if response.status_code != HTTPStatusCode.SERVER_OK:
+                await self._fallback_log(str(request.level), request.message, *request.args, **request.kwargs)
+        except Exception:
+            await self._fallback_log(str(request.level), request.message, *request.args, **request.kwargs)
+
+    async def log(self, level: LogLevel, msg: object, *args: Any, **kwargs: Any) -> None:
+        """Log a message at the specified level."""
+        if level.value >= self.level.value:
+            request = LogRequest(level=level.value, message=str(msg), args=args, kwargs=kwargs)
+            await self._log(request)
+
+    async def _fallback_log(self, lvl: str, msg: object, *args: Any, **kwargs: Any) -> None:
+        """Fallback - same as original SimpleLogger._log."""
+        timestamp: str = EpochTimestamp.now().to_string()
+        print(f"Fallback Logging: [{timestamp}] {lvl}: {msg}", file=self.file)
+        if args:
+            print(" ".join(str(arg) for arg in args), file=self.file)
+        if kwargs:
+            for key, value in kwargs.items():
+                print(f"{key}={value}", file=self.file)
+
+    async def verbose(self, msg: object, *args, **kwargs) -> None:
+        """Log a verbose message."""
+        await self.log(VERBOSE, msg, *args, **kwargs)
+
+    async def debug(self, msg: object, *args, **kwargs) -> None:
+        """Log a debug message."""
+        await self.log(DEBUG, msg, *args, **kwargs)
+
+    async def info(self, msg: object, *args, **kwargs) -> None:
+        """Log an info message."""
+        await self.log(INFO, msg, *args, **kwargs)
+
+    async def warning(self, msg: object, *args, **kwargs) -> None:
+        """Log a warning message."""
+        await self.log(WARNING, msg, *args, **kwargs)
+
+    async def error(self, msg: object, *args, **kwargs) -> None:
+        """Log an error message."""
+        await self.log(ERROR, msg, *args, **kwargs)
+
+    async def failure(self, msg: object, *args, **kwargs) -> None:
+        """Log a failure message."""
+        await self.log(FAILURE, msg, *args, **kwargs)
+
+    async def success(self, msg: object, *args, **kwargs) -> None:
+        """Log a success message."""
+        await self.log(SUCCESS, msg, *args, **kwargs)
+
+    async def close(self) -> None:
+        """Close the HTTP client."""
+        await self.client.aclose()
+
+    async def __aenter__(self) -> Self:
+        """Enter the asynchronous context manager."""
+        return self
+
+    async def __aexit__(self, exc_type: object, exc_value: object, traceback: object) -> None:
+        """Exit the asynchronous context manager."""
+        await self.close()
+
+
+async def run_server(
+    host: str = "localhost",
+    port: int = 8080,
+    log_file: str = "server.log",
+    level: LogLevel | int | str = DEBUG,
+    file: TextIO = DEVNULL,
+) -> ExitCode | int:
+    """Run the local logging server."""
+    server: LoggingServer[TextIO] = LoggingServer(
+        host=host,
+        port=port,
+        log_file=log_file,
+        level=level,
+        file=file,
+    )
+    try:
+        while True:
+            await server.start()
+    except KeyboardInterrupt:
+        print("Stopping server...", file=server.file)
+    except Exception as e:
+        print(f"An error occurred: {e}", file=server.file)
+        return ExitCode.FAILURE
+    finally:
+        await server.stop()
+    return ExitCode.SUCCESS
+
+
+def sync_server(
+    host: str = "localhost",
+    port: int = 8080,
+    log_file: str = "server.log",
+    level: LogLevel | int | str = DEBUG,
+    file: TextIO = DEVNULL,
+) -> ExitCode | int:
+    """Run the local logging server synchronously."""
+    loop = asyncio.get_event_loop()
+    asyncio.set_event_loop(loop)
+    return loop.run_until_complete(run_server(host, port, log_file, level, file))
+
+
+# if __name__ == "__main__":
+#     exit_code = sync_server()
+#     sys.exit(exit_code)