webscout 7.0__py3-none-any.whl → 7.2__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,20 @@
+from enum import Enum
+
+class LogLevel(Enum):
+    DEBUG = 10
+    INFO = 20
+    WARNING = 30
+    ERROR = 40
+    CRITICAL = 50
+
+    @staticmethod
+    def get_level(level_str: str) -> 'LogLevel':
+        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,123 @@
+
+import asyncio
+import json
+from datetime import datetime
+from typing import Any, Dict, List, Optional, Union
+
+from ..styles.colors import LogColors
+from ..styles.formats import LogFormat
+from .level import LogLevel
+
+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] = LogLevel.INFO,
+        format: str = LogFormat.MODERN,
+        handlers: List = None,
+        enable_colors: bool = True,
+        async_mode: bool = False
+    ):
+        self.name = name
+        self.level = LogLevel.get_level(level) if isinstance(level, str) else level
+        self.format = format
+        self.handlers = handlers or []
+        self.enable_colors = enable_colors
+        self.async_mode = async_mode
+        self._context_data = {}
+        self._metrics = {}
+
+    def _format_message(self, level: LogLevel, message: str, **kwargs) -> str:
+        now = datetime.now()
+        log_data = {
+            "timestamp": now.strftime("%Y-%m-%d %H:%M:%S"),
+            "time": now.strftime("%H:%M:%S"),  # Add time field
+            "date": now.strftime("%Y-%m-%d"),  # Add date field
+            "level": level.name,
+            "name": self.name,
+            "message": message,
+            "emoji": self.LEVEL_EMOJIS.get(level, ""),
+            **self._context_data,
+            **kwargs
+        }
+
+        if self.format == LogFormat.JSON:
+            return json.dumps(log_data)
+        
+        try:
+            formatted = self.format.format(**log_data)
+        except KeyError as e:
+            # Fallback to a basic format if the specified format fails
+            basic_format = "[{time}] {level}: {message}"
+            formatted = basic_format.format(**log_data)
+        
+        if self.enable_colors:
+            color = LogColors.LEVEL_COLORS.get(level, LogColors.RESET)
+            return f"{color}{formatted}{LogColors.RESET}"
+        return formatted
+
+    async def _async_log(self, level: LogLevel, message: str, **kwargs):
+        if level.value < self.level.value:
+            return
+
+        formatted_message = self._format_message(level, message, **kwargs)
+        tasks = []
+        for handler in self.handlers:
+            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 _sync_log(self, level: LogLevel, message: str, **kwargs):
+        if level.value < self.level.value:
+            return
+
+        formatted_message = self._format_message(level, message, **kwargs)
+        for handler in self.handlers:
+            handler.emit(formatted_message, level)
+
+    def log(self, level: LogLevel, message: str, **kwargs):
+        if self.async_mode:
+            return asyncio.create_task(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 set_context(self, **kwargs):
+        self._context_data.update(kwargs)
+
+    def clear_context(self):
+        self._context_data.clear()
+
+    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,50 @@
+import sys
+from typing import Optional, TextIO
+from ..core.level import LogLevel
+
+class ConsoleHandler:
+    """Handler for outputting log messages to the console."""
+    
+    def __init__(self, 
+                 stream: Optional[TextIO] = None,
+                 level: LogLevel = LogLevel.DEBUG):
+        """
+        Initialize console handler.
+        
+        Args:
+            stream: Output stream (defaults to sys.stdout)
+            level: Minimum log level to output
+        """
+        self.stream = stream or sys.stdout
+        self.level = level
+        
+    def emit(self, message: str, level: LogLevel):
+        """
+        Write log message to console if level is sufficient.
+        
+        Args:
+            message: Formatted log message
+            level: Message log level
+        """
+        if level.value >= self.level.value:
+            try:
+                self.stream.write(message + "\n")
+                self.stream.flush()
+            except Exception as e:
+                # Fallback to stderr on error
+                sys.stderr.write(f"Error in ConsoleHandler: {e}\n")
+                sys.stderr.write(message + "\n")
+                sys.stderr.flush()
+
+    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,174 @@
+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."""
+        if level.value < self.level.value:
+            return
+            
+        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"]