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

webscout/Litlogger/styles/formats.py

@@ -0,0 +1,458 @@
+
+class LogFormat:
+    # Basic formats with improved styling
+    MINIMAL = "│ {time} │ {level} │ {message}"
+    STANDARD = "┌─ {time} ─┐\n│ {level} │ {name}: {message}"
+    DETAILED = """╭──────────────────────╮
+│ {time}
+│ {level} • {name}
+│ {file}:{line}
+├──────────────────────┤
+│ {message}
+╰──────────────────────╯"""
+    SIMPLE = "• {message}"
+    COMPACT = "⟦{time}⟧ {level} ⟫ {message}"
+    
+    # Modern Styles with Unicode
+    MODERN = """┌────────────────────┐
+│ {time}
+├────────────────────┤
+│ {level} • {name}
+│ {message}
+└────────────────────┘"""
+    
+    MODERN_EMOJI = """╭─ {emoji} {time} ─╮
+│ {level}
+├───────────────────
+│ {message}
+╰───────────────────"""
+    
+    MODERN_CLEAN = """• {time} •
+┌─ {level}
+└→ {message}"""
+    
+    MODERN_BRACKET = """【{time}】
+「{level}」{message}"""
+    
+    MODERN_PLUS = """⊕ {time}
+├─ {level}
+└─ {message}"""
+    
+    MODERN_DOT = """● {time}
+├● {level}
+└● {message}"""
+    
+    MODERN_ARROW = """➤ {time}
+├➤ {level}
+└➤ {message}"""
+    
+    # Boxed Styles
+    BOXED = """
+╭─────────────────────╮
+│ [{time}]
+│ {level} - {name}
+│ {message}
+╰─────────────────────╯"""
+
+    DOUBLE_BOX = """
+╔══════════════════════╗
+║ {level} @ {time}
+║ {name}
+║ {message}
+╚══════════════════════╝"""
+
+    ROUNDED_BOX = """
+╭──────────────────────╮
+│ {time} • {level}
+├──────────────────────┤
+│ {message}
+╰──────────────────────╯"""
+
+    RAINBOW_BOX = """
+ {level} - {time}
+  {name}: {message}
+"""
+
+    HEAVY_BOX = """
+┏━━━━━━━━━━━━━━━━━━━━┓
+┃ {time}
+┃ {level} | {name}
+┃ {message}
+┗━━━━━━━━━━━━━━━━━━━━┛"""
+
+    DOTTED_BOX = """
+╭┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈╮
+┊ {time} | {level}
+┊ {message}
+╰┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈╯"""
+
+    # Debug & Development
+    DEBUG = "[{time}] {level} {name} ({file}:{line}) {message}"
+    DEBUG_FULL = """
+┌─ Debug Info ─┐
+│ Time: {time}
+│ Level: {level}
+│ Name: {name}
+│ File: {file}:{line}
+│ Message: {message}
+└──────────────┘"""
+
+    TRACE = """
+ Trace Details:
+   Time: {time}
+   Level: {level}
+   Location: {file}:{line}
+   Message: {message}"""
+
+    DEBUG_COMPACT = "[DBG][{time}] {message} @{file}:{line}"
+    DEBUG_EXTENDED = """
+🔍 Debug Information 🔍
+⏰ Time: {time}
+📊 Level: {level}
+📂 File: {file}
+📍 Line: {line}
+💬 Message: {message}
+"""
+
+    # Enhanced Error Formats
+    ERROR = """╔══ ERROR ══╗
+║ Time: {time}
+║ Level: {level}
+║ Component: {name}
+╟──────────────
+║ {message}
+╚════════════╝"""
+
+    ERROR_DETAILED = """┏━━ ALERT ━━┓
+┃ Time: {time}
+┃ Level: {level}
+┃ Component: {name}
+┃ Location: {file}:{line}
+┣━━━━━━━━━━━
+┃ {message}
+┗━━━━━━━━━━━┛"""
+
+    ERROR_COMPACT = "‼ [{time}] {level}: {message}"
+    
+    ERROR_EMOJI = """❌ ERROR REPORT
+⏰ {time}
+⚠️ {level}
+📝 {message}"""
+
+    ERROR_BLOCK = """█▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀█
+█  ERROR @ {time}
+█  {level}
+█  {message}
+█▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄█"""
+
+    # Status & Progress with Better Visual Hierarchy
+    STATUS = """┌─── Status Update ───┐
+│ Time: {time}
+│ Level: {level}
+│ Component: {name}
+├───────────────────┤
+│ {message}
+└───────────────────┘"""
+
+    PROGRESS = """╭── Progress Report ──╮
+│ Time: {time}
+│ Level: {level}
+├────────────────────
+│ Component: {name}
+│ Status: {message}
+╰────────────────────"""
+
+    PROGRESS_SIMPLE = "► {time} | {level} | {message}"
+    PROGRESS_BAR = "[{progress_bar}] {percentage}% - {message}"
+    
+    # Network & API
+    HTTP = """
+API {level} [{time}]
+Endpoint: {name}
+Response: {message}"""
+
+    REQUEST = """
+→ Incoming Request
+  Time: {time}
+  Level: {level}
+  API: {name}
+  Details: {message}"""
+
+    RESPONSE = """
+← Outgoing Response
+  Time: {time}
+  Level: {level}
+  API: {name}
+  Details: {message}"""
+
+    API_COMPACT = "{method} {url} - {status_code} ({time})"
+    API_DETAILED = """┌── API Request ──┐
+│ Time: {time}
+│ Method: {method}
+│ URL: {url}
+├─────────────────
+│ Status: {status_code}
+│ {message}
+└─────────────────"""
+
+    # System & Metrics
+    SYSTEM = """┌─── System Status ───┐
+│ {time}
+├───────────────────────
+│ Component: {name}
+│ Status: {level}
+│ Message: {message}
+└───────────────────────"""
+
+    METRIC = """┌── Metrics ──┐
+│ Time: {time}
+│ Value: {value}{units}
+│ {message}
+└─────────────"""
+
+    METRIC_COMPACT = "[METRIC] {name}={value} {units}"
+    METRIC_JSON = '{{"metric":"{name}","value":{value},"time":"{time}"}}'
+    
+    # Security & Audit
+    SECURITY = """
+ Security Event 
+Time: {time}
+Level: {level}
+Source: {name}
+Event: {message}"""
+
+    AUDIT = """
+ Audit Log Entry
+Time: {time}
+Level: {level}
+Component: {name}
+Action: {message}"""
+
+    SECURITY_ALERT = """╔═══ SECURITY ALERT ═══╗
+║ Time: {time}
+║ Level: {level}
+║ Component: {name}
+╟───────────────────────
+║ {message}
+╚═══════════════════════"""
+
+    # Special Formats
+    RAINBOW = " {time}  {level}  {message}"
+    MINIMAL_EMOJI = "{emoji} {message}"
+    TIMESTAMP = "{time} {message}"
+    COMPONENT = "[{name}] {message}"
+    HASH = "#{hash} | {time} | {message}"
+    TAG = "@{tag} | {time} | {message}"
+
+    # Data Formats
+    JSON = '{{"time":"{time}","level":"{level}","name":"{name}","message":"{message}"}}'
+    JSON_PRETTY = """{
+    "timestamp": "{time}",
+    "level": "{level}",
+    "component": "{name}",
+    "message": "{message}"
+}"""
+    
+    XML = """<log>
+  <time>{time}</time>
+  <level>{level}</level>
+  <name>{name}</name>
+  <message>{message}</message>
+</log>"""
+
+    YAML = """---
+timestamp: {time}
+level: {level}
+component: {name}
+details:
+  message: {message}
+"""
+
+    # Modern Documentation Formats
+    MARKDOWN = """## Log Entry
+**Time:** `{time}`
+**Level:** `{level}`
+**Component:** `{name}`
+
+> {message}
+---"""
+
+    RST = """
+Log Entry
+=========
+:Time: {time}
+:Level: {level}
+:Component: {name}
+:Message: {message}
+"""
+
+    HTML = """<div class="log-entry">
+    <div class="log-header">
+        <span class="time">{time}</span>
+        <span class="level">{level}</span>
+    </div>
+    <div class="log-body">
+        <span class="name">{name}</span>
+        <span class="message">{message}</span>
+    </div>
+</div>"""
+
+    # Rich Console Formats
+    RICH = """╭── {name} ──╮
+│ {time} │ {level_colored}
+├──────────┴───────────
+│ {message}
+│ {context}{exception}
+╰────────────────────"""
+    
+    RICH_DETAILED = """╔══════════════════════════╗
+║ {name}                    
+╟──────────────────────────
+║ Time: {time}
+║ Level: {level_colored}
+║ Thread: {thread_info}
+╟──────────────────────────
+║ {message}
+║ {context}{exception}
+╚══════════════════════════╝"""
+
+    RICH_MINIMAL = "│ {time} │ {level_colored} │ {message}"
+    
+    RICH_COMPACT = "⟦{time}⟧ {level_colored} [{name}] ⟫ {message}"
+
+    # Template registry
+    TEMPLATES = {
+        # Basic formats
+        "minimal": MINIMAL,
+        "standard": STANDARD,
+        "detailed": DETAILED,
+        "simple": SIMPLE,
+        "compact": COMPACT,
+
+        # Modern styles
+        "modern": MODERN,
+        "modern_emoji": MODERN_EMOJI,
+        "modern_clean": MODERN_CLEAN,
+        "modern_bracket": MODERN_BRACKET,
+        "modern_plus": MODERN_PLUS,
+        "modern_dot": MODERN_DOT,
+        "modern_arrow": MODERN_ARROW,
+
+        # Boxed styles
+        "boxed": BOXED,
+        "double_box": DOUBLE_BOX,
+        "rounded_box": ROUNDED_BOX,
+        "rainbow_box": RAINBOW_BOX,
+        "heavy_box": HEAVY_BOX,
+        "dotted_box": DOTTED_BOX,
+
+        # Debug formats
+        "debug": DEBUG,
+        "debug_full": DEBUG_FULL,
+        "trace": TRACE,
+        "debug_compact": DEBUG_COMPACT,
+        "debug_extended": DEBUG_EXTENDED,
+
+        # Error formats
+        "error": ERROR,
+        "error_detailed": ERROR_DETAILED,
+        "error_compact": ERROR_COMPACT,
+        "error_emoji": ERROR_EMOJI,
+        "error_block": ERROR_BLOCK,
+
+        # Status formats
+        "status": STATUS,
+        "progress": PROGRESS,
+        "progress_simple": PROGRESS_SIMPLE,
+        "progress_bar": PROGRESS_BAR,
+
+        # Network formats
+        "http": HTTP,
+        "request": REQUEST,
+        "response": RESPONSE,
+        "api_compact": API_COMPACT,
+        "api_detailed": API_DETAILED,
+
+        # System formats
+        "system": SYSTEM,
+        "metric": METRIC,
+        "metric_compact": METRIC_COMPACT,
+        "metric_json": METRIC_JSON,
+
+        # Security formats
+        "security": SECURITY,
+        "audit": AUDIT,
+        "security_alert": SECURITY_ALERT,
+
+        # Special formats
+        "rainbow": RAINBOW,
+        "minimal_emoji": MINIMAL_EMOJI,
+        "timestamp": TIMESTAMP,
+        "component": COMPONENT,
+        "hash": HASH,
+        "tag": TAG,
+
+        # Data formats
+        "json": JSON,
+        "json_pretty": JSON_PRETTY,
+        "xml": XML,
+        "yaml": YAML,
+
+        # Documentation formats
+        "markdown": MARKDOWN,
+        "rst": RST,
+        "html": HTML,
+
+        # Rich-like formats
+        "rich": RICH,
+        "rich_detailed": RICH_DETAILED,
+        "rich_minimal": RICH_MINIMAL,
+        "rich_compact": RICH_COMPACT,
+    }
+
+    @staticmethod
+    def create_custom(template: str) -> str:
+        """Create a custom log format template."""
+        try:
+            # Test if the template is valid by formatting with dummy data
+            dummy_data = {
+                "time": "2024-01-01 00:00:00",
+                "level": "INFO",
+                "name": "test",
+                "message": "test message",
+                "file": "test.py",
+                "line": 1,
+                "emoji": "✨",
+                "progress_bar": "==========",
+                "percentage": 100,
+                "method": "GET",
+                "url": "/test",
+                "status_code": 200,
+                "value": 42,
+                "units": "ms",
+                "hash": "abc123",
+                "tag": "test"
+            }
+            template.format(**dummy_data)
+            return template
+        except KeyError as e:
+            raise ValueError(f"Invalid format template. Missing key: {e}")
+        except Exception as e:
+            raise ValueError(f"Invalid format template: {e}")
+
+    @staticmethod
+    def get_format(format_name: str) -> str:
+        """Get a predefined format template by name."""
+        if format_name in LogFormat.TEMPLATES:
+            return LogFormat.TEMPLATES[format_name]
+        raise ValueError(f"Unknown format: {format_name}")
+
+    @staticmethod
+    def register_template(name: str, template: str):
+        """Register a new format template."""
+        if name in LogFormat.TEMPLATES:
+            raise ValueError(f"Format template '{name}' already exists")
+        
+        # Validate template before registering
+        LogFormat.create_custom(template)
+        LogFormat.TEMPLATES[name] = template

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,153 @@
+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