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

webscout/Litlogger/Readme.md

@@ -1,175 +0,0 @@
-# 📝 LitLogger - The Most Fire Logger You'll Ever Use! 
-
-Yo fam! Meet LitLogger - your new logging bestie that's built different! 🔥 With smart level detection, fire color schemes, and emoji support, your logs never looked this good!
-
-## 🚀 Quick Start
-
-```python
-from webscout import LitLogger, LogFormat, ColorScheme
-
-# Create your logger with style
-logger = LitLogger(
-    name="MyApp",
-    format=LogFormat.MODERN_EMOJI,
-    color_scheme=ColorScheme.CYBERPUNK
-)
-
-# Start logging with swag
-logger.info("App started! 🚀")
-logger.success("Mission accomplished! 💯")
-logger.warning("CPU getting spicy! 🌶️")
-logger.error("Houston, we got a problem! 🔧")
-```
-
-## 💫 Features That Hit Different
-
-### 🎨 Fire Color Schemes
-
-```python
-# Cyberpunk vibes
-logger = LitLogger(color_scheme=ColorScheme.CYBERPUNK)
-
-# Ocean feels
-logger = LitLogger(color_scheme=ColorScheme.OCEAN)
-
-# Matrix mode
-logger = LitLogger(color_scheme=ColorScheme.MATRIX)
-
-# Aurora lights
-logger = LitLogger(color_scheme=ColorScheme.AURORA)
-
-# Sunset mood
-logger = LitLogger(color_scheme=ColorScheme.SUNSET)
-```
-
-### 📝 Lit Log Formats
-
-```python
-# Modern with emojis
-logger = LitLogger(format=LogFormat.MODERN_EMOJI)
-# Output: 🚀 [2024-01-20 15:30:45] INFO Server started!
-
-# Clean and minimal
-logger = LitLogger(format=LogFormat.MODERN_CLEAN)
-# Output: 2024-01-20 15:30:45 INFO Server started
-
-# Boxed style
-logger = LitLogger(format=LogFormat.BOXED)
-# Output: ╭─────────────────────╮
-#        │ [2024-01-20 15:30:45]
-#        │ INFO - MyApp
-#        │ Server started!
-#        ╰─────────────────────╯
-
-# Japanese style
-logger = LitLogger(format=LogFormat.MODERN_BRACKET)
-# Output: 【2024-01-20 15:30:45】「INFO」Server started
-```
-
-### 🧠 Smart Level Detection
-
-```python
-# Auto-detects appropriate log level
-logger.auto("Starting server...")  # INFO
-logger.auto("CPU usage at 95%")   # WARNING
-logger.auto("404: Not Found")     # ERROR
-logger.auto("x = calculate(y)")   # DEBUG
-
-# With context
-logger.auto("Memory usage: 90%", memory=90)  # WARNING
-logger.auto("Response time: 1500ms", latency=1500)  # WARNING
-```
-
-### 🎯 Log Levels
-
-```python
-# All the levels you need
-logger.trace("Entering function...")
-logger.debug("x = 42")
-logger.info("Server started")
-logger.success("Task completed")
-logger.warning("Running low on memory")
-logger.error("Failed to connect")
-logger.critical("System crash!")
-```
-
-## 🌟 Real-World Examples
-
-### API Server Logging
-
-```python
-logger = LitLogger(name="APIServer", format=LogFormat.MODERN_EMOJI)
-
-def handle_request():
-    logger.info("Received new request 📥")
-    try:
-        # Process request
-        logger.success("Request processed successfully ✨")
-    except Exception as e:
-        logger.error(f"Request failed: {e} 💀")
-```
-
-### Performance Monitoring
-
-```python
-logger = LitLogger(name="Monitor", color_scheme=ColorScheme.MATRIX)
-
-def monitor_system():
-    metrics = get_system_metrics()
-    logger.auto(
-        f"CPU: {metrics['cpu']}%, Memory: {metrics['memory']}%",
-        cpu=metrics['cpu'],
-        memory=metrics['memory']
-    )
-```
-
-### Development Debugging
-
-```python
-logger = LitLogger(name="Debug", format=LogFormat.DETAILED)
-
-def complex_calculation(x, y):
-    logger.debug(f"Input: x={x}, y={y}")
-    result = x * y
-    logger.debug(f"Result: {result}")
-    return result
-```
-
-## 🎮 Pro Tips
-
-1. **Custom Color Schemes**: Create your own vibe
-   ```python
-   my_scheme = {
-       "trace": (128, 128, 255),  # Your colors
-       "debug": (255, 0, 255),
-       "info": (0, 255, 255)
-   }
-   logger = LitLogger(color_scheme=my_scheme)
-   ```
-
-2. **Log to File**: Keep records with style
-   ```python
-   logger = LitLogger(
-       name="MyApp",
-       log_path="logs/app.log",
-       console_output=True  # Both file and console
-   )
-   ```
-
-3. **Smart Context**: Let the logger decide
-   ```python
-   # Automatically chooses log level based on content
-   logger.auto("Database connection failed")  # ERROR
-   logger.auto("Cache hit ratio: 95%")       # INFO
-   ```
-
-## 🔥 Why LitLogger?
-
-- 🎨 Beautiful, colorful output
-- 🧠 Smart level detection
-- 📱 Multiple output formats
-- 🌈 Customizable color schemes
-- 💪 Easy to use, hard to mess up
-- ⚡ Fast and lightweight
-
-Made with 💖 by the HelpingAI team

webscout/Litlogger/core/__init__.py

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

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