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

webscout/Litlogger/styles/text.py

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

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

@@ -0,0 +1,154 @@
+import re
+import sys
+import traceback
+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

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