webscout 8.2.8__py3-none-any.whl → 8.2.9__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/Provider/TTI/AiForce/README.md

@@ -1,159 +0,0 @@
-# AiForce Provider 🔥
-
-Yo fam! This is the AiForce provider for generating some fire images! Part of the HelpingAI squad! 👑
-
-## Features 💪
-
-- Both sync and async support ⚡
-- 12 fire models to choose from 🎨
-- Smart retry mechanism 🔄
-- Custom image sizes 📐
-- Save with custom names 💾
-- Fire logging with cyberpunk theme 🌟
-- Proxy support for stealth mode 🕵️‍♂️
-
-## Quick Start 🚀
-
-### Installation 📦
-
-```bash
-pip install webscout
-```
-
-### Basic Usage 💫
-
-```python
-# Sync way
-from webscout import AiForceimager
-
-provider = AiForceimager()
-images = provider.generate("Epic dragon")
-paths = provider.save(images)
-
-# Async way
-from webscout import AsyncAiForceimager
-import asyncio
-
-async def generate():
-    provider = AsyncAiForceimager()
-    images = await provider.generate("Cool art")
-    paths = await provider.save(images)
-
-asyncio.run(generate())
-```
-
-## Available Models 🎭
-
-| Model | Description | Best For |
-|-------|-------------|----------|
-| `Flux-1.1-Pro` | Latest pro model (Default) | High quality general purpose |
-| `stable-diffusion-xl-lightning` | Fast SDXL model | Quick generations |
-| `stable-diffusion-xl-base` | Base SDXL model | High quality base |
-| `ideogram` | Artistic model | Creative artwork |
-| `flux` | Standard model | General purpose |
-| `flux-realism` | Photorealistic model | Realistic images |
-| `flux-anime` | Anime style | Anime/manga art |
-| `flux-3d` | 3D rendering | 3D objects/scenes |
-| `flux-disney` | Disney style | Disney-like art |
-| `flux-pixel` | Pixel art | Retro/game art |
-| `flux-4o` | 4k output | High resolution |
-| `any-dark` | Dark theme | Gothic/dark art |
-
-## Advanced Examples 🔥
-
-### Custom Settings 🛠️
-
-```python
-provider = AiForceimager(
-    timeout=120,  # Longer timeout
-    proxies={
-        'http': 'http://proxy.example.com:8080'
-    }
-)
-```
-
-### Multiple Images with Custom Size 📸
-
-```python
-images = provider.generate(
-    prompt="A shiny red sports car",
-    amount=3,  # Generate 3 images
-    model="flux-realism",  # Use realistic model
-    width=1024,  # Custom width
-    height=768,  # Custom height
-    seed=42  # For reproducible results
-)
-```
-
-### Custom Save Options 💾
-
-```python
-paths = provider.save(
-    images,
-    name="sports_car",  # Custom name
-    dir="my_images",  # Custom directory
-    filenames_prefix="v1_"  # Add prefix
-)
-```
-
-### Async with Error Handling ⚡
-
-```python
-async def generate_safely():
-    provider = AsyncAiForceimager()
-    try:
-        images = await provider.generate(
-            prompt="Epic dragon",
-            model="flux-3d",
-            amount=2
-        )
-        paths = await provider.save(images, dir="dragons")
-        print(f"Saved to: {paths}")
-    except Exception as e:
-        print(f"Oops! Something went wrong: {e}")
-
-asyncio.run(generate_safely())
-```
-
-## Tips & Tricks 💡
-
-1. Use `flux-realism` for photorealistic images
-2. Use `flux-3d` for product renders
-3. Use `flux-anime` for anime style art
-4. Set custom timeouts for large images
-5. Use proxies for better reliability
-6. Add seed for reproducible results
-
-## Error Handling 🛡️
-
-The provider handles common errors:
-
-- Network issues
-- API timeouts
-- Invalid inputs
-- File saving errors
-
-Example with retry:
-
-```python
-provider = AiForceimager()
-try:
-    images = provider.generate(
-        "Epic scene",
-        max_retries=5,  # More retries
-        retry_delay=10  # Longer delay
-    )
-except Exception as e:
-    print(f"Generation failed: {e}")
-```
-
-## Contributing 🤝
-
-Pull up to the squad! We're always looking for improvements:
-
-1. Fork it
-2. Create your feature branch
-3. Push your changes
-4. Hit us with that pull request
-
-Made with 💖 by the HelpingAI Team

webscout/Provider/TTI/AiForce/__init__.py

@@ -1,22 +0,0 @@
-"""
-AiForce - Your go-to provider for generating fire images! 🔥
-
-Examples:
-    >>> # Sync Usage
-    >>> from webscout import AiForceimager
-    >>> provider = AiForceimager()
-    >>> images = provider.generate("Cool art")
-    >>> paths = provider.save(images)
-    >>>
-    >>> # Async Usage
-    >>> from webscout import AsyncAiForceimager
-    >>> async def example():
-    ...     provider = AsyncAiForceimager()
-    ...     images = await provider.generate("Epic dragon")
-    ...     paths = await provider.save(images)
-"""
-
-from .sync_aiforce import AiForceimager
-from .async_aiforce import AsyncAiForceimager
-
-__all__ = ["AiForceimager", "AsyncAiForceimager"]