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

bear_utils/logger_manager/loggers/fastapi_logger.py

@@ -1,209 +1,334 @@
 """FastAPI-based local logging server and HTTP logger."""
 
 import asyncio
-import sys
+from collections import deque
+from pathlib import Path
 import threading
-from typing import TYPE_CHECKING
+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
+from pydantic import BaseModel, Field, field_serializer
+from singleton_base import SingletonBase
 import uvicorn
 
-from bear_utils.constants import SERVER_OK
-from bear_utils.logger_manager._log_level import LogLevel, log_levels
+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 = log_levels.get("VERBOSE")
-DEBUG: LogLevel = log_levels.get("DEBUG")
-INFO: LogLevel = log_levels.get("INFO")
-WARNING: LogLevel = log_levels.get("WARNING")
-ERROR: LogLevel = log_levels.get("ERROR")
-
-
-def get_level(level: str) -> int:
-    """Get the numeric value for a given level string."""
-    return log_levels.get_int(level)
-
-
-def get_name(level: int) -> str:
-    """Get the name of a logging level by its integer value."""
-    return log_levels.get_name(level)
+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: str
-    message: str
-    args: list[str] = []
-    kwargs: dict[str, str] = {}
+    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,
+    }
 
-class LocalLoggingServer:
+    @field_serializer("level")
+    def serialize_level(self, value: LogLevel | int | str) -> int:
+        """Serialize the log level to an integer."""
+        return LogLevel.get(value).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 = "server.log",
-        min_level: LogLevel | int | str = DEBUG,
+        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: str = log_file
-        self.min_level: LogLevel = log_levels.get(min_level)
+        self.log_file: Path = Path(log_file)
+        self.log_file.parent.mkdir(parents=True, exist_ok=True)
+        self.level: LogLevel = LogLevel.get(level)
         self.app = FastAPI()
         self.server_thread = None
         self._running = False
+        self.logs: deque[LogRequest] = deque(maxlen=maxlen)
+        self.file: T = file
         self._setup_routes()
-        self.buffer: list[str] = []
+
+    @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) -> dict[str, str]:
-            self.write_log(request.level, request.message, *request.args, **request.kwargs)
-            return {"status": "success"}
+        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)
+            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() -> dict[str, str]:
-            return {"status": "healthy"}
+        async def health_check() -> JSONResponse:
+            return JSONResponse(
+                content={"status": "healthy"},
+                status_code=HTTPStatusCode.SERVER_OK,
+            )
 
-    def write_log(self, level: str, message: str, *args: str, end: str = "\n", **kwargs: str) -> None:
+    def write_log(
+        self,
+        level: LogLevel,
+        message: str,
+        end: str = "\n",
+        console: bool = True,
+        *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:
-            level_t: LogLevel = log_levels.get(level)
-            if level_t.value >= self.min_level.value:
-                log_entry: str = f"[{timestamp}] {level}: {message}"
-                self.buffer.append(log_entry)
-                if args:
-                    self.buffer.append(f"{end}".join(str(arg) for arg in args))
-                if kwargs:
-                    for key, value in kwargs.items():
-                        self.buffer.append(f"{key}={value}{end}")
-                with open(self.log_file, "a", encoding="utf-8") as f:
-                    f.writelines(self.buffer)
-                print(f"{end}".join(self.buffer), file=sys.stderr)
+            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 console:
+                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:
-            print(f"[{timestamp}] {level}: {message}", file=sys.stderr)
-        finally:
-            self.buffer.clear()
+            self.print(f"[{timestamp}] {level}: {message}")
+            return ExitCode.FAILURE
 
-    def start(self) -> None:
+    async def start(self) -> None:
         """Start the logging server in a separate thread."""
         if self._running:
             return
 
-        def run_server() -> None:
+        def _run_server() -> None:
             """Run the FastAPI server in a new event loop."""
-            asyncio.set_event_loop(asyncio.new_event_loop())
-            uvicorn.run(self.app, host=self.host, port=self.port, log_level="warning")
+            uvicorn.run(self.app, host=self.host, port=self.port, log_level="error")
 
-        self.server_thread = threading.Thread(target=run_server)
+        self.server_thread = threading.Thread(target=_run_server)
         self.server_thread.daemon = True
         self.server_thread.start()
         self._running = True
-        print(f"Logging server started on {self.host}:{self.port}")
+        self.write_log(DEBUG, f"Logging server started on {self.host}:{self.port}")
 
-    def stop(self) -> None:
+    async def stop(self) -> None:
         """Stop the logging server."""
         if self._running:
             self._running = False
-            print("Logging server stopped")
+            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 ServerLogger:
+class LoggingClient[T: TextIO]:
     """Logger that calls HTTP endpoints but behaves like SimpleLogger."""
 
-    def __init__(self, server_url: str = "http://localhost:8080", min_level: LogLevel | int | str = INFO) -> None:
+    def __init__(
+        self,
+        server_url: str | None = None,
+        host: str = "http://localhost",
+        port: int = 8080,
+        level: LogLevel | int | str = INFO,
+        file: T = DEVNULL,  # Default to DEVNULL to discard console output
+    ) -> None:
         """Initialize the ServerLogger."""
-        self.server_url: str = server_url.rstrip("/")
-        self.min_level: LogLevel = log_levels.get(min_level)
+        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)
         self.client: AsyncClient = AsyncClient(timeout=5.0)
-        self.loop: asyncio.AbstractEventLoop = asyncio.get_event_loop()
+        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, lvl: LogLevel, msg: object, *args, **kwargs) -> None:
+    async def _log(self, request: LogRequest) -> None:
         """Same interface as SimpleLogger._log but calls HTTP endpoint."""
-        if lvl.value >= self.min_level.value:
-            try:
-                response: Response = await self.client.post(
-                    url=f"{self.server_url}/log",
-                    json={
-                        "level": lvl.value,
-                        "message": msg,
-                        "args": args,
-                        "kwargs": kwargs,
-                    },
-                )
-                if response.status_code != SERVER_OK:
-                    self._fallback_log(lvl, msg, *args, **kwargs)
-            except Exception:
-                self._fallback_log(lvl, msg, *args, **kwargs)
+        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)
 
-    def _fallback_log(self, lvl: LogLevel, msg: object, *args, **kwargs) -> None:
+    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"[{timestamp}] {lvl.value}: {msg}", file=sys.stderr)
+        print(f"Fallback Logging: [{timestamp}] {lvl}: {msg}", file=self.file)
         if args:
-            print(" ".join(str(arg) for arg in args), file=sys.stderr)
+            print(" ".join(str(arg) for arg in args), file=self.file)
         if kwargs:
             for key, value in kwargs.items():
-                print(f"{key}={value}", file=sys.stderr)
+                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)
+        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)
+        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)
+        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)
+        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)
+        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()
 
-
-if __name__ == "__main__":
-    server = LocalLoggingServer(port=8080, log_file="server.log")
+    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:
-            server.start()
+            await server.start()
     except KeyboardInterrupt:
-        print("Stopping server...")
-        server.stop()
-        sys.exit(0)
-#     time.sleep(2)
-
-#     # Use logger exactly like SimpleLogger
-#     logger = HTTPLogger("http://localhost:8080")
-
-#     logger.verbose("This is a verbose message")
-#     logger.debug("This is a debug message")
-#     logger.info("This is an info message")
-#     logger.warning("This is a warning message")
-#     logger.error("This is an error message")
-
-#     logger.close()
-#     time.sleep(1)
-#     server.stop()
+        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)

bear_utils/logger_manager/loggers/simple_logger.py

@@ -1,30 +1,36 @@
 """Simple logger implementation with log levels and timestamped output."""
 
-import sys
+from io import StringIO
 from typing import TextIO
 
-from bear_utils.logger_manager._log_level import LogLevel, log_levels
+from bear_utils.constants import STDERR, STDOUT
+from bear_utils.logger_manager._log_level import LogLevel
 from bear_utils.time import EpochTimestamp
 
-STDOUT: TextIO = sys.stdout
-STDERR: TextIO = sys.stderr
+VERBOSE: LogLevel = LogLevel.get("VERBOSE")
+DEBUG: LogLevel = LogLevel.get("DEBUG")
+INFO: LogLevel = LogLevel.get("INFO")
+WARNING: LogLevel = LogLevel.get("WARNING")
+ERROR: LogLevel = LogLevel.get("ERROR")
+SUCCESS: LogLevel = LogLevel.get("SUCCESS")
+FAILURE: LogLevel = LogLevel.get("FAILURE")
 
-VERBOSE: LogLevel = log_levels.get("VERBOSE")
-DEBUG: LogLevel = log_levels.get("DEBUG")
-INFO: LogLevel = log_levels.get("INFO")
-WARNING: LogLevel = log_levels.get("WARNING")
-ERROR: LogLevel = log_levels.get("ERROR")
+CHOICES = [STDOUT, STDERR, StringIO]
 
 
-class SimpleLogger:
-    """A simple logger that writes messages to stderr (or STDOUT if preferred) with a timestamp."""
+class SimpleLogger[T: TextIO]:
+    """A simple logger that writes messages to stdout, stderr, or StringIO with a timestamp."""
 
-    def __init__(self, min_level: int | str | LogLevel = INFO, redirect: TextIO = STDERR) -> None:
-        """Initialize the logger with a minimum log level."""
-        self.min_level: LogLevel = log_levels.get(min_level)
-        self.redirect: TextIO = redirect
+    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)
+        self.file: T = file
         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:
@@ -34,15 +40,15 @@ class SimpleLogger:
             if kwargs:
                 for key, value in kwargs.items():
                     self.buffer.append(f"{key}={value}")
-            print(f"{end}".join(self.buffer), file=self.redirect)
+            self.print(f"{end}".join(self.buffer))
         except Exception as e:
-            print(f"[{timestamp}] {level.value}: {msg} - Error: {e}", file=self.redirect)
+            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.min_level.value:
+        if level.value >= self.level.value:
             self._log(level, msg, *args, **kwargs)
 
     def verbose(self, msg: object, *args, **kwargs) -> None:
@@ -65,13 +71,22 @@ class SimpleLogger:
         """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)
+
 
 # Example usage:
 if __name__ == "__main__":
-    logger = SimpleLogger()
-
-    logger.verbose(msg="This is a verbose message")
-    logger.debug(msg="This is a debug message")
+    logger = SimpleLogger(file=StringIO())
+    logger_two = SimpleLogger(level="INFO", file=STDERR)
     logger.info(msg="This is an info message")
-    logger.warning(msg="This is a warning message")
-    logger.error(msg="This is an error 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-0.8.26.dist-info → bear_utils-0.9.0.dist-info}/METADATA

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: bear-utils
-Version: 0.8.26
+Version: 0.9.0
 Summary: Various utilities for Bear programmers, including a rich logging utility, a disk cache, and a SQLite database wrapper amongst other things.
 Author-email: chaz <bright.lid5647@fastmail.com>
 Requires-Python: >=3.12
-Requires-Dist: bear-epoch-time>=1.1.1
+Requires-Dist: bear-epoch-time>=1.1.4
 Requires-Dist: diskcache<6.0.0,>=5.6.3
 Requires-Dist: fastapi>=0.116.0
 Requires-Dist: httpx>=0.28.1
@@ -25,7 +25,7 @@ Provides-Extra: gui
 Requires-Dist: pyqt6>=6.9.0; extra == 'gui'
 Description-Content-Type: text/markdown
 
-# Bear Utils v# Bear Utils v0.8.26
+# Bear Utils v# Bear Utils v0.9.0
 
 Personal set of tools and utilities for Python projects, focusing on modularity and ease of use. This library includes components for caching, database management, logging, time handling, file operations, CLI prompts, image processing, clipboard interaction, gradient utilities, event systems, and async helpers.