webscout 8.2.2__py3-none-any.whl → 2026.1.19__py3-none-any.whl

webscout/Litlogger/styles/text.py

@@ -1,87 +0,0 @@
-import textwrap
-from typing import Optional
-
-class TextStyle:
-    @staticmethod
-    def wrap(text: str, width: int = 80, indent: str = "") -> str:
-        """Wrap text to specified width with optional indentation."""
-        return textwrap.fill(text, width=width, initial_indent=indent, 
-                           subsequent_indent=indent)
-
-    @staticmethod
-    def truncate(text: str, max_length: int, suffix: str = "...") -> str:
-        """Truncate text to maximum length with suffix."""
-        if len(text) <= max_length:
-            return text
-        return text[:max_length - len(suffix)] + suffix
-
-    @staticmethod
-    def pad(text: str, width: int, align: str = "left", 
-           fill_char: str = " ") -> str:
-        """Pad text to specified width with alignment."""
-        if align == "left":
-            return text.ljust(width, fill_char)
-        elif align == "right":
-            return text.rjust(width, fill_char)
-        elif align == "center":
-            return text.center(width, fill_char)
-        raise ValueError(f"Invalid alignment: {align}")
-
-    @staticmethod
-    def indent(text: str, prefix: str = "  ", predicate: Optional[callable] = None) -> str:
-        """Indent text lines with prefix based on optional predicate."""
-        lines = text.splitlines(True)
-        if predicate is None:
-            predicate = bool
-        
-        def should_indent(line):
-            return predicate(line)
-
-        return "".join(prefix + line if should_indent(line) else line
-                      for line in lines)
-
-    @staticmethod
-    def highlight(text: str, substring: str, color: str) -> str:
-        """Highlight substring within text using ANSI color codes."""
-        from ..styles.colors import LogColors
-        if not substring:
-            return text
-        
-        parts = text.split(substring)
-        highlighted = f"{color}{substring}{LogColors.RESET}"
-        return highlighted.join(parts)
-
-    @staticmethod
-    def table(headers: list, rows: list, padding: int = 1) -> str:
-        """Create a formatted table with headers and rows."""
-        if not rows:
-            return ""
-            
-        # Calculate column widths
-        widths = [max(len(str(row[i])) for row in [headers] + rows)
-                 for i in range(len(headers))]
-        
-        # Create separator line
-        separator = "+" + "+".join("-" * (w + 2 * padding) for w in widths) + "+"
-        
-        # Format header
-        header = "|" + "|".join(
-            str(h).center(w + 2 * padding) for h, w in zip(headers, widths)
-        ) + "|"
-        
-        # Format rows
-        formatted_rows = []
-        for row in rows:
-            formatted_row = "|" + "|".join(
-                str(cell).ljust(w + 2 * padding) for cell, w in zip(row, widths)
-            ) + "|"
-            formatted_rows.append(formatted_row)
-        
-        # Combine all parts
-        return "\n".join([
-            separator,
-            header,
-            separator,
-            *formatted_rows,
-            separator
-        ])

webscout/Litlogger/utils/__init__.py

@@ -1,6 +0,0 @@
-"""Utility functions for log level detection and message formatting."""
-
-from .detectors import LevelDetector
-from .formatters import MessageFormatter
-
-__all__ = ["LevelDetector", "MessageFormatter"]

webscout/Litlogger/utils/detectors.py

@@ -1,153 +0,0 @@
-import re
-import sys
-from typing import Optional
-from ..core.level import LogLevel
-
-class LevelDetector:
-    """Utility class for intelligent log level detection."""
-    
-    # Common patterns indicating error conditions
-    ERROR_PATTERNS = [
-        r"error",
-        r"exception",
-        r"failed",
-        r"failure",
-        r"traceback",
-        r"crash",
-        r"fatal",
-    ]
-    
-    # Common patterns indicating warning conditions
-    WARNING_PATTERNS = [
-        r"warning",
-        r"warn",
-        r"deprecated",
-        r"might",
-        r"consider",
-        r"attention",
-    ]
-    
-    # Common patterns indicating debug information
-    DEBUG_PATTERNS = [
-        r"debug",
-        r"trace",
-        r"verbose",
-        r"detail",
-    ]
-    
-    @classmethod
-    def detect_level(cls, message: str, exception: Optional[Exception] = None) -> LogLevel:
-        """
-        Detect appropriate log level from message content and context.
-        
-        Args:
-            message: Log message to analyze
-            exception: Optional exception object
-            
-        Returns:
-            Detected LogLevel
-        """
-        # If there's an exception, it's at least ERROR
-        if exception is not None:
-            if isinstance(exception, (SystemExit, KeyboardInterrupt)):
-                return LogLevel.CRITICAL
-            return LogLevel.ERROR
-            
-        # Convert to lowercase for pattern matching
-        message_lower = message.lower()
-        
-        # Check for error patterns
-        for pattern in cls.ERROR_PATTERNS:
-            if re.search(pattern, message_lower):
-                return LogLevel.ERROR
-                
-        # Check for warning patterns
-        for pattern in cls.WARNING_PATTERNS:
-            if re.search(pattern, message_lower):
-                return LogLevel.WARNING
-                
-        # Check for debug patterns
-        for pattern in cls.DEBUG_PATTERNS:
-            if re.search(pattern, message_lower):
-                return LogLevel.DEBUG
-                
-        # Default to INFO
-        return LogLevel.INFO
-        
-    @classmethod
-    def detect_level_from_exception(cls, exc_type, exc_value, exc_tb) -> LogLevel:
-        """
-        Detect log level from exception information.
-        
-        Args:
-            exc_type: Exception type
-            exc_value: Exception value
-            exc_tb: Exception traceback
-            
-        Returns:
-            Detected LogLevel
-        """
-        # Critical errors that should terminate execution
-        if exc_type in (SystemExit, KeyboardInterrupt, MemoryError):
-            return LogLevel.CRITICAL
-            
-        # Built-in exceptions that indicate programming errors
-        if exc_type in (
-            SyntaxError,
-            IndentationError,
-            NameError,
-            TypeError,
-            AttributeError
-        ):
-            return LogLevel.ERROR
-            
-        # Runtime errors that might be recoverable
-        if exc_type in (
-            ValueError,
-            KeyError,
-            IOError,
-            OSError,
-            ConnectionError
-        ):
-            return LogLevel.WARNING
-            
-        # Default to ERROR for unknown exception types
-        return LogLevel.ERROR
-
-    @classmethod
-    def detect_level_from_frame(cls, frame_depth: int = 1) -> LogLevel:
-        """
-        Detect log level by analyzing the call stack.
-        
-        Args:
-            frame_depth: How many frames up to look (1 = caller's frame)
-            
-        Returns:
-            Detected LogLevel
-        """
-        try:
-            frame = sys._getframe(frame_depth)
-            
-            # Check function/method name
-            code = frame.f_code
-            func_name = code.co_name.lower()
-            
-            if any(p in func_name for p in ["error", "fail", "crash"]):
-                return LogLevel.ERROR
-            if any(p in func_name for p in ["warn"]):
-                return LogLevel.WARNING
-            if any(p in func_name for p in ["debug", "trace"]):
-                return LogLevel.DEBUG
-                
-            # Check local variables for exceptions
-            locals_dict = frame.f_locals
-            for value in locals_dict.values():
-                if isinstance(value, Exception):
-                    return cls.detect_level_from_exception(
-                        type(value), value, value.__traceback__
-                    )
-                    
-            return LogLevel.INFO
-            
-        except Exception:
-            return LogLevel.INFO  # Default if detection fails

webscout/Litlogger/utils/formatters.py

@@ -1,200 +0,0 @@
-import json
-import re
-import traceback
-from datetime import datetime
-from typing import Any, Dict, Optional, Union
-
-class MessageFormatter:
-    """Utility class for formatting log messages."""
-    
-    @staticmethod
-    def format_exception(exc_info: tuple) -> str:
-        """
-        Format exception information into a readable string.
-        
-        Args:
-            exc_info: Tuple of (type, value, traceback)
-            
-        Returns:
-            Formatted exception string
-        """
-        return "".join(traceback.format_exception(*exc_info))
-
-    @staticmethod
-    def format_dict(data: Dict[str, Any], indent: int = 2) -> str:
-        """
-        Format dictionary into pretty-printed string.
-        
-        Args:
-            data: Dictionary to format
-            indent: Number of spaces for indentation
-            
-        Returns:
-            Formatted string representation
-        """
-        return json.dumps(data, indent=indent, default=str, ensure_ascii=False)
-
-    @staticmethod
-    def format_object(obj: Any) -> str:
-        """
-        Format any object into a string representation.
-        
-        Args:
-            obj: Object to format
-            
-        Returns:
-            String representation of object
-        """
-        if hasattr(obj, "to_dict"):
-            return MessageFormatter.format_dict(obj.to_dict())
-        if hasattr(obj, "__dict__"):
-            return MessageFormatter.format_dict(obj.__dict__)
-        return str(obj)
-
-    @staticmethod
-    def truncate(message: str, max_length: int = 1000, suffix: str = "...") -> str:
-        """
-        Truncate message to maximum length.
-        
-        Args:
-            message: Message to truncate
-            max_length: Maximum length
-            suffix: String to append when truncated
-            
-        Returns:
-            Truncated message
-        """
-        if len(message) <= max_length:
-            return message
-        return message[:max_length - len(suffix)] + suffix
-
-    @staticmethod
-    def mask_sensitive(message: str, patterns: Dict[str, str]) -> str:
-        """
-        Mask sensitive information in message.
-        
-        Args:
-            message: Message to process
-            patterns: Dictionary of {pattern: mask}
-            
-        Returns:
-            Message with sensitive info masked
-        """
-        result = message
-        for pattern, mask in patterns.items():
-            result = re.sub(pattern, mask, result)
-        return result
-
-    @staticmethod
-    def format_context(context: Dict[str, Any]) -> str:
-        """
-        Format context dictionary into readable string.
-        
-        Args:
-            context: Context dictionary
-            
-        Returns:
-            Formatted context string
-        """
-        parts = []
-        for key, value in sorted(context.items()):
-            formatted_value = (
-                MessageFormatter.format_object(value)
-                if isinstance(value, (dict, list, tuple))
-                else str(value)
-            )
-            parts.append(f"{key}={formatted_value}")
-        return " ".join(parts)
-
-    @staticmethod
-    def format_metrics(metrics: Dict[str, Union[int, float]]) -> str:
-        """
-        Format performance metrics into readable string.
-        
-        Args:
-            metrics: Dictionary of metric names and values
-            
-        Returns:
-            Formatted metrics string
-        """
-        parts = []
-        for key, value in sorted(metrics.items()):
-            if isinstance(value, float):
-                formatted = f"{value:.3f}"
-            else:
-                formatted = str(value)
-            parts.append(f"{key}={formatted}")
-        return " ".join(parts)
-
-    @staticmethod
-    def format_timestamp(
-        timestamp: Optional[datetime] = None,
-        format: str = "%Y-%m-%d %H:%M:%S.%f"
-    ) -> str:
-        """
-        Format timestamp into string.
-        
-        Args:
-            timestamp: Datetime object (uses current time if None)
-            format: strftime format string
-            
-        Returns:
-            Formatted timestamp string
-        """
-        if timestamp is None:
-            timestamp = datetime.now()
-        return timestamp.strftime(format)
-
-    @classmethod
-    def format_message(
-        cls,
-        message: str,
-        context: Optional[Dict[str, Any]] = None,
-        metrics: Optional[Dict[str, Union[int, float]]] = None,
-        max_length: Optional[int] = None,
-        mask_patterns: Optional[Dict[str, str]] = None,
-        timestamp_format: Optional[str] = None
-    ) -> str:
-        """
-        Format complete log message with all options.
-        
-        Args:
-            message: Base message
-            context: Optional context dictionary
-            metrics: Optional performance metrics
-            max_length: Optional maximum length
-            mask_patterns: Optional sensitive data patterns
-            timestamp_format: Optional timestamp format
-            
-        Returns:
-            Formatted complete message
-        """
-        parts = []
-        
-        # Add timestamp
-        if timestamp_format:
-            parts.append(cls.format_timestamp(format=timestamp_format))
-            
-        # Add main message
-        parts.append(message)
-        
-        # Add context if present
-        if context:
-            parts.append(cls.format_context(context))
-            
-        # Add metrics if present
-        if metrics:
-            parts.append(cls.format_metrics(metrics))
-            
-        # Join all parts
-        result = " ".join(parts)
-        
-        # Apply masking if needed
-        if mask_patterns:
-            result = cls.mask_sensitive(result, mask_patterns)
-            
-        # Apply length limit if needed
-        if max_length:
-            result = cls.truncate(result, max_length)
-            
-        return result

webscout/Local/__init__.py

@@ -1,12 +0,0 @@
-"""
-Webscout.Local - A llama-cpp-python based LLM serving tool with Ollama-compatible API
-"""
-from webscout.version import __version__
-
-# Import main components for easier access
-from .llm import LLMInterface
-from .model_manager import ModelManager
-from .server import start_server
-
-# Define what's available when using `from webscout.Local import *`
-__all__ = ["LLMInterface", "ModelManager", "start_server"]

webscout/Local/__main__.py

@@ -1,9 +0,0 @@
-"""
-Entry point for running webscout.Local as a module.
-This allows running the CLI using 'python -m webscout.Local'.
-"""
-
-from webscout.Local.cli import app
-
-if __name__ == "__main__":
-    app()