webscout 7.2__py3-none-any.whl → 7.3__py3-none-any.whl

webscout/Bard.py

@@ -16,7 +16,7 @@ import httpx
 from httpx import AsyncClient, HTTPStatusError
 
 # For image models using validation. Adjust based on organization internal pydantic.
-from pydantic import BaseModel, field_validator
+from pydantic import BaseModel, validator
 
 # Rich is retained for logging within image methods.
 from rich.console import Console
@@ -463,7 +463,7 @@ class GeneratedImage(Image):
     """
     cookies: Dict[str, str]
 
-    @field_validator("cookies")
+    @validator("cookies")
     def validate_cookies(cls, v):
         if not v:
             raise ValueError("GeneratedImage requires cookies from GeminiClient.")

webscout/Litlogger/core/level.py

@@ -1,6 +1,7 @@
 from enum import Enum
 
 class LogLevel(Enum):
+    NOTSET = 0
     DEBUG = 10
     INFO = 20
     WARNING = 30
@@ -9,6 +10,8 @@ class LogLevel(Enum):
 
     @staticmethod
     def get_level(level_str: str) -> 'LogLevel':
+        if not level_str:
+            return LogLevel.NOTSET
         try:
             return LogLevel[level_str.upper()]
         except KeyError:

webscout/Litlogger/core/logger.py

@@ -1,12 +1,14 @@
 
 import asyncio
-import json
+import sys
+import threading
+import traceback
 from datetime import datetime
 from typing import Any, Dict, List, Optional, Union
 
-from ..styles.colors import LogColors
+from ..core.level import LogLevel
 from ..styles.formats import LogFormat
-from .level import LogLevel
+from ..styles.colors import LogColors
 
 class Logger:
     # Emoji mappings for different log levels
@@ -21,91 +23,125 @@ class Logger:
     def __init__(
         self,
         name: str = "LitLogger",
-        level: Union[str, LogLevel] = LogLevel.INFO,
-        format: str = LogFormat.MODERN,
+        level: Union[str, LogLevel, None] = None,
+        format: Union[str, LogFormat] = LogFormat.MODERN_EMOJI,
         handlers: List = None,
         enable_colors: bool = True,
-        async_mode: bool = False
+        async_mode: bool = False,
+        show_thread: bool = True,
+        show_context: bool = True
     ):
         self.name = name
-        self.level = LogLevel.get_level(level) if isinstance(level, str) else level
+        self.level = LogLevel.NOTSET if level is None else (
+            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.show_thread = show_thread
+        self.show_context = show_context
         self._context_data = {}
-        self._metrics = {}
+        
+        # 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("%Y-%m-%d %H:%M:%S"),
-            "time": now.strftime("%H:%M:%S"),  # Add time field
-            "date": now.strftime("%Y-%m-%d"),  # Add date field
+            "timestamp": now.strftime("%H:%M:%S"),
             "level": level.name,
             "name": self.name,
-            "message": message,
-            "emoji": self.LEVEL_EMOJIS.get(level, ""),
-            **self._context_data,
-            **kwargs
+            "message": str(message),
+            "emoji": emoji,
+            "thread": threading.current_thread().name if self.show_thread else "",
         }
-
-        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)
+        # Add context data
+        if self.show_context and self._context_data:
+            log_data.update(self._context_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))
+        # Add extra kwargs
+        log_data.update(kwargs)
         
-        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)
+        # 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):
+    def _log(self, level: LogLevel, message: str, **kwargs):
         if self.async_mode:
-            return asyncio.create_task(self._async_log(level, message, **kwargs))
+            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)
+        self._log(LogLevel.DEBUG, message, **kwargs)
 
     def info(self, message: str, **kwargs):
-        self.log(LogLevel.INFO, message, **kwargs)
+        self._log(LogLevel.INFO, message, **kwargs)
 
     def warning(self, message: str, **kwargs):
-        self.log(LogLevel.WARNING, message, **kwargs)
+        self._log(LogLevel.WARNING, message, **kwargs)
 
     def error(self, message: str, **kwargs):
-        self.log(LogLevel.ERROR, message, **kwargs)
+        self._log(LogLevel.ERROR, message, **kwargs)
 
     def critical(self, message: str, **kwargs):
-        self.log(LogLevel.CRITICAL, message, **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)
@@ -113,6 +149,13 @@ class Logger:
     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
 
@@ -120,4 +163,4 @@ class Logger:
         if exc_type is not None:
             self.error(f"Context exited with error: {exc_val}")
             return False
-        return True
+        return True

webscout/Litlogger/handlers/console.py

@@ -1,40 +1,23 @@
 import sys
-from typing import Optional, TextIO
 from ..core.level import LogLevel
+from ..styles.colors import LogColors
 
 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
+    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 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()
+        """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):
         """

webscout/Litlogger/handlers/network.py

@@ -125,25 +125,24 @@ class NetworkHandler:
             
     async def async_emit(self, message: str, level: LogLevel):
         """Asynchronously send log message to remote server."""
-        if level.value < self.level.value:
-            return
+        # 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
+            }
             
-        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)
+            if self.batch_size > 0:
+                self._batch.append(log_data)
+                if len(self._batch) >= self.batch_size:
+                    await self._send_batch()
             else:
-                await self._send_tcp(log_data)
-                
+                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:

webscout/Litlogger/styles/colors.py

@@ -1,6 +1,10 @@
 # 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:
@@ -10,7 +14,10 @@ class LogColors:
     - Gradients and animations
     - Predefined themes
     """
-    # Basic foreground colors
+    # Reset
+    RESET = "\033[0m"
+    
+    # Regular colors
     BLACK = "\033[30m"
     RED = "\033[31m"
     GREEN = "\033[32m"
@@ -19,9 +26,8 @@ class LogColors:
     MAGENTA = "\033[35m"
     CYAN = "\033[36m"
     WHITE = "\033[37m"
-    RESET = "\033[0m"
-
-    # Basic background colors
+    
+    # Background colors
     BG_BLACK = "\033[40m"
     BG_RED = "\033[41m"
     BG_GREEN = "\033[42m"
@@ -30,8 +36,8 @@ class LogColors:
     BG_MAGENTA = "\033[45m"
     BG_CYAN = "\033[46m"
     BG_WHITE = "\033[47m"
-
-    # Bright foreground colors
+    
+    # Bright colors
     BRIGHT_BLACK = "\033[90m"
     BRIGHT_RED = "\033[91m"
     BRIGHT_GREEN = "\033[92m"
@@ -40,7 +46,7 @@ class LogColors:
     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"
@@ -50,62 +56,53 @@ class LogColors:
     BG_BRIGHT_MAGENTA = "\033[105m"
     BG_BRIGHT_CYAN = "\033[106m"
     BG_BRIGHT_WHITE = "\033[107m"
-
-    # Text styles
+    
+    # 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"
-    BLINK = "\033[5m"
-    REVERSE = "\033[7m"
-    HIDDEN = "\033[8m"
-    STRIKE = "\033[9m"
-    DOUBLE_UNDERLINE = "\033[21m"
-
-    # Special effects
-    FRAME = "\033[51m"
-    ENCIRCLE = "\033[52m"
-    OVERLINE = "\033[53m"
-
-    # Extended color combinations
-    FIRE = "\033[38;2;255;100;0m"
-    ICE = "\033[38;2;150;230;255m"
-    GRASS = "\033[38;2;0;200;0m"
-    PURPLE = "\033[38;2;160;32;240m"
-    GOLD = "\033[38;2;255;215;0m"
-    SILVER = "\033[38;2;192;192;192m"
-    BRONZE = "\033[38;2;205;127;50m"
-    PINK = "\033[38;2;255;192;203m"
-    TEAL = "\033[38;2;0;128;128m"
-    ORANGE = "\033[38;2;255;165;0m"
-    BROWN = "\033[38;2;165;42;42m"
-    MAROON = "\033[38;2;128;0;0m"
-    NAVY = "\033[38;2;0;0;128m"
-    OLIVE = "\033[38;2;128;128;0m"
-
-    # Gradient colors
-    SUNSET_START = "\033[38;2;255;128;0m"
-    SUNSET_END = "\033[38;2;255;0;128m"
-    OCEAN_START = "\033[38;2;0;255;255m"
-    OCEAN_END = "\033[38;2;0;0;255m"
-    FOREST_START = "\033[38;2;34;139;34m"
-    FOREST_END = "\033[38;2;0;100;0m"
-
-    # Special background combinations
-    BG_FIRE = "\033[48;2;255;100;0m"
-    BG_ICE = "\033[48;2;150;230;255m"
-    BG_GRASS = "\033[48;2;0;200;0m"
-    BG_PURPLE = "\033[48;2;160;32;240m"
-    BG_GOLD = "\033[48;2;255;215;0m"
-    BG_SILVER = "\033[48;2;192;192;192m"
-    BG_BRONZE = "\033[48;2;205;127;50m"
-    BG_PINK = "\033[48;2;255;192;203m"
-    BG_TEAL = "\033[48;2;0;128;128m"
-    BG_ORANGE = "\033[48;2;255;165;0m"
-    BG_BROWN = "\033[48;2;165;42;42m"
-    BG_MAROON = "\033[48;2;128;0;0m"
-    BG_NAVY = "\033[48;2;0;0;128m"
-    BG_OLIVE = "\033[48;2;128;128;0m"
+    
+    # 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:
@@ -122,9 +119,8 @@ class LogColors:
         return f"\033[38;5;{code}m"
 
     @staticmethod
-    def combine(*styles: str) -> str:
-        """Combine multiple color and style codes."""
-        return "".join(styles)
+    def combine(*colors):
+        return "".join(colors)
 
     @staticmethod
     def gradient(text: str, start_rgb: tuple, end_rgb: tuple) -> str:
@@ -173,6 +169,28 @@ class LogColors:
         }
         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."""
@@ -228,4 +246,4 @@ LogColors.LEVEL_COLORS = {
     "WARNING": LogTheme.get_theme("warning"),
     "ERROR": LogTheme.get_theme("error"),
     "CRITICAL": LogTheme.get_theme("critical")
-}
+}