webscout 7.1__py3-none-any.whl → 7.3__py3-none-any.whl

webscout/Litlogger/core/__init__.py

@@ -0,0 +1,6 @@
+"""Core logging functionality."""
+
+from .logger import Logger
+from .level import LogLevel
+
+__all__ = ["Logger", "LogLevel"]

webscout/Litlogger/core/level.py

@@ -0,0 +1,23 @@
+from enum import Enum
+
+class LogLevel(Enum):
+    NOTSET = 0
+    DEBUG = 10
+    INFO = 20
+    WARNING = 30
+    ERROR = 40
+    CRITICAL = 50
+
+    @staticmethod
+    def get_level(level_str: str) -> 'LogLevel':
+        if not level_str:
+            return LogLevel.NOTSET
+        try:
+            return LogLevel[level_str.upper()]
+        except KeyError:
+            raise ValueError(f"Invalid log level: {level_str}")
+
+    def __lt__(self, other):
+        if isinstance(other, LogLevel):
+            return self.value < other.value
+        return NotImplemented

webscout/Litlogger/core/logger.py

@@ -0,0 +1,166 @@
+
+import asyncio
+import sys
+import threading
+import traceback
+from datetime import datetime
+from typing import Any, Dict, List, Optional, Union
+
+from ..core.level import LogLevel
+from ..styles.formats import LogFormat
+from ..styles.colors import LogColors
+
+class Logger:
+    # Emoji mappings for different log levels
+    LEVEL_EMOJIS = {
+        LogLevel.DEBUG: "🔍",
+        LogLevel.INFO: "ℹ️",
+        LogLevel.WARNING: "⚠️",
+        LogLevel.ERROR: "❌",
+        LogLevel.CRITICAL: "🔥"
+    }
+
+    def __init__(
+        self,
+        name: str = "LitLogger",
+        level: Union[str, LogLevel, None] = None,
+        format: Union[str, LogFormat] = LogFormat.MODERN_EMOJI,
+        handlers: List = None,
+        enable_colors: bool = True,
+        async_mode: bool = False,
+        show_thread: bool = True,
+        show_context: bool = True
+    ):
+        self.name = name
+        self.level = LogLevel.NOTSET if level is None else (
+            LogLevel.get_level(level) if isinstance(level, str) else level
+        )
+        self.format = format
+        self.enable_colors = enable_colors
+        self.async_mode = async_mode
+        self.show_thread = show_thread
+        self.show_context = show_context
+        self._context_data = {}
+        
+        # Initialize with default console handler if none provided
+        if handlers is None:
+            from ..handlers.console import ConsoleHandler
+            self.handlers = [ConsoleHandler(level=self.level)]
+        else:
+            self.handlers = handlers
+
+    def _format_message(self, level: LogLevel, message: str, **kwargs) -> str:
+        now = datetime.now()
+        emoji = self.LEVEL_EMOJIS.get(level, "") if self.enable_colors else ""
+        
+        log_data = {
+            "timestamp": now.strftime("%H:%M:%S"),
+            "level": level.name,
+            "name": self.name,
+            "message": str(message),
+            "emoji": emoji,
+            "thread": threading.current_thread().name if self.show_thread else "",
+        }
+        
+        # Add context data
+        if self.show_context and self._context_data:
+            log_data.update(self._context_data)
+        
+        # Add extra kwargs
+        log_data.update(kwargs)
+        
+        # Format exception if present
+        if 'exc_info' in kwargs:
+            exc_info = kwargs['exc_info']
+            if exc_info:
+                exception_text = ''.join(traceback.format_exception(*exc_info))
+                log_data['message'] = f"{message}\n{exception_text}"
+        
+        try:
+            base_message = f"{emoji} [{log_data['timestamp']}] {level.name} {log_data['message']}"
+            return base_message
+        except Exception as e:
+            return f"[{log_data['timestamp']}] {level.name}: {message}"
+
+    def _log(self, level: LogLevel, message: str, **kwargs):
+        if self.async_mode:
+            loop = asyncio.get_event_loop()
+            if loop.is_running():
+                return asyncio.create_task(self._async_log(level, message, **kwargs))
+            else:
+                return loop.run_until_complete(self._async_log(level, message, **kwargs))
+        return self._sync_log(level, message, **kwargs)
+
+    def debug(self, message: str, **kwargs):
+        self._log(LogLevel.DEBUG, message, **kwargs)
+
+    def info(self, message: str, **kwargs):
+        self._log(LogLevel.INFO, message, **kwargs)
+
+    def warning(self, message: str, **kwargs):
+        self._log(LogLevel.WARNING, message, **kwargs)
+
+    def error(self, message: str, **kwargs):
+        self._log(LogLevel.ERROR, message, **kwargs)
+
+    def critical(self, message: str, **kwargs):
+        self._log(LogLevel.CRITICAL, message, **kwargs)
+
+    def exception(self, message: str, exc_info=True, **kwargs):
+        """
+        Log an exception with traceback.
+        
+        Args:
+            message: The message to log
+            exc_info: If True, adds exception info to the message. Can also be a tuple (type, value, traceback)
+            **kwargs: Additional key-value pairs to log
+        """
+        if exc_info:
+            if not isinstance(exc_info, tuple):
+                exc_info = sys.exc_info()
+        kwargs['exc_info'] = exc_info
+        self.error(message, **kwargs)
+
+    def _sync_log(self, level: LogLevel, message: str, **kwargs):
+        if self._should_log(level):
+            formatted_message = self._format_message(level, message, **kwargs)
+            for handler in self.handlers:
+                if handler.level == LogLevel.NOTSET or level.value >= handler.level.value:
+                    handler.emit(formatted_message, level)
+
+    async def _async_log(self, level: LogLevel, message: str, **kwargs):
+        if self._should_log(level):
+            formatted_message = self._format_message(level, message, **kwargs)
+            tasks = []
+            for handler in self.handlers:
+                if handler.level == LogLevel.NOTSET or level.value >= handler.level.value:
+                    if hasattr(handler, 'async_emit'):
+                        tasks.append(handler.async_emit(formatted_message, level))
+                    else:
+                        tasks.append(asyncio.to_thread(handler.emit, formatted_message, level))
+            await asyncio.gather(*tasks)
+
+    def _should_log(self, level: LogLevel) -> bool:
+        return self.level == LogLevel.NOTSET or level.value >= self.level.value
+
+    def set_context(self, **kwargs):
+        self._context_data.update(kwargs)
+
+    def clear_context(self):
+        self._context_data.clear()
+
+    def set_style(self, style: str):
+        """Set logger style format."""
+        if style in LogFormat.TEMPLATES:
+            self.format = LogFormat.TEMPLATES[style]
+        else:
+            raise ValueError(f"Unknown style: {style}")
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if exc_type is not None:
+            self.error(f"Context exited with error: {exc_val}")
+            return False
+        return True

webscout/Litlogger/handlers/__init__.py

@@ -0,0 +1,12 @@
+"""Log output handlers for different destinations."""
+
+from .console import ConsoleHandler, ErrorConsoleHandler
+from .file import FileHandler
+from .network import NetworkHandler
+
+__all__ = [
+    "ConsoleHandler",
+    "ErrorConsoleHandler",
+    "FileHandler",
+    "NetworkHandler"
+]

webscout/Litlogger/handlers/console.py

@@ -0,0 +1,33 @@
+import sys
+from ..core.level import LogLevel
+from ..styles.colors import LogColors
+
+class ConsoleHandler:
+    def __init__(self, level: LogLevel = LogLevel.DEBUG, stream=sys.stdout):
+        self.level = level
+        self.stream = stream
+        self.colors = LogColors()
+
+    def emit(self, message: str, level: LogLevel):
+        """Write the colored message to the console."""
+        try:
+            # Apply color based on log level
+            color = LogColors.LEVEL_COLORS.get(level, LogColors.RESET)
+            colored_message = f"{color}{message}{LogColors.RESET}"
+            print(colored_message, file=self.stream, flush=True)
+        except Exception as e:
+            # Fallback to plain printing if coloring fails
+            print(message, file=self.stream, flush=True)
+
+    async def async_emit(self, message: str, level: LogLevel):
+        """
+        Asynchronously write log message to console.
+        Just calls emit() since console output is generally fast enough.
+        """
+        self.emit(message, level)
+
+class ErrorConsoleHandler(ConsoleHandler):
+    """Specialized handler that writes to stderr."""
+    
+    def __init__(self, level: LogLevel = LogLevel.ERROR):
+        super().__init__(stream=sys.stderr, level=level)

webscout/Litlogger/handlers/file.py

@@ -0,0 +1,143 @@
+import os
+import time
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, Union
+from ..core.level import LogLevel
+
+class FileHandler:
+    """Handler for outputting log messages to a file with optional rotation."""
+    
+    def __init__(
+        self,
+        filename: Union[str, Path],
+        mode: str = "a",
+        encoding: str = "utf-8",
+        level: LogLevel = LogLevel.DEBUG,
+        max_bytes: int = 0,
+        backup_count: int = 0,
+        rotate_on_time: bool = False,
+        time_interval: str = "D"  # D=daily, H=hourly, M=monthly
+    ):
+        """
+        Initialize file handler with rotation options.
+        
+        Args:
+            filename: Log file path
+            mode: File open mode ('a' for append, 'w' for write)
+            encoding: File encoding
+            level: Minimum log level to output
+            max_bytes: Max file size before rotation (0 = no size limit)
+            backup_count: Number of backup files to keep (0 = no backups)
+            rotate_on_time: Enable time-based rotation
+            time_interval: Rotation interval ('D'=daily, 'H'=hourly, 'M'=monthly)
+        """
+        self.filename = Path(filename)
+        self.mode = mode
+        self.encoding = encoding
+        self.level = level
+        self.max_bytes = max_bytes
+        self.backup_count = backup_count
+        self.rotate_on_time = rotate_on_time
+        self.time_interval = time_interval.upper()
+        
+        if self.time_interval not in ["D", "H", "M"]:
+            raise ValueError("time_interval must be 'D', 'H', or 'M'")
+            
+        self._file = None
+        self._current_size = 0
+        self._last_rollover_time = time.time()
+        
+        # Create directory if it doesn't exist
+        self.filename.parent.mkdir(parents=True, exist_ok=True)
+        
+        # Open the file
+        self._open()
+        
+    def _open(self):
+        """Open or reopen the log file."""
+        if self._file:
+            self._file.close()
+        
+        self._file = open(
+            self.filename,
+            mode=self.mode,
+            encoding=self.encoding
+        )
+        
+        self._current_size = self._file.tell()
+        if self.mode == "a":
+            self._current_size = self.filename.stat().st_size
+            
+    def _should_rollover(self) -> bool:
+        """Check if file should be rolled over based on size or time."""
+        if self.max_bytes > 0 and self._current_size >= self.max_bytes:
+            return True
+            
+        if self.rotate_on_time:
+            current_time = time.time()
+            if self.time_interval == "H":
+                interval = 3600  # 1 hour
+            elif self.time_interval == "D":
+                interval = 86400  # 1 day
+            else:  # Monthly
+                now = datetime.now()
+                if now.month == datetime.fromtimestamp(self._last_rollover_time).month:
+                    return False
+                return True
+                
+            if current_time - self._last_rollover_time >= interval:
+                return True
+                
+        return False
+        
+    def _do_rollover(self):
+        """Perform log file rotation."""
+        if self._file:
+            self._file.close()
+            self._file = None
+            
+        if self.backup_count > 0:
+            # Shift existing backup files
+            for i in range(self.backup_count - 1, 0, -1):
+                sfn = f"{self.filename}.{i}"
+                dfn = f"{self.filename}.{i + 1}"
+                if os.path.exists(sfn):
+                    if os.path.exists(dfn):
+                        os.remove(dfn)
+                    os.rename(sfn, dfn)
+                    
+            dfn = f"{self.filename}.1"
+            if os.path.exists(dfn):
+                os.remove(dfn)
+            os.rename(self.filename, dfn)
+            
+        self._open()
+        self._last_rollover_time = time.time()
+        
+    def emit(self, message: str, level: LogLevel):
+        """Write log message to file if level is sufficient."""
+        if level.value >= self.level.value:
+            try:
+                if self._should_rollover():
+                    self._do_rollover()
+                    
+                self._file.write(message + "\n")
+                self._file.flush()
+                self._current_size = self._file.tell()
+                
+            except Exception as e:
+                # Fallback to console on error
+                import sys
+                sys.stderr.write(f"Error in FileHandler: {e}\n")
+                sys.stderr.write(message + "\n")
+                
+    async def async_emit(self, message: str, level: LogLevel):
+        """Asynchronously write log message to file."""
+        self.emit(message, level)
+        
+    def close(self):
+        """Close the log file."""
+        if self._file:
+            self._file.close()
+            self._file = None

webscout/Litlogger/handlers/network.py

@@ -0,0 +1,173 @@
+import asyncio
+import json
+import socket
+from typing import Optional, Dict, Any
+import aiohttp
+from ..core.level import LogLevel
+
+class NetworkHandler:
+    """Handler for sending log messages to a remote server."""
+    
+    def __init__(
+        self,
+        host: str,
+        port: int,
+        protocol: str = "http",
+        endpoint: str = "/logs",
+        method: str = "POST",
+        headers: Optional[Dict[str, str]] = None,
+        timeout: float = 5.0,
+        level: LogLevel = LogLevel.DEBUG,
+        batch_size: int = 0,
+        retry_count: int = 3,
+        retry_delay: float = 1.0,
+        custom_fields: Optional[Dict[str, Any]] = None
+    ):
+        """
+        Initialize network handler.
+        
+        Args:
+            host: Remote server hostname/IP
+            port: Remote server port
+            protocol: 'http', 'https', or 'tcp'
+            endpoint: Server endpoint for HTTP/HTTPS
+            method: HTTP method to use
+            headers: Optional HTTP headers
+            timeout: Request timeout in seconds
+            level: Minimum log level to send
+            batch_size: Number of logs to batch (0 = no batching)
+            retry_count: Number of retries on failure
+            retry_delay: Delay between retries in seconds
+            custom_fields: Additional fields to include in log data
+        """
+        self.host = host
+        self.port = port
+        self.protocol = protocol.lower()
+        self.endpoint = endpoint
+        self.method = method.upper()
+        self.headers = headers or {}
+        self.timeout = timeout
+        self.level = level
+        self.batch_size = batch_size
+        self.retry_count = retry_count
+        self.retry_delay = retry_delay
+        self.custom_fields = custom_fields or {}
+        
+        if self.protocol not in ["http", "https", "tcp"]:
+            raise ValueError("Protocol must be 'http', 'https' or 'tcp'")
+            
+        self._batch = []
+        self._tcp_socket = None
+        self._session = None
+        
+    async def _init_session(self):
+        """Initialize HTTP session if needed."""
+        if self.protocol in ["http", "https"] and not self._session:
+            self._session = aiohttp.ClientSession(
+                timeout=aiohttp.ClientTimeout(total=self.timeout)
+            )
+            
+    async def _send_http(self, data: Dict[str, Any]) -> bool:
+        """Send log data via HTTP/HTTPS."""
+        await self._init_session()
+        
+        url = f"{self.protocol}://{self.host}:{self.port}{self.endpoint}"
+        
+        for attempt in range(self.retry_count + 1):
+            try:
+                async with self._session.request(
+                    method=self.method,
+                    url=url,
+                    json=data,
+                    headers=self.headers
+                ) as response:
+                    return response.status < 400
+                    
+            except Exception:
+                if attempt == self.retry_count:
+                    return False
+                await asyncio.sleep(self.retry_delay)
+                
+    async def _send_tcp(self, data: Dict[str, Any]) -> bool:
+        """Send log data via TCP."""
+        message = json.dumps(data).encode() + b"\n"
+        
+        for attempt in range(self.retry_count + 1):
+            try:
+                if not self._tcp_socket:
+                    self._tcp_socket = socket.socket(
+                        socket.AF_INET, socket.SOCK_STREAM
+                    )
+                    self._tcp_socket.settimeout(self.timeout)
+                    self._tcp_socket.connect((self.host, self.port))
+                    
+                self._tcp_socket.sendall(message)
+                return True
+                
+            except Exception:
+                if self._tcp_socket:
+                    self._tcp_socket.close()
+                    self._tcp_socket = None
+                    
+                if attempt == self.retry_count:
+                    return False
+                    
+                await asyncio.sleep(self.retry_delay)
+                
+    def emit(self, message: str, level: LogLevel):
+        """
+        Synchronously send log message.
+        Not recommended - use async_emit instead.
+        """
+        if level.value >= self.level.value:
+            loop = asyncio.get_event_loop()
+            loop.run_until_complete(self.async_emit(message, level))
+            
+    async def async_emit(self, message: str, level: LogLevel):
+        """Asynchronously send log message to remote server."""
+        # Fix: Allow all messages if level is NOTSET
+        if self.level == LogLevel.NOTSET or level.value >= self.level.value:
+            log_data = {
+                "message": message,
+                "level": level.name,
+                **self.custom_fields
+            }
+            
+            if self.batch_size > 0:
+                self._batch.append(log_data)
+                if len(self._batch) >= self.batch_size:
+                    await self._send_batch()
+            else:
+                if self.protocol in ["http", "https"]:
+                    await self._send_http(log_data)
+                else:
+                    await self._send_tcp(log_data)
+                    
+    async def _send_batch(self):
+        """Send batched log messages."""
+        if not self._batch:
+            return
+            
+        batch_data = {"logs": self._batch}
+        success = False
+        
+        if self.protocol in ["http", "https"]:
+            success = await self._send_http(batch_data)
+        else:
+            success = await self._send_tcp(batch_data)
+            
+        if success:
+            self._batch.clear()
+            
+    async def close(self):
+        """Close network connections."""
+        if self._batch:
+            await self._send_batch()
+            
+        if self._tcp_socket:
+            self._tcp_socket.close()
+            self._tcp_socket = None
+            
+        if self._session:
+            await self._session.close()
+            self._session = None

webscout/Litlogger/styles/__init__.py

@@ -0,0 +1,7 @@
+"""Styling and formatting utilities."""
+
+from .colors import LogColors
+from .formats import LogFormat
+from .text import TextStyle
+
+__all__ = ["LogColors", "LogFormat", "TextStyle"]