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

webscout/Provider/TTI/ImgSys/README.md

@@ -0,0 +1,174 @@
+# ImgSys Provider 🎨
+
+A powerful text-to-image generation provider that uses multiple AI models to create unique images from your prompts! 
+
+## Features ✨
+
+- Generate 2 unique images from random providers for each prompt
+- Support for both synchronous and asynchronous operations
+- Built-in retry logic with configurable attempts and delays
+- Comprehensive error handling and input validation
+- Easy image saving with custom names and directories
+- Random user agent rotation for requests
+- Proxy support for enhanced privacy
+- Detailed documentation and examples
+
+## Installation 🚀
+
+The ImgSys provider is part of the Webscout package. You can install it using pip:
+
+```bash
+pip install webscout
+```
+
+## Usage Examples 📝
+
+### Synchronous Usage
+
+```python
+from webscout import ImgSys
+
+# Initialize the provider
+provider = ImgSys()
+
+# Generate images
+images = provider.generate("A cool cyberpunk city at night")
+
+# Save the images
+provider.save(images, dir="my_images")
+```
+
+### Asynchronous Usage
+
+```python
+import asyncio
+from webscout import AsyncImgSys
+
+async def main():
+    # Initialize the provider
+    provider = AsyncImgSys()
+    
+    # Generate images
+    images = await provider.generate("A cool cyberpunk city at night")
+    
+    # Save the images
+    await provider.save(images, dir="my_images")
+
+# Run the async function
+asyncio.run(main())
+```
+
+### Advanced Usage
+
+```python
+from webscout import ImgSys
+
+# Initialize with custom settings
+provider = ImgSys(
+    timeout=30,  # Custom timeout in seconds
+    proxies={    # Optional proxy configuration
+        "http": "http://proxy:8080",
+        "https": "https://proxy:8080"
+    }
+)
+
+# Generate images with custom retry settings
+images = provider.generate(
+    prompt="A majestic dragon in a fantasy landscape",
+    max_retries=5,    # More retry attempts
+    retry_delay=10    # Longer delay between retries
+)
+
+# Save with custom naming
+provider.save(
+    images,
+    name="dragon_art",
+    dir="fantasy_images",
+    filenames_prefix="fantasy_"
+)
+```
+
+## API Reference 📚
+
+### ImgSys Class
+
+#### Constructor
+
+```python
+def __init__(
+    self,
+    timeout: int = 60,
+    proxies: Optional[dict] = None
+)
+```
+
+Parameters:
+- `timeout` (int): HTTP request timeout in seconds (default: 60)
+- `proxies` (dict, optional): Proxy configuration for requests
+
+#### Methods
+
+##### generate()
+
+```python
+def generate(
+    self,
+    prompt: str,
+    max_retries: int = 3,
+    retry_delay: int = 5
+) -> List[bytes]
+```
+
+Generate images from a text prompt.
+
+Parameters:
+- `prompt` (str): Your image description
+- `max_retries` (int): Max retry attempts if something fails (default: 3)
+- `retry_delay` (int): Seconds to wait between retries (default: 5)
+
+Returns:
+- `List[bytes]`: Generated images as bytes
+
+##### save()
+
+```python
+def save(
+    self,
+    response: List[bytes],
+    name: Optional[str] = None,
+    dir: Optional[Union[str, Path]] = None,
+    filenames_prefix: str = ""
+) -> List[str]
+```
+
+Save generated images to disk.
+
+Parameters:
+- `response` (List[bytes]): Generated images
+- `name` (str, optional): Custom name for images
+- `dir` (Union[str, Path], optional): Save directory (default: current directory)
+- `filenames_prefix` (str): Prefix for image filenames
+
+Returns:
+- `List[str]`: Paths to saved images
+
+### AsyncImgSys Class
+
+The `AsyncImgSys` class provides the same functionality as `ImgSys` but with async/await support. All methods are prefixed with `async` and should be called with `await`.
+
+## Error Handling 🛡️
+
+The provider includes comprehensive error handling:
+
+- Input validation for empty prompts
+- Retry logic for failed API calls
+- Proper exception handling for network issues
+- Graceful handling of API response errors
+
+## Contributing 🤝
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License 📄
+
+This provider is part of the Webscout package and is licensed under the same terms. 

webscout/Provider/TTI/MagicStudio/README.md

@@ -0,0 +1,101 @@
+# 🎨 MagicStudio Image Generation
+
+Generate amazing images with MagicStudio's AI art generator! 🚀
+
+## 🌟 Features
+
+- Fast and reliable image generation
+- Both sync and async implementations
+- Smart retry mechanism
+- Proxy support
+- Custom timeouts
+- Easy-to-use interface
+
+## 📦 Installation
+
+```bash
+pip install webscout
+```
+
+## 🚀 Quick Start
+
+### Sync Usage
+
+```python
+from webscout import MagicStudioImager
+
+# Initialize the provider
+provider = MagicStudioImager()
+
+# Generate a single image
+images = provider.generate("A beautiful sunset over mountains")
+paths = provider.save(images)
+
+# Generate multiple images
+images = provider.generate(
+    prompt="Epic dragon breathing fire",
+    amount=3
+)
+paths = provider.save(images, dir="dragon_pics")
+```
+
+### Async Usage
+
+```python
+from webscout import AsyncMagicStudioImager
+import asyncio
+
+async def generate_images():
+    provider = AsyncMagicStudioImager()
+    
+    # Generate multiple images
+    images = await provider.generate(
+        "Epic dragon in cyberpunk city",
+        amount=2
+    )
+    paths = await provider.save(images, dir="outputs")
+
+# Run the async function
+asyncio.run(generate_images())
+```
+
+## ⚙️ Configuration
+
+```python
+# Custom settings
+provider = MagicStudioImager(
+    timeout=120,  # Longer timeout
+    proxies={
+        'http': 'http://proxy:8080',
+        'https': 'http://proxy:8080'
+    }
+)
+
+# Advanced usage
+images = provider.generate(
+    prompt="A shiny red sports car",
+    amount=3,
+    max_retries=5,
+    retry_delay=3
+)
+```
+
+## 🛡️ Error Handling
+
+```python
+try:
+    images = provider.generate("Cool art")
+    paths = provider.save(images)
+except ValueError as e:
+    print(f"Invalid input: {e}")
+except Exception as e:
+    print(f"Generation failed: {e}")
+```
+
+## 💡 Tips
+
+1. Use clear, descriptive prompts
+2. Set longer timeouts for multiple images
+3. Enable proxies for better reliability
+4. Use retry mechanism for stability
+5. Save images with meaningful names

webscout/Provider/TTI/Nexra/README.md

@@ -0,0 +1,155 @@
+# Nexra Provider 🔥
+
+Yo fam! This is the Nexra provider for generating some fire images! Part of the HelpingAI squad! 👑
+
+## Features 💪
+
+- Standard & Prodia models ⚡
+- 19+ fire models to choose from 🎨
+- Smart retry mechanism 🔄
+- Custom parameters support 🛠️
+- Save with custom names 💾
+- Fire logging with cyberpunk theme 🌟
+- Proxy support for stealth mode 🕵️‍♂️
+
+## Quick Start 🚀
+
+### Installation 📦
+
+```bash
+pip install webscout
+```
+
+### Basic Usage 💫
+
+```python
+from webscout import NexraImager
+
+# Basic usage
+provider = NexraImager()
+images = provider.generate("Epic dragon")
+paths = provider.save(images)
+
+# With custom model
+provider = NexraImager()
+images = provider.generate(
+    prompt="Epic dragon",
+    model="midjourney"
+)
+paths = provider.save(images)
+```
+
+## Available Models 🎭
+
+### Standard Models 🌟
+
+| Model | Description | Best For |
+|-------|-------------|----------|
+| `emi` | Eminent AI model | General purpose |
+| `stablediffusion-1.5` | Classic SD model | Proven quality |
+| `stablediffusion-2.1` | Improved SD model | Better quality |
+| `sdxl-lora` | SDXL with LoRA | Custom styles |
+| `dalle` | OpenAI's DALL-E | Clean images |
+| `dalle2` | DALL-E 2 model | High quality |
+| `dalle-mini` | Lightweight DALL-E | Quick generations |
+| `flux` | Standard Flux | General purpose |
+| `midjourney` | MJ style | Artistic images |
+
+### Prodia Models 🚀
+
+| Model | Description |
+|-------|-------------|
+| `dreamshaperXL10_alpha2` | Dreamlike creations |
+| `dynavisionXL_0411` | Dynamic visuals |
+| `juggernautXL_v45` | Powerful generations |
+| `realismEngineSDXL_v10` | Photorealistic images |
+| `sd_xl_base_1.0` | Base SDXL model |
+| `animagineXLV3_v30` | Anime style art |
+| `sd_xl_base_1.0_inpainting` | Inpainting specialist |
+| `turbovisionXL_v431` | Fast generations |
+| `devlishphotorealism_sdxl15` | Ultra-realistic |
+| `realvisxlV40` | Reality-based art |
+
+## Advanced Examples 🔥
+
+### Custom Settings 🛠️
+
+```python
+provider = NexraImager(
+    timeout=120,  # Longer timeout
+    proxies={
+        'http': 'http://proxy.example.com:8080'
+    }
+)
+```
+
+### Prodia Model with Custom Params 📸
+
+```python
+images = provider.generate(
+    prompt="A shiny red sports car",
+    model="realismEngineSDXL_v10.safetensors [af771c3f]",
+    additional_params={
+        "data": {
+            "steps": 30,
+            "cfg_scale": 8,
+            "sampler": "DPM++ 2M Karras",
+            "negative_prompt": "blurry, low quality"
+        }
+    }
+)
+```
+
+### Custom Save Options 💾
+
+```python
+paths = provider.save(
+    images,
+    name="sports_car",  # Custom name
+    dir="my_images",  # Custom directory
+    filenames_prefix="v1_"  # Add prefix
+)
+```
+
+### Error Handling 🛡️
+
+```python
+try:
+    images = provider.generate(
+        prompt="Epic scene",
+        model="midjourney",
+        max_retries=5,  # More retries
+        retry_delay=10  # Longer delay
+    )
+    paths = provider.save(images, dir="scenes")
+except Exception as e:
+    print(f"Oops! Something went wrong: {e}")
+```
+
+## Tips & Tricks 💡
+
+1. Use `midjourney` for artistic images
+2. Use `realismEngineSDXL` for photorealistic shots
+3. Use `animagineXLV3` for anime style
+4. Adjust steps and cfg_scale for better quality
+5. Use custom negative prompts
+6. Set longer timeouts for complex generations
+
+The provider handles common errors:
+
+- Network issues
+- JSON parsing errors
+- API timeouts
+- Invalid inputs
+- File saving errors
+
+## 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/PollinationsAI/README.md

@@ -0,0 +1,146 @@
+# PollinationsAI Provider 🎨
+
+A powerful text-to-image generation provider using Pollinations.ai! Generate stunning images with various styles and models. Supports both synchronous and asynchronous operations! 🚀
+
+## Features 💫
+
+- Multiple AI models for different styles 🎭
+- Both sync and async support ⚡
+- Built-in retry logic and error handling 🛡️
+- Easy-to-use interface 🎯
+- Beautiful logging with LitLogger 📝
+- Random user agents with LitAgent 🔄
+
+## Installation 📦
+
+```bash
+pip install webscout
+```
+
+## Quick Start 🚀
+
+### Synchronous Usage
+
+```python
+from webscout import PollinationsAI
+
+# Create provider
+provider = PollinationsAI()
+
+# Generate a single image
+images = provider.generate("A cool cyberpunk city at night")
+provider.save(images, dir="my_images")
+
+# Generate multiple images with settings
+images = provider.generate(
+    prompt="A majestic dragon",
+    amount=3,
+    width=1024,
+    height=1024,
+    model="flux-3d"  # Use 3D style
+)
+provider.save(images, dir="dragon_pics")
+```
+
+### Asynchronous Usage
+
+```python
+import asyncio
+from webscout import AsyncPollinationsAI
+
+async def main():
+    # Create provider
+    provider = AsyncPollinationsAI()
+    
+    # Generate images
+    images = await provider.generate(
+        prompt="A beautiful sunset",
+        amount=2,
+        model="flux-realism"  # Use realistic style
+    )
+    
+    # Save images
+    paths = await provider.save(images, dir="sunset_pics")
+    print(f"Saved images to: {paths}")
+
+# Run async code
+asyncio.run(main())
+```
+
+## Available Models 🎭
+
+| Model | Description | Best For |
+|-------|-------------|----------|
+| `flux` | Default model | General purpose |
+| `flux-realism` | Enhanced realism | Photos, portraits |
+| `flux-cablyai` | CablyAI style | Artistic renders |
+| `flux-anime` | Anime/manga style | Anime art |
+| `flux-3d` | 3D-style renders | 3D scenes |
+| `any-dark` | Dark/gothic style | Dark themes |
+| `flux-pro` | Professional quality | High-quality art |
+| `turbo` | Fast generation | Quick results |
+
+## Advanced Usage 🔧
+
+### Different Models for Different Styles
+
+```python
+# Anime style
+anime_pics = provider.generate(
+    prompt="Cute anime character",
+    model="flux-anime"
+)
+
+# Realistic style
+real_pics = provider.generate(
+    prompt="Professional portrait",
+    model="flux-realism"
+)
+
+# Quick generation
+quick_pics = provider.generate(
+    prompt="Quick concept art",
+    model="turbo"
+)
+```
+
+### Custom Settings
+
+```python
+# Custom timeout and proxies
+provider = PollinationsAI(
+    timeout=30,  # 30 seconds timeout
+    proxies={
+        "http": "http://proxy:8080"
+    }
+)
+
+# Generate high-res images
+images = provider.generate(
+    prompt="Ultra detailed landscape",
+    width=1920,
+    height=1080,
+    model="flux-pro"
+)
+```
+
+## Error Handling 🛡️
+
+The provider includes built-in retry logic and error handling:
+
+```python
+try:
+    images = provider.generate(
+        prompt="Test image",
+        max_retries=3,  # Retry 3 times
+        retry_delay=5   # Wait 5 seconds between retries
+    )
+except Exception as e:
+    print(f"Generation failed: {e}")
+```
+
+## Contributing 🤝
+
+Feel free to contribute! Check out our issues or submit PRs.
+
+Made with 💖 by the HelpingAI Team

webscout/Provider/TTI/README.md

@@ -0,0 +1,128 @@
+# 🎨 WebScout Text-to-Image (TTI) Providers
+
+Welcome to WebScout's Text-to-Image providers - your ultimate collection of AI art generators! 🚀
+
+## 🌟 Available Providers
+
+* **[AiForce](AiForce/README.md):** Advanced AI image generation with 12 specialized models including Flux-1.1-Pro, SDXL Lightning, and Ideogram, perfect for both quick generations and high-quality art
+* **[Nexra](Nexra/README.md):** Next-gen image creation with 19+ models including MidJourney, DALL-E, and specialized SDXL variants for every use case from anime to photorealism
+* **[TalkAI](talkai/README.md):** Fast and reliable image generation with comprehensive error handling and dynamic user agent support
+* **[PollinationsAI](PollinationsAI/README.md):** Nature-inspired AI art generation with specialized models for organic and natural imagery
+* **[Artbit](artbit/README.md):** Bit-perfect AI art creation with precise control over generation parameters
+* **[HuggingFace](huggingface/README.md):** Direct integration with HuggingFace's powerful models for research-grade image generation
+* **[FreeAIPlayground](FreeAIPlayground/README.md):** Premium image generation with DALL-E 3 and Flux series models including Pro Ultra, Realism, and Aurora variants
+* **[PiclumenImager](piclumen/README.md):** Professional photorealistic image generation with advanced concurrent processing, optimized for macro photography, underwater scenes, and architectural visualization
+* **[MagicStudio](MagicStudio/README.md):** Generate amazing images with MagicStudio's AI art generator! 🚀
+* **[FastFlux](fastflux/README.md):** Generate amazing images with FastFlux's AI art generator! 🚀
+* **[ImgSys](ImgSys/README.md):** Multi-provider image generation that creates 2 unique images from random AI models for each prompt, with comprehensive error handling and async support 🎨
+* **[PixelMuse](pixelmuse/README.md):** Create stunning AI art with PixelMuse's powerful models including flux-schnell, imagen-3, and recraft-v3, featuring both sync and async support for optimal performance 🎨
+
+## 🚀 Features
+
+All providers come with these fire features:
+
+### 🛠️ Core Features
+
+* Both sync and async implementations
+
+* Comprehensive error handling
+* Optional logging with cyberpunk theme
+* Dynamic user agent generation
+* Proxy support
+* Customizable timeouts
+* Smart retry mechanisms
+
+### 💫 Developer Experience
+
+* Consistent API across all providers
+
+* Detailed documentation with examples
+* Type hints for better IDE support
+* Comprehensive error messages
+* Easy-to-use interface
+
+### 🔒 Security Features
+
+* Proxy support for privacy
+
+* Configurable timeouts
+* Safe error handling
+* Optional verbose logging
+* Dynamic user agent rotation
+
+## 🎯 Usage Example
+
+```python
+# Sync way
+from webscout.Provider.TTI import BlackboxAIImager
+
+imager = BlackboxAIImager()
+images = imager.generate("Epic dragon breathing fire", amount=2)
+paths = imager.save(images)
+
+# Async way
+from webscout.Provider.TTI import AsyncDeepInfraImager
+import asyncio
+
+async def generate_art():
+    imager = AsyncDeepInfraImager()
+    images = await imager.generate("Cyberpunk city at night")
+    paths = await imager.save(images)
+
+asyncio.run(generate_art())
+```
+
+## 🔧 Installation
+
+```bash
+pip install webscout
+```
+
+## 📚 Common Interface
+
+All providers implement these base classes:
+
+* `ImageProvider` for sync operations
+* `AsyncImageProvider` for async operations
+
+### 🎨 Common Methods
+
+```python
+def generate(
+    self,
+    prompt: str,           # Your creative prompt
+    amount: int = 1,       # Number of images
+    max_retries: int = 3,  # Max retry attempts
+    retry_delay: int = 5   # Delay between retries
+) -> List[bytes]:         # Returns image data
+    ...
+
+def save(
+    self,
+    response: List[bytes], # Image data
+    name: str = None,      # Base filename
+    dir: str = os.getcwd(),# Save directory
+    prefix: str = ""       # Filename prefix
+) -> List[str]:           # Returns saved paths
+    ...
+```
+
+## 🛡️ Error Handling
+
+All providers use these standard exceptions:
+
+* `APIConnectionError`: Network/connection issues
+* `InvalidResponseError`: Invalid API responses
+* `FailedToGenerateResponseError`: Generation failures
+
+## 🎛️ Configuration
+
+Common configuration options:
+
+```python
+imager = Provider(
+    timeout=60,      # Request timeout
+    proxies={},      # Proxy settings
+
+)
+```