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

webscout/Litlogger/core/level.py

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

@@ -1,165 +0,0 @@
-
-import asyncio
-import sys
-import threading
-import traceback
-from datetime import datetime
-from typing import List, Union
-
-from ..core.level import LogLevel
-from ..styles.formats import LogFormat
-
-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

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

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

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