webscout 8.3.6__py3-none-any.whl → 2025.10.11__py3-none-any.whl

webscout/Litlogger/handlers.py

@@ -1,121 +1,121 @@
-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")
-
-class JSONFileHandler(FileHandler):
-    def __init__(self, path: str, level: LogLevel = LogLevel.DEBUG, max_bytes: int = 0, backups: int = 0):
-        super().__init__(path, level, max_bytes, backups)
-
-    def emit(self, message: str, level: LogLevel):
-        # Expect message to be a JSON string or dict
-        if level < self.level:
-            return
-        import json
-        if isinstance(message, dict):
-            log_entry = json.dumps(message)
-        else:
-            log_entry = message
-        self._file.write(log_entry + "\n")
-        self._file.flush()
-        if self.max_bytes and self._file.tell() >= self.max_bytes:
-            self._rotate()
+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")
+
+class JSONFileHandler(FileHandler):
+    def __init__(self, path: str, level: LogLevel = LogLevel.DEBUG, max_bytes: int = 0, backups: int = 0):
+        super().__init__(path, level, max_bytes, backups)
+
+    def emit(self, message: str, level: LogLevel):
+        # Expect message to be a JSON string or dict
+        if level < self.level:
+            return
+        import json
+        if isinstance(message, dict):
+            log_entry = json.dumps(message)
+        else:
+            log_entry = message
+        self._file.write(log_entry + "\n")
+        self._file.flush()
+        if self.max_bytes and self._file.tell() >= self.max_bytes:
+            self._rotate()

webscout/Litlogger/levels.py

@@ -1,13 +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()]
+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

@@ -1,134 +1,134 @@
-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,
-        include_context: bool = False,  # New flag to include thread/process info
-    ):
-        import threading
-        import multiprocessing
-
-        self.name = name
-        self.level = level
-        self.format = fmt
-        self.async_mode = async_mode
-        self.include_context = include_context
-        self.handlers = handlers or [ConsoleHandler()]
-        self._thread = threading
-        self._multiprocessing = multiprocessing
-
-    def _format(self, level: LogLevel, message: str) -> str:
-        now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        if self.include_context:
-            thread_name = self._thread.current_thread().name
-            process_id = self._multiprocessing.current_process().pid
-            # Check if format is JSON format
-            if self.format.strip().startswith('{') and self.format.strip().endswith('}'):
-                # Format as JSON string with extra fields
-                return self.format.format(
-                    time=now,
-                    level=level.name,
-                    name=self.name,
-                    message=message,
-                    thread=thread_name,
-                    process=process_id
-                )
-            else:
-                # For non-JSON formats, add thread and process info if placeholders exist
-                try:
-                    return self.format.format(
-                        time=now,
-                        level=level.name,
-                        name=self.name,
-                        message=message,
-                        thread=thread_name,
-                        process=process_id
-                    )
-                except KeyError:
-                    # If thread/process placeholders not in format, append them manually
-                    base = self.format.format(time=now, level=level.name, name=self.name, message=message)
-                    return f"{base} | Thread: {thread_name} | Process: {process_id}"
-        else:
-            return self.format.format(time=now, level=level.name, name=self.name, message=message)
-
-    def set_format(self, fmt: str, include_context: bool = False):
-        """Dynamically change the log format and context inclusion."""
-        self.format = fmt
-        self.include_context = include_context
-
-    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
+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,
+        include_context: bool = False,  # New flag to include thread/process info
+    ):
+        import threading
+        import multiprocessing
+
+        self.name = name
+        self.level = level
+        self.format = fmt
+        self.async_mode = async_mode
+        self.include_context = include_context
+        self.handlers = handlers or [ConsoleHandler()]
+        self._thread = threading
+        self._multiprocessing = multiprocessing
+
+    def _format(self, level: LogLevel, message: str) -> str:
+        now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        if self.include_context:
+            thread_name = self._thread.current_thread().name
+            process_id = self._multiprocessing.current_process().pid
+            # Check if format is JSON format
+            if self.format.strip().startswith('{') and self.format.strip().endswith('}'):
+                # Format as JSON string with extra fields
+                return self.format.format(
+                    time=now,
+                    level=level.name,
+                    name=self.name,
+                    message=message,
+                    thread=thread_name,
+                    process=process_id
+                )
+            else:
+                # For non-JSON formats, add thread and process info if placeholders exist
+                try:
+                    return self.format.format(
+                        time=now,
+                        level=level.name,
+                        name=self.name,
+                        message=message,
+                        thread=thread_name,
+                        process=process_id
+                    )
+                except KeyError:
+                    # If thread/process placeholders not in format, append them manually
+                    base = self.format.format(time=now, level=level.name, name=self.name, message=message)
+                    return f"{base} | Thread: {thread_name} | Process: {process_id}"
+        else:
+            return self.format.format(time=now, level=level.name, name=self.name, message=message)
+
+    def set_format(self, fmt: str, include_context: bool = False):
+        """Dynamically change the log format and context inclusion."""
+        self.format = fmt
+        self.include_context = include_context
+
+    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