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

webscout/Provider/TTI/aiarta/README.md

@@ -0,0 +1,134 @@
+# AIArta Image Generator
+
+Generate stunning AI art with AI Arta! 🎨 This package provides both synchronous and asynchronous interfaces to the AIArta image generation service.
+
+## Features
+
+- Generate high-quality images from text prompts
+- 45+ artistic styles and models to choose from
+- Customize image generation with various parameters
+- Save images with automatic naming and organization
+- Both synchronous and asynchronous implementations
+
+## Installation
+
+```bash
+pip install webscout
+```
+
+## Usage
+
+### Synchronous Usage
+
+```python
+from webscout import AIArtaImager
+
+# Initialize the provider
+provider = AIArtaImager()
+
+# Generate a single image
+images = provider.generate("A cool cyberpunk city at night")
+paths = provider.save(images, dir="my_images")
+
+# Generate multiple images with different settings
+images = provider.generate(
+    prompt="Epic dragon breathing fire",
+    amount=2, 
+    model="flux"
+)
+provider.save(images, dir="dragon_pics")
+```
+
+### Asynchronous Usage
+
+```python
+from webscout import AsyncAIArtaImager
+import asyncio
+
+async def generate_images():
+    # Initialize with logging
+    provider = AsyncAIArtaImager(logging=True)
+    
+    # Generate a single image
+    images = await provider.generate("A beautiful sunset over mountains")
+    paths = await provider.save(images)
+    
+    # Generate multiple images with parameters
+    images = await provider.generate(
+        prompt="Epic dragon in cyberpunk city",
+        amount=2,
+        model="fantasy_art",
+        negative_prompt="ugly, deformed",
+        guidance_scale=7,
+        num_inference_steps=30
+    )
+    paths = await provider.save(images, name="dragon", dir="outputs")
+
+# Run the async function
+asyncio.run(generate_images())
+```
+
+## Available Models
+
+The AIArta provider supports 45+ models, including:
+
+- `flux` - General purpose model
+- `fantasy_art` - Fantasy-style images
+- `photographic` - Realistic photographic style
+- `watercolor` - Watercolor painting style
+- `low_poly` - Low-poly art style
+- `anime_tattoo` - Anime-inspired tattoo designs
+- `cinematic_art` - Movie-like cinematic images
+
+See the full list in the `model_aliases` variable in the code.
+
+## Parameters
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| prompt | str | | Your image description |
+| amount | int | 1 | Number of images to generate |
+| model | str | "Flux" | Model to use for generation |
+| negative_prompt | str | "blurry, deformed hands, ugly" | What to avoid in the image |
+| guidance_scale | int | 7 | How closely to follow the prompt |
+| num_inference_steps | int | 30 | More steps = better quality but slower |
+| aspect_ratio | str | "1:1" | Image aspect ratio |
+
+## Advanced Usage
+
+### Custom Timeouts and Proxies
+
+```python
+# Synchronous with custom settings
+provider = AIArtaImager(
+    timeout=120,
+    proxies={"http": "http://proxy:8080"},
+    logging=True
+)
+
+# Asynchronous with custom settings
+async_provider = AsyncAIArtaImager(
+    timeout=120,
+    proxies={"http": "http://proxy:8080"},
+    logging=True
+)
+```
+
+### Saving Images with Custom Naming
+
+```python
+# Generate images
+images = provider.generate("Beautiful landscape")
+
+# Save with custom name and directory
+provider.save(
+    images,
+    name="landscape",
+    dir="my_art_folder",
+    filenames_prefix="vacation_"
+)
+```
+
+## Authentication
+
+The provider handles authentication automatically, storing and refreshing tokens as needed. No manual setup required!

webscout/Provider/TTI/artbit/README.md

@@ -0,0 +1,100 @@
+# 🔥 Artbit Image Providers
+
+Your go-to solution for generating fire images with Artbit.ai! Both sync and async support! 🚀
+
+## 🌟 Features
+
+- 🎨 Support for all Artbit models
+- ⚡ Both sync and async implementations
+- 🔄 Smart retry mechanism
+- 🌐 Proxy support
+- 📝 Optional logging
+- 🎯 Type hints
+- 🚀 Easy to use
+
+## 📦 Installation
+
+```bash
+pip install webscout
+```
+
+## 🚀 Quick Start
+
+### Sync Usage
+
+```python
+from webscout import ArtbitImager
+
+# Initialize with logging
+provider = ArtbitImager(logging=True)
+
+# Generate a single image
+images = provider.generate("A shiny red sports car")
+paths = provider.save(images)
+
+# Generate multiple images with parameters
+images = provider.generate(
+    prompt="Epic dragon in cyberpunk city",
+    amount=3,
+    caption_model="sdxl",
+    selected_ratio="1024",
+    negative_prompt="blurry, bad quality"
+)
+paths = provider.save(images, name="dragon", dir="outputs")
+```
+
+### Async Usage
+
+```python
+from webscout import AsyncArtbitImager
+import asyncio
+
+async def example():
+    # Initialize with logging
+    provider = AsyncArtbitImager(logging=True)
+    
+    # Generate a single image
+    images = await provider.generate("A shiny red sports car")
+    paths = await provider.save(images)
+    
+    # Generate multiple images with parameters
+    images = await provider.generate(
+        prompt="Epic dragon in cyberpunk city",
+        amount=3,
+        caption_model="sdxl",
+        selected_ratio="1024",
+        negative_prompt="blurry, bad quality"
+    )
+    paths = await provider.save(images, name="dragon", dir="outputs")
+
+# Run the example
+asyncio.run(example())
+```
+
+## 🎨 Supported Models
+
+- `sdxl` (default) - Stable Diffusion XL
+- `sd` - Stable Diffusion
+- And more coming soon! 🎉
+
+## ⚙️ Configuration Options
+
+- `timeout`: Request timeout in seconds
+- `proxies`: Proxy settings for requests
+- `logging`: Enable/disable fire logging
+
+## 🎯 Generation Parameters
+
+- `prompt`: Your image description
+- `amount`: Number of images to generate
+- `caption_model`: Which model to use
+- `selected_ratio`: Image size ratio
+- `negative_prompt`: What you don't want in the image
+
+## 💾 Save Options
+
+- `name`: Custom name for your images
+- `dir`: Where to save your images
+- `filenames_prefix`: Add prefix to filenames
+
+## 🔥 Made with Love by HelpingAI

webscout/Provider/TTI/fastflux/README.md

@@ -0,0 +1,129 @@
+# 🎨 FastFlux Image Generator
+
+Generate amazing images with FastFlux's AI art generator! 🚀
+
+## 🌟 Features
+
+- Fast and reliable image generation
+- Both sync and async implementations
+- Smart retry mechanism
+- Multiple model options
+- Different aspect ratios
+- Proxy support
+- Custom timeouts
+- Easy-to-use interface
+
+## 📦 Installation
+
+```bash
+pip install webscout
+```
+
+## 🚀 Quick Start
+
+### Sync Usage
+
+```python
+from webscout import FastFluxImager
+
+# Initialize the provider
+provider = FastFluxImager()
+
+# Generate a single image
+images = provider.generate("A beautiful sunset over mountains")
+paths = provider.save(images)
+
+# Generate multiple images with parameters
+images = provider.generate(
+    prompt="Epic dragon breathing fire",
+    amount=3,
+    model="flux_1_dev",
+    size="16_9"
+)
+paths = provider.save(images, dir="dragon_pics")
+```
+
+### Async Usage
+
+```python
+from webscout import AsyncFastFluxImager
+import asyncio
+
+async def generate_images():
+    provider = AsyncFastFluxImager()
+    
+    # Generate multiple images
+    images = await provider.generate(
+        "Epic dragon in cyberpunk city",
+        amount=2,
+        model="flux_1_schnell"
+    )
+    paths = await provider.save(images, dir="outputs")
+
+# Run the async function
+asyncio.run(generate_images())
+```
+
+## 🎨 Available Models
+
+- `flux_1_schnell` - Fast generation model (default)
+- `flux_1_dev` - Developer model with detailed outputs
+- `sana_1_6b` - SANA 1.6B model for specialized images
+
+## ⚙️ Configuration
+
+```python
+# Custom settings
+provider = FastFluxImager(
+    timeout=120,  # Longer timeout
+    proxies={
+        'http': 'http://proxy:8080',
+        'https': 'http://proxy:8080'
+    },
+    logging=True  # Enable logging
+)
+
+# Advanced usage
+images = provider.generate(
+    prompt="A shiny red sports car",
+    amount=3,
+    model="flux_1_dev",
+    size="16_9",
+    is_public=False,
+    max_retries=5,
+    retry_delay=3
+)
+```
+
+## 💾 Save Options
+
+```python
+# Save with custom options
+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("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. `flux_1_schnell` is faster but `flux_1_dev` gives better quality
+3. Set longer timeouts for better quality models
+4. Enable proxies for better reliability
+5. Use retry mechanism for stability
+6. Save images with meaningful names

webscout/Provider/TTI/huggingface/README.md

@@ -0,0 +1,114 @@
+# 🔥 HuggingFace Image Providers
+
+Your go-to solution for generating fire images with HuggingFace's models! Both sync and async support! 🚀
+
+## 🌟 Features
+
+- 🎨 Support for all HuggingFace image models
+- ⚡ Both sync and async implementations
+- 🔄 Smart retry mechanism
+- 🌐 Proxy support
+- 📝 Comprehensive logging
+- 🎯 Type hints
+- 🚀 Easy to use
+
+## 📦 Installation
+
+```bash
+pip install webscout
+```
+
+## 🚀 Quick Start
+
+### Sync Usage
+
+```python
+from webscout import HFimager
+
+# Initialize with your API key
+provider = HFimager(api_token="your-hf-token")
+
+# Generate a single image
+images = provider.generate("A shiny red sports car")
+paths = provider.save(images)
+
+# Generate multiple images with parameters
+images = provider.generate(
+    prompt="Epic dragon in cyberpunk city",
+    amount=3,
+    model="runwayml/stable-diffusion-v1-5",
+    guidance_scale=7.5,
+    negative_prompt="blurry, bad quality",
+    num_inference_steps=50,
+    width=768,
+    height=768
+)
+paths = provider.save(images, name="dragon", dir="outputs")
+```
+
+### Async Usage
+
+```python
+from webscout import AsyncHFimager
+import asyncio
+
+async def example():
+    # Initialize with your API key
+    provider = AsyncHFimager(api_token="your-hf-token")
+    
+    # Generate a single image
+    images = await provider.generate("A shiny red sports car")
+    paths = await provider.save(images)
+    
+    # Generate multiple images with parameters
+    images = await provider.generate(
+        prompt="Epic dragon in cyberpunk city",
+        amount=3,
+        model="runwayml/stable-diffusion-v1-5",
+        guidance_scale=7.5,
+        negative_prompt="blurry, bad quality",
+        num_inference_steps=50,
+        width=768,
+        height=768
+    )
+    paths = await provider.save(images, name="dragon", dir="outputs")
+
+# Run the example
+asyncio.run(example())
+```
+
+## 🎨 Supported Models
+
+- `stabilityai/stable-diffusion-xl-base-1.0` (default)
+- `runwayml/stable-diffusion-v1-5`
+- `CompVis/stable-diffusion-v1-4`
+- `stabilityai/sdxl-turbo`
+- And many more! 🎉
+
+## ⚙️ Configuration Options
+
+- `api_token`: Your HuggingFace API token
+- `timeout`: Request timeout in seconds
+- `proxies`: Proxy settings for requests
+
+## 🎯 Generation Parameters
+
+- `prompt`: Your image description
+- `amount`: Number of images to generate
+- `model`: Which model to use
+- `guidance_scale`: Control how much to follow your prompt
+- `negative_prompt`: What you don't want in the image
+- `num_inference_steps`: More steps = better quality but slower
+- `width`: Image width
+- `height`: Image height
+- `scheduler`: Which scheduler to use
+- `seed`: Random seed for reproducibility
+
+## 💾 Save Options
+
+- `name`: Custom name for your images
+- `dir`: Where to save your images
+- `filenames_prefix`: Add prefix to filenames
+
+## 🔥 Made with Love by HelpingAI
+

webscout/Provider/TTI/piclumen/README.md

@@ -0,0 +1,161 @@
+# 🎨 PiclumenImager - Professional AI Image Generation
+
+Welcome to PiclumenImager - a powerful provider for creating high-quality AI-generated images.
+
+## ✨ Features
+
+- Professional-grade image generation with photorealistic outputs
+- Synchronous and asynchronous operation support
+- Robust error handling and retry mechanisms
+- Dynamic user agent management
+- Configurable proxy support
+- Customizable timeouts and retry settings
+- Smart error recovery system
+
+## 📦 Installation
+
+```bash
+pip install webscout
+```
+
+## 📘 Usage Guide
+
+### Synchronous Usage (PiclumenImager)
+
+```python
+from webscout import PiclumenImager
+
+# Basic initialization
+imager = PiclumenImager()
+
+# Generate a single image
+images = imager.generate("Dragon in flight over mountain peaks")
+paths = imager.save(images)
+print(f"Image saved to: {paths[0]}")
+
+# Generate multiple images with retry configuration
+images = imager.generate(
+    "Bioluminescent deep sea creature in natural habitat",
+    amount=3,
+    max_retries=5,
+    retry_delay=3
+)
+paths = imager.save(images)
+print(f"Images saved to: {paths}")
+
+# Configure with custom settings
+custom_imager = PiclumenImager(timeout=180)
+images = custom_imager.generate("Abstract architectural concept")
+paths = custom_imager.save(images)
+```
+
+### Asynchronous Usage (AsyncPiclumenImager)
+
+```python
+from webscout import AsyncPiclumenImager
+import asyncio
+
+async def generate_images():
+    imager = AsyncPiclumenImager()
+    
+    # Generate multiple images concurrently
+    images = await imager.generate(
+        "Architectural visualization of modern building",
+        amount=2,
+        max_retries=3,
+        retry_delay=5
+    )
+    paths = await imager.save(images)
+    print(f"Generated images: {paths}")
+
+    # Custom save configuration
+    images = await imager.generate("Modern art composition")
+    paths = await imager.save(
+        images, 
+        dir="artwork",
+        filenames_prefix="modern_"
+    )
+
+# Execute the async function
+asyncio.run(generate_images())
+```
+
+### Advanced Configuration
+
+```python
+# Initialize with proxy and extended timeout
+imager = PiclumenImager(
+    timeout=180,
+    proxies={
+        'http': 'http://proxy.example.com:8000',
+        'https': 'http://proxy.example.com:8000'
+    }
+)
+
+# Advanced image generation with custom settings
+images = imager.generate(
+    "Professional product photography of luxury watch",
+    max_retries=5,
+    retry_delay=3
+)
+paths = imager.save(
+    images,
+    name="product_photo",
+    dir="product_images",
+    filenames_prefix="watch_"
+)
+```
+
+## ⚡ Error Handling
+
+Comprehensive error handling implementation:
+
+```python
+try:
+    images = imager.generate("Product photography")
+    paths = imager.save(images)
+except requests.exceptions.RequestException as e:
+    print(f"Network error: {e}")
+except ValueError as e:
+    print(f"Invalid parameter: {e}")
+except Exception as e:
+    print(f"Unexpected error: {e}")
+```
+
+## 🎯 Image Quality Specializations
+
+PiclumenImager excels in generating:
+
+- Photorealistic images with accurate lighting and shadows
+- Detailed textures and material representations
+- Complex underwater and nature scenes
+- Architectural and product visualizations
+- Macro photography simulations
+
+## 🔒 Security Considerations
+
+- Implement proxy configuration for enhanced privacy
+- Use secure network connections
+- Follow API rate limiting guidelines
+- Handle sensitive data appropriately
+- Monitor and log API usage when needed
+
+## 💡 Optimization Tips
+
+For optimal results:
+
+1. Provide detailed, specific prompts
+2. Include lighting and environment details
+3. Reference professional photography styles
+4. Specify desired color schemes
+5. Adjust timeouts for complex generations
+6. Use appropriate retry settings for reliability
+
+## 📚 Technical Notes
+
+- Default timeout: 120 seconds
+- Maximum retries: 3 (configurable)
+- Supports JPEG image format
+- Implements automatic error recovery
+- Handles concurrent image generation
+- Supports both sync and async workflows

webscout/Provider/TTI/pixelmuse/README.md

@@ -0,0 +1,79 @@
+# PixelMuse Image Provider 🎨
+
+A powerful image generation provider using PixelMuse's API to create stunning AI art.
+
+## Features ✨
+
+- Generate high-quality AI images from text prompts
+- Support for multiple models
+- Customizable aspect ratio and style
+- Automatic image saving with customizable filenames
+- Built-in retry mechanism for reliability
+
+## Installation 📦
+
+No additional installation required! This provider is included in the webscout package.
+
+## Usage 🚀
+
+```python
+from webscout.Provider.TTI.pixelmuse import PixelMuseImager
+
+# Create an instance of the provider
+imager = PixelMuseImager(model="flux-schnell")
+
+# Generate images
+images = imager.generate(
+    prompt="A magical forest with glowing mushrooms",
+    amount=1,
+    style="none",
+    aspect_ratio="1:1"
+)
+
+# Save the generated images
+paths = imager.save(images)
+print(f"Saved images to: {paths}")
+```
+
+## Parameters ⚙️
+
+### Initialization
+
+- `model` (str): Which model to use (default: "flux-schnell")
+- `timeout` (int): Request timeout in seconds (default: 60)
+- `proxies` (dict): Proxy settings for requests (default: {})
+- `logging` (bool): Enable logging (default: True)
+
+### Generate Method
+
+- `prompt` (str): Your creative prompt
+- `amount` (int): Number of images to generate (default: 1)
+- `max_retries` (int): Maximum retry attempts (default: 3)
+- `retry_delay` (int): Seconds to wait between retries (default: 5)
+- `style` (str): Style to apply (default: "none")
+- `aspect_ratio` (str): Aspect ratio (default: "1:1")
+
+### Save Method
+
+- `response` (List[bytes]): List of image data
+- `name` (str): Base name for saved files (default: prompt)
+- `dir` (str): Directory to save images (default: current directory)
+- `filenames_prefix` (str): Prefix for filenames (default: "")
+
+## Available Models 🎯
+
+- `flux-schnell`: Fast and efficient model
+- `imagen-3-fast`: Quick Imagen 3 model
+- `imagen-3`: Full Imagen 3 model
+- `recraft-v3`: Recraft v3 model
+
+## Notes 📝
+
+- Currently only supports 1:1 aspect ratio
+- Images are saved in WebP format
+- Requires internet connection
+- Rate limits may apply based on PixelMuse's API policies
+
+## License 📄
+
+This provider is part of the webscout package. See the main package license for details.