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

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"]

webscout/Litlogger/styles/colors.py

@@ -0,0 +1,249 @@
+# Terminal Color Management System
+# Provides extensive ANSI color support with themes, gradients, and animations
+
+from typing import Optional
+from ..core.level import LogLevel
+
+
+class LogColors:
+    """
+    Comprehensive terminal color and styling system with support for:
+    - Basic and bright colors (foreground/background)
+    - RGB and 256-color modes
+    - Text styles (bold, italic, etc.)
+    - Gradients and animations
+    - Predefined themes
+    """
+    # Reset
+    RESET = "\033[0m"
+    
+    # Regular colors
+    BLACK = "\033[30m"
+    RED = "\033[31m"
+    GREEN = "\033[32m"
+    YELLOW = "\033[33m"
+    BLUE = "\033[34m"
+    MAGENTA = "\033[35m"
+    CYAN = "\033[36m"
+    WHITE = "\033[37m"
+    
+    # Background colors
+    BG_BLACK = "\033[40m"
+    BG_RED = "\033[41m"
+    BG_GREEN = "\033[42m"
+    BG_YELLOW = "\033[43m"
+    BG_BLUE = "\033[44m"
+    BG_MAGENTA = "\033[45m"
+    BG_CYAN = "\033[46m"
+    BG_WHITE = "\033[47m"
+    
+    # Bright colors
+    BRIGHT_BLACK = "\033[90m"
+    BRIGHT_RED = "\033[91m"
+    BRIGHT_GREEN = "\033[92m"
+    BRIGHT_YELLOW = "\033[93m"
+    BRIGHT_BLUE = "\033[94m"
+    BRIGHT_MAGENTA = "\033[95m"
+    BRIGHT_CYAN = "\033[96m"
+    BRIGHT_WHITE = "\033[97m"
+    
+    # Bright background colors
+    BG_BRIGHT_BLACK = "\033[100m"
+    BG_BRIGHT_RED = "\033[101m"
+    BG_BRIGHT_GREEN = "\033[102m"
+    BG_BRIGHT_YELLOW = "\033[103m"
+    BG_BRIGHT_BLUE = "\033[104m"
+    BG_BRIGHT_MAGENTA = "\033[105m"
+    BG_BRIGHT_CYAN = "\033[106m"
+    BG_BRIGHT_WHITE = "\033[107m"
+    
+    # Custom theme colors using RGB
+    FIRE = "\033[38;2;255;100;0m"  # Orange-red
+    ICE = "\033[38;2;150;230;255m"  # Light blue
+    GRASS = "\033[38;2;120;200;80m"  # Light green
+    PURPLE = "\033[38;2;147;112;219m"  # Medium purple
+    GOLD = "\033[38;2;255;215;0m"  # Golden
+    
+    # Gradient colors
+    SUNSET_START = "\033[38;2;255;128;0m"  # Orange
+    SUNSET_END = "\033[38;2;255;51;153m"  # Pink
+    
+    OCEAN_START = "\033[38;2;0;204;255m"  # Light blue
+    OCEAN_END = "\033[38;2;0;51;102m"  # Dark blue
+    
+    FOREST_START = "\033[38;2;34;139;34m"  # Forest green
+    FOREST_END = "\033[38;2;0;100;0m"  # Dark green
+    
+    # Bold
+    BOLD = "\033[1m"
+    
+    # Styles
+    DIM = "\033[2m"
+    ITALIC = "\033[3m"
+    UNDERLINE = "\033[4m"
+    
+    # Level color mapping
+    LEVEL_COLORS = {
+        LogLevel.DEBUG: BRIGHT_BLACK,
+        LogLevel.INFO: BRIGHT_BLUE,
+        LogLevel.WARNING: BRIGHT_YELLOW,
+        LogLevel.ERROR: BRIGHT_RED,
+        LogLevel.CRITICAL: BRIGHT_RED + BOLD,
+        LogLevel.NOTSET: WHITE
+    }
+
+    # Add style combinations
+    STYLES = {
+        "bold": "\033[1m",
+        "dim": "\033[2m",
+        "italic": "\033[3m",
+        "underline": "\033[4m",
+        "blink": "\033[5m",
+        "reverse": "\033[7m",
+        "hidden": "\033[8m",
+        "strike": "\033[9m",
+    }
+
+    @staticmethod
+    def rgb(r: int, g: int, b: int, background: bool = False) -> str:
+        """Create RGB color code."""
+        if background:
+            return f"\033[48;2;{r};{g};{b}m"
+        return f"\033[38;2;{r};{g};{b}m"
+
+    @staticmethod
+    def color_256(code: int, background: bool = False) -> str:
+        """Create 256-color code."""
+        if background:
+            return f"\033[48;5;{code}m"
+        return f"\033[38;5;{code}m"
+
+    @staticmethod
+    def combine(*colors):
+        return "".join(colors)
+
+    @staticmethod
+    def gradient(text: str, start_rgb: tuple, end_rgb: tuple) -> str:
+        """Create a gradient effect across text."""
+        if len(text) < 2:
+            return LogColors.rgb(*start_rgb) + text
+            
+        result = []
+        for i, char in enumerate(text):
+            r = int(start_rgb[0] + (end_rgb[0] - start_rgb[0]) * i / (len(text) - 1))
+            g = int(start_rgb[1] + (end_rgb[1] - start_rgb[1]) * i / (len(text) - 1))
+            b = int(start_rgb[2] + (end_rgb[2] - start_rgb[2]) * i / (len(text) - 1))
+            result.append(f"{LogColors.rgb(r, g, b)}{char}")
+            
+        return "".join(result) + LogColors.RESET
+
+    @staticmethod
+    def rainbow(text: str) -> str:
+        """Apply rainbow colors to text."""
+        colors = [
+            (255, 0, 0),    # Red
+            (255, 127, 0),  # Orange
+            (255, 255, 0),  # Yellow
+            (0, 255, 0),    # Green
+            (0, 0, 255),    # Blue
+            (75, 0, 130),   # Indigo
+            (148, 0, 211)   # Violet
+        ]
+        
+        result = []
+        for i, char in enumerate(text):
+            color = colors[i % len(colors)]
+            result.append(f"{LogColors.rgb(*color)}{char}")
+            
+        return "".join(result) + LogColors.RESET
+
+    @staticmethod
+    def animate(text: str, effect: str = "blink") -> str:
+        """Apply animation effects to text."""
+        effects = {
+            "blink": LogColors.BLINK,
+            "reverse": LogColors.REVERSE,
+            "bold_blink": LogColors.combine(LogColors.BOLD, LogColors.BLINK),
+            "frame_blink": LogColors.combine(LogColors.FRAME, LogColors.BLINK),
+            "encircle_blink": LogColors.combine(LogColors.ENCIRCLE, LogColors.BLINK)
+        }
+        return effects.get(effect, LogColors.BLINK) + text + LogColors.RESET
+
+    @staticmethod
+    def style_text(text: str, *styles: str, color: Optional[str] = None) -> str:
+        """Apply multiple styles and color to text."""
+        style_codes = "".join(LogColors.STYLES.get(style, "") for style in styles)
+        color_code = color if color else ""
+        return f"{style_codes}{color_code}{text}{LogColors.RESET}"
+
+    @staticmethod
+    def level_style(level: LogLevel, text: str) -> str:
+        """Style text according to log level with enhanced formatting."""
+        color = LogColors.LEVEL_COLORS.get(level, LogColors.RESET)
+        
+        # Apply appropriate styling based on level
+        if level == LogLevel.CRITICAL:
+            return f"{color}{LogColors.STYLES['bold']}{text}{LogColors.RESET}"
+        elif level == LogLevel.ERROR:
+            return f"{color}{text}{LogColors.RESET}"
+        elif level == LogLevel.WARNING:
+            return f"{color}{text}{LogColors.RESET}"
+        else:
+            return f"{color}{text}{LogColors.RESET}"
+
+
+class LogTheme:
+    """Pre-defined color themes and combinations."""
+    
+    @staticmethod
+    def get_theme(name: str) -> str:
+        themes = {
+            # Status themes
+            "success": LogColors.combine(LogColors.BRIGHT_GREEN, LogColors.BOLD),
+            "error": LogColors.combine(LogColors.BRIGHT_RED, LogColors.BOLD),
+            "warning": LogColors.combine(LogColors.BRIGHT_YELLOW, LogColors.BOLD),
+            "info": LogColors.combine(LogColors.BRIGHT_BLUE, LogColors.BOLD),
+            "debug": LogColors.combine(LogColors.DIM, LogColors.WHITE),
+            "critical": LogColors.combine(LogColors.BG_RED, LogColors.WHITE, LogColors.BOLD),
+            
+            # Special themes
+            "header": LogColors.combine(LogColors.BRIGHT_WHITE, LogColors.BOLD, LogColors.UNDERLINE),
+            "highlight": LogColors.combine(LogColors.BLACK, LogColors.BG_BRIGHT_YELLOW),
+            "important": LogColors.combine(LogColors.BRIGHT_RED, LogColors.BOLD, LogColors.UNDERLINE),
+            "subtle": LogColors.combine(LogColors.DIM, LogColors.BRIGHT_BLACK),
+            
+            # UI themes
+            "title": LogColors.combine(LogColors.BRIGHT_WHITE, LogColors.BOLD, LogColors.UNDERLINE),
+            "subtitle": LogColors.combine(LogColors.BRIGHT_WHITE, LogColors.DIM),
+            "link": LogColors.combine(LogColors.BLUE, LogColors.UNDERLINE),
+            "code": LogColors.combine(LogColors.BRIGHT_BLACK, LogColors.BG_WHITE),
+            
+            # Data themes
+            "number": LogColors.combine(LogColors.BRIGHT_CYAN, LogColors.BOLD),
+            "string": LogColors.combine(LogColors.BRIGHT_GREEN),
+            "boolean": LogColors.combine(LogColors.BRIGHT_YELLOW, LogColors.BOLD),
+            "null": LogColors.combine(LogColors.DIM, LogColors.ITALIC),
+            
+            # Custom themes
+            "fire": LogColors.combine(LogColors.FIRE, LogColors.BOLD),
+            "ice": LogColors.combine(LogColors.ICE, LogColors.BOLD),
+            "nature": LogColors.combine(LogColors.GRASS, LogColors.BOLD),
+            "royal": LogColors.combine(LogColors.PURPLE, LogColors.BOLD),
+            "precious": LogColors.combine(LogColors.GOLD, LogColors.BOLD),
+            
+            # Gradient themes
+            "sunset": LogColors.combine(LogColors.SUNSET_START, LogColors.SUNSET_END),
+            "ocean": LogColors.combine(LogColors.OCEAN_START, LogColors.OCEAN_END),
+            "forest": LogColors.combine(LogColors.FOREST_START, LogColors.FOREST_END),
+        }
+        return themes.get(name, LogColors.RESET)
+
+
+# Define level colors after both classes are defined
+LogColors.LEVEL_COLORS = {
+    "DEBUG": LogTheme.get_theme("debug"),
+    "INFO": LogTheme.get_theme("info"),
+    "WARNING": LogTheme.get_theme("warning"),
+    "ERROR": LogTheme.get_theme("error"),
+    "CRITICAL": LogTheme.get_theme("critical")
+}