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

webscout/Litlogger/handlers/file.py

@@ -1,143 +0,0 @@
-import os
-import time
-from datetime import datetime
-from pathlib import Path
-from typing import 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

@@ -1,173 +0,0 @@
-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

@@ -1,7 +0,0 @@
-"""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

@@ -1,249 +0,0 @@
-# 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")
-}