webscout 8.2.8__py3-none-any.whl → 8.2.9__py3-none-any.whl

webscout/Litlogger/handlers.py

@@ -0,0 +1,103 @@
+import os
+import socket
+import http.client
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+from .levels import LogLevel
+
+RESET = "\033[0m"
+LEVEL_COLORS = {
+    LogLevel.TRACE: "\033[90m",
+    LogLevel.DEBUG: "\033[36m",
+    LogLevel.INFO: "\033[32m",
+    LogLevel.WARNING: "\033[33m",
+    LogLevel.ERROR: "\033[31m",
+    LogLevel.CRITICAL: "\033[41m\033[97m",
+}
+
+class Handler:
+    def __init__(self, level: LogLevel = LogLevel.DEBUG):
+        self.level = level
+
+    def emit(self, message: str, level: LogLevel):
+        raise NotImplementedError
+
+class ConsoleHandler(Handler):
+    def __init__(self, stream=None, level: LogLevel = LogLevel.DEBUG):
+        super().__init__(level)
+        self.stream = stream or os.sys.stdout
+
+    def emit(self, message: str, level: LogLevel):
+        color = LEVEL_COLORS.get(level, "")
+        self.stream.write(f"{color}{message}{RESET}\n")
+        self.stream.flush()
+
+class FileHandler(Handler):
+    def __init__(self, path: str, level: LogLevel = LogLevel.DEBUG, max_bytes: int = 0, backups: int = 0):
+        super().__init__(level)
+        self.path = Path(path)
+        self.max_bytes = max_bytes
+        self.backups = backups
+        self._open()
+
+    def _open(self):
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        self._file = open(self.path, "a", encoding="utf-8")
+
+    def _rotate(self):
+        if self.backups <= 0:
+            self._file.close()
+            self.path.unlink(missing_ok=True)
+            self._open()
+            return
+        self._file.close()
+        for i in range(self.backups, 0, -1):
+            src = self.path.with_suffix(f".{i}") if i == 1 else self.path.with_suffix(f".{i-1}")
+            dst = self.path.with_suffix(f".{i}")
+            if src.exists():
+                if dst.exists():
+                    dst.unlink()
+                src.rename(dst)
+        self._open()
+
+    def emit(self, message: str, level: LogLevel):
+        if self.level and level < self.level:
+            return
+        self._file.write(message + "\n")
+        self._file.flush()
+        if self.max_bytes and self._file.tell() >= self.max_bytes:
+            self._rotate()
+
+class NetworkHandler(Handler):
+    def __init__(self, host: str, port: int, use_https: bool = False, level: LogLevel = LogLevel.DEBUG):
+        super().__init__(level)
+        self.host = host
+        self.port = port
+        self.use_https = use_https
+
+    def emit(self, message: str, level: LogLevel):
+        if level < self.level:
+            return
+        if self.use_https:
+            conn = http.client.HTTPSConnection(self.host, self.port, timeout=5)
+        else:
+            conn = http.client.HTTPConnection(self.host, self.port, timeout=5)
+        try:
+            conn.request("POST", "/", body=message.encode(), headers={"Content-Type": "text/plain"})
+            conn.getresponse().read()
+        finally:
+            conn.close()
+
+class TCPHandler(Handler):
+    def __init__(self, host: str, port: int, level: LogLevel = LogLevel.DEBUG):
+        super().__init__(level)
+        self.host = host
+        self.port = port
+
+    def emit(self, message: str, level: LogLevel):
+        if level < self.level:
+            return
+        with socket.create_connection((self.host, self.port), timeout=5) as sock:
+            sock.sendall(message.encode() + b"\n")

webscout/Litlogger/levels.py

@@ -0,0 +1,13 @@
+from enum import IntEnum
+
+class LogLevel(IntEnum):
+    TRACE = 10
+    DEBUG = 20
+    INFO = 30
+    WARNING = 40
+    ERROR = 50
+    CRITICAL = 60
+
+    @classmethod
+    def from_str(cls, level: str) -> "LogLevel":
+        return cls[level.upper()]

webscout/Litlogger/logger.py

@@ -0,0 +1,92 @@
+import asyncio
+import sys
+import traceback
+from datetime import datetime
+from typing import List, Optional
+
+from .levels import LogLevel
+from .formats import LogFormat
+from .handlers import Handler, ConsoleHandler
+
+class Logger:
+    def __init__(
+        self,
+        name: str = "LitLogger",
+        level: LogLevel = LogLevel.INFO,
+        handlers: Optional[List[Handler]] = None,
+        fmt: str = LogFormat.DEFAULT,  # <--- use LogFormat.DEFAULT
+        async_mode: bool = False,
+    ):
+        self.name = name
+        self.level = level
+        self.format = fmt
+        self.async_mode = async_mode
+        self.handlers = handlers or [ConsoleHandler()]
+
+    def _format(self, level: LogLevel, message: str) -> str:
+        now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        return self.format.format(time=now, level=level.name, name=self.name, message=message)
+
+    def _should_log(self, level: LogLevel) -> bool:
+        return level >= self.level
+
+    async def _log_async(self, level: LogLevel, message: str):
+        if not self._should_log(level):
+            return
+        record = self._format(level, message)
+        tasks = []
+        for h in self.handlers:
+            if level >= h.level:
+                if asyncio.iscoroutinefunction(h.emit):
+                    tasks.append(h.emit(record, level))
+                else:
+                    tasks.append(asyncio.to_thread(h.emit, record, level))
+        if tasks:
+            await asyncio.gather(*tasks)
+
+    def _log(self, level: LogLevel, message: str):
+        if not self._should_log(level):
+            return
+        record = self._format(level, message)
+        for h in self.handlers:
+            if level >= h.level:
+                h.emit(record, level)
+
+    def log(self, level: LogLevel, message: str):
+        if self.async_mode:
+            loop = asyncio.get_event_loop()
+            if loop.is_running():
+                return asyncio.create_task(self._log_async(level, message))
+            return loop.run_until_complete(self._log_async(level, message))
+        self._log(level, message)
+
+    def trace(self, message: str):
+        self.log(LogLevel.TRACE, message)
+
+    def debug(self, message: str):
+        self.log(LogLevel.DEBUG, message)
+
+    def info(self, message: str):
+        self.log(LogLevel.INFO, message)
+
+    def warning(self, message: str):
+        self.log(LogLevel.WARNING, message)
+
+    def error(self, message: str):
+        self.log(LogLevel.ERROR, message)
+
+    def critical(self, message: str):
+        self.log(LogLevel.CRITICAL, message)
+
+    def exception(self, message: str):
+        exc = sys.exc_info()
+        formatted = f"{message}\n" + "".join(traceback.format_exception(*exc))
+        self.error(formatted)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc, tb):
+        if exc_type:
+            self.exception(str(exc))
+        return False