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

webscout/Provider/TTI/pollinations.py

@@ -0,0 +1,221 @@
+import requests
+from typing import Optional, List, Dict, Any, Union
+from pathlib import Path
+from requests.exceptions import RequestException
+from webscout.Provider.TTI.utils import ImageData, ImageResponse
+from webscout.Provider.TTI.base import TTICompatibleProvider, BaseImages
+from io import BytesIO
+import os
+import tempfile
+from webscout.litagent import LitAgent
+import time
+import json
+import random
+
+try:
+    from PIL import Image
+except ImportError:
+    Image = None
+
+class Images(BaseImages):
+    def __init__(self, client):
+        self._client = client
+
+    def create(
+        self,
+        *,
+        model: str,
+        prompt: str,
+        n: int = 1,
+        size: str = "1024x1024",
+        response_format: str = "url",
+        user: Optional[str] = None,
+        style: str = "none",
+        aspect_ratio: str = "1:1",
+        timeout: int = 60,
+        image_format: str = "png",
+        seed: Optional[int] = None,
+        **kwargs
+    ) -> ImageResponse:
+        """
+        image_format: "png" or "jpeg"
+        seed: Optional random seed for reproducibility. If not provided, a random seed is used.
+        """
+        if Image is None:
+            raise ImportError("Pillow (PIL) is required for image format conversion.")
+
+        images = []
+        urls = []
+
+        def upload_file_with_retry(img_bytes, image_format, max_retries=3):
+            ext = "jpg" if image_format.lower() == "jpeg" else "png"
+            for attempt in range(max_retries):
+                tmp_path = None
+                try:
+                    with tempfile.NamedTemporaryFile(suffix=f".{ext}", delete=False) as tmp:
+                        tmp.write(img_bytes)
+                        tmp.flush()
+                        tmp_path = tmp.name
+                    with open(tmp_path, 'rb') as f:
+                        files = {
+                            'fileToUpload': (f'image.{ext}', f, f'image/{ext}')
+                        }
+                        data = {
+                            'reqtype': 'fileupload',
+                            'json': 'true'
+                        }
+                        headers = {'User-Agent': LitAgent().random()}
+                        if attempt > 0:
+                            headers['Connection'] = 'close'
+                        resp = requests.post("https://catbox.moe/user/api.php", files=files, data=data, headers=headers, timeout=timeout)
+                        if resp.status_code == 200 and resp.text.strip():
+                            text = resp.text.strip()
+                            if text.startswith('http'):
+                                return text
+                            try:
+                                result = resp.json()
+                                if "url" in result:
+                                    return result["url"]
+                            except json.JSONDecodeError:
+                                if 'http' in text:
+                                    return text
+                except Exception:
+                    if attempt < max_retries - 1:
+                        time.sleep(1 * (attempt + 1))
+                finally:
+                    if tmp_path and os.path.isfile(tmp_path):
+                        try:
+                            os.remove(tmp_path)
+                        except Exception:
+                            pass
+            return None
+
+        def upload_file_alternative(img_bytes, image_format):
+            try:
+                ext = "jpg" if image_format.lower() == "jpeg" else "png"
+                with tempfile.NamedTemporaryFile(suffix=f".{ext}", delete=False) as tmp:
+                    tmp.write(img_bytes)
+                    tmp.flush()
+                    tmp_path = tmp.name
+                try:
+                    if not os.path.isfile(tmp_path):
+                        return None
+                    with open(tmp_path, 'rb') as img_file:
+                        files = {'file': img_file}
+                        response = requests.post('https://0x0.st', files=files)
+                        response.raise_for_status()
+                        image_url = response.text.strip()
+                        if not image_url.startswith('http'):
+                            return None
+                        return image_url
+                except Exception:
+                    return None
+                finally:
+                    try:
+                        os.remove(tmp_path)
+                    except Exception:
+                        pass
+            except Exception:
+                return None
+
+        for i in range(n):
+            # Prepare parameters for Pollinations API
+            params = {
+                "model": model,
+                "width": int(size.split("x")[0]) if "x" in size else 1024,
+                "height": int(size.split("x")[1]) if "x" in size else 1024,
+                "seed": seed if seed is not None else random.randint(0, 2**32 - 1),
+            }
+            # Build the API URL
+            base_url = f"https://image.pollinations.ai/prompt/{prompt}"
+            # Compose query string
+            query = "&".join(f"{k}={v}" for k, v in params.items())
+            url = f"{base_url}?{query}"
+            try:
+                resp = self._client.session.get(url, timeout=timeout)
+                resp.raise_for_status()
+                img_bytes = resp.content
+            except RequestException as e:
+                raise RuntimeError(f"Failed to fetch image from Pollinations API: {e}")
+
+            # Convert to png or jpeg in memory
+            with BytesIO(img_bytes) as input_io:
+                with Image.open(input_io) as im:
+                    out_io = BytesIO()
+                    if image_format.lower() == "jpeg":
+                        im = im.convert("RGB")
+                        im.save(out_io, format="JPEG")
+                    else:
+                        im.save(out_io, format="PNG")
+                    img_bytes = out_io.getvalue()
+
+            images.append(img_bytes)
+
+            if response_format == "url":
+                uploaded_url = upload_file_with_retry(img_bytes, image_format)
+                if not uploaded_url:
+                    uploaded_url = upload_file_alternative(img_bytes, image_format)
+                if uploaded_url:
+                    urls.append(uploaded_url)
+                else:
+                    raise RuntimeError("Failed to upload image to catbox.moe using all available methods")
+
+        result_data = []
+        if response_format == "url":
+            for url in urls:
+                result_data.append(ImageData(url=url))
+        elif response_format == "b64_json":
+            import base64
+            for img in images:
+                b64 = base64.b64encode(img).decode("utf-8")
+                result_data.append(ImageData(b64_json=b64))
+        else:
+            raise ValueError("response_format must be 'url' or 'b64_json'")
+
+        from time import time as _time
+        return ImageResponse(
+            created=int(_time()),
+            data=result_data
+        )
+
+class PollinationsAI(TTICompatibleProvider):
+    AVAILABLE_MODELS = [
+        "flux",
+        "turbo",
+        "gptimage"
+    ]
+
+    def __init__(self):
+        self.api_endpoint = "https://image.pollinations.ai/prompt"
+        self.session = requests.Session()
+        self.user_agent = LitAgent().random()
+        self.headers = {
+            "accept": "*/*",
+            "accept-language": "en-US,en;q=0.9",
+            "content-type": "application/json",
+            "origin": "https://image.pollinations.ai",
+            "referer": "https://image.pollinations.ai/",
+            "user-agent": self.user_agent,
+        }
+        self.session.headers.update(self.headers)
+        self.images = Images(self)
+
+    @property
+    def models(self):
+        class _ModelList:
+            def list(inner_self):
+                return type(self).AVAILABLE_MODELS
+        return _ModelList()
+
+if __name__ == "__main__":
+    from rich import print
+    client = PollinationsAI()
+    response = client.images.create(
+        model="flux",
+        prompt="a japanese waifu in short kimono clothes",
+        response_format="url",
+        n=4,
+        timeout=30,
+        seed=None  # You can set a specific seed for reproducibility
+    )
+    print(response)

webscout/Provider/TTI/utils.py

@@ -0,0 +1,11 @@
+from typing import List, Optional
+from pydantic import BaseModel, Field
+import time
+
+class ImageData(BaseModel):
+    url: Optional[str] = None
+    b64_json: Optional[str] = None
+
+class ImageResponse(BaseModel):
+    created: int = Field(default_factory=lambda: int(time.time()))
+    data: List[ImageData]

webscout/Provider/TTS/README.md

@@ -0,0 +1,192 @@
+# 🎙️ Webscout Text-to-Speech (TTS) Providers
+
+## Overview
+
+Webscout's TTS Providers offer a versatile and powerful text-to-speech conversion library with support for multiple providers and advanced features.
+
+## 🌟 Features
+
+- **Multiple TTS Providers**: Support for various text-to-speech services
+- **Concurrent Audio Generation**: Efficiently process long texts
+- **Flexible Voice Selection**: Choose from a wide range of voices
+- **Robust Error Handling**: Comprehensive logging and error management
+- **Temporary File Management**: Automatically manages temporary audio files
+- **Cross-Platform Compatibility**: Works seamlessly across different environments
+- **Custom Save Locations**: Save audio files to specific destinations
+- **Audio Streaming**: Stream audio data in chunks for real-time applications
+
+## 📦 Supported TTS Providers
+
+1. **ElevenlabsTTS**
+2. **GesseritTTS**
+3. **MurfAITTS**
+4. **ParlerTTS**
+5. **DeepgramTTS**
+6. **StreamElementsTTS**
+7. **SpeechMaTTS**
+8. **SthirTTS**
+## 🚀 Installation
+
+```bash
+pip install webscout
+```
+
+## 💻 Basic Usage
+
+```python
+from webscout.Provider.TTS import ElevenlabsTTS
+
+# Initialize the TTS provider
+tts = ElevenlabsTTS()
+
+# Generate speech from text
+text = "Hello, this is a test of text-to-speech conversion."
+audio_file = tts.tts(text, voice="Brian")
+
+# Save the audio to a specific location
+saved_path = tts.save_audio(audio_file, destination="my_speech.mp3")
+print(f"Audio saved to: {saved_path}")
+
+# Stream audio in chunks
+for chunk in tts.stream_audio(text, voice="Brian"):
+    # Process each chunk (e.g., send to a websocket, write to a stream, etc.)
+    process_audio_chunk(chunk)
+```
+
+## 🎛️ Advanced Configuration
+
+### Voice Selection
+
+Each TTS provider offers multiple voices:
+
+```python
+# List available voices
+print(tts.all_voices.keys())
+
+# Select a specific voice
+audio_file = tts.tts(text, voice="Alice")
+```
+
+### Verbose Logging
+
+Enable detailed logging for debugging:
+
+```python
+audio_file = tts.tts(text, verbose=True)
+```
+
+## 🔧 Provider-Specific Details
+
+### ElevenlabsTTS
+
+- Supports multiple English voices
+- Multilingual text-to-speech
+
+### GesseritTTS
+
+- Offers unique voice characteristics
+- Supports voice description customization
+
+### MurfAITTS
+
+- Provides specific voice models
+- Supports custom voice descriptions
+
+### ParlerTTS
+
+- Uses Gradio Client for TTS generation
+- Supports large and small model variants
+
+### DeepgramTTS
+
+- Multiple voice options
+- Advanced voice selection
+
+### StreamElementsTTS
+
+- Wide range of international voices
+
+### SpeechMaTTS
+
+- Multilingual voices (Ava, Emma, Andrew, Brian)
+- Adjustable pitch and speech rate
+- Fast audio generation
+
+## 🛡️ Error Handling
+
+```python
+try:
+    audio_file = tts.tts(text)
+except exceptions.FailedToGenerateResponseError as e:
+    print(f"TTS generation failed: {e}")
+```
+
+## 🌐 Proxy Support
+
+```python
+# Use with proxy
+tts = ElevenlabsTTS(proxies={
+    'http': 'http://proxy.example.com:8080',
+    'https': 'https://proxy.example.com:8080'
+})
+```
+
+## 💾 Custom Audio Saving
+
+Save generated audio to a specific location:
+
+```python
+# Generate speech
+audio_file = tts.tts(text, voice="Brian")
+
+# Save to a specific file
+tts.save_audio(audio_file, destination="path/to/output.mp3")
+
+# Save to a specific directory with default filename
+tts.save_audio(audio_file, destination="path/to/directory/")
+
+# Save with default location (current directory with timestamp)
+saved_path = tts.save_audio(audio_file)
+print(f"Saved to: {saved_path}")
+```
+
+## 📼 Audio Streaming
+
+Stream audio data in chunks for real-time applications:
+
+```python
+# Stream audio in chunks
+for chunk in tts.stream_audio(text, voice="Brian", chunk_size=2048):
+    # Example: Send to a websocket
+    websocket.send(chunk)
+
+    # Example: Write to an audio stream
+    audio_stream.write(chunk)
+
+    # Example: Process in real-time
+    process_audio_data(chunk)
+```
+
+## ⏱️ Async Support
+
+Use the async versions for non-blocking operations:
+
+```python
+from webscout.Provider.TTS import AsyncElevenlabsTTS
+import asyncio
+
+async def main():
+    tts = AsyncElevenlabsTTS()
+
+    # Generate speech
+    audio_file = await tts.tts(text, voice="Brian")
+
+    # Save to a specific location
+    saved_path = await tts.save_audio(audio_file, destination="output.mp3")
+
+    # Stream audio
+    async for chunk in tts.stream_audio(text, voice="Brian"):
+        await process_chunk(chunk)
+
+asyncio.run(main())
+```

webscout/Provider/TTS/__init__.py

@@ -0,0 +1,10 @@
+from .base import BaseTTSProvider, AsyncBaseTTSProvider
+from .streamElements import *
+from .parler import *
+from .deepgram import *
+from .elevenlabs import *
+from .murfai import *
+from .gesserit import *
+from .speechma import *
+from .sthir import *
+from .openai_fm import *

webscout/Provider/TTS/base.py

@@ -0,0 +1,159 @@
+"""
+Base class for TTS providers with common functionality.
+"""
+import os
+import tempfile
+from pathlib import Path
+from typing import Generator, Optional
+from webscout.AIbase import TTSProvider
+
+class BaseTTSProvider(TTSProvider):
+    """
+    Base class for TTS providers with common functionality.
+    
+    This class implements common methods like save_audio and stream_audio
+    that can be used by all TTS providers.
+    """
+    
+    def __init__(self):
+        """Initialize the base TTS provider."""
+        self.temp_dir = tempfile.mkdtemp(prefix="webscout_tts_")
+    
+    def save_audio(self, audio_file: str, destination: str = None, verbose: bool = False) -> str:
+        """
+        Save audio to a specific destination.
+        
+        Args:
+            audio_file (str): Path to the source audio file
+            destination (str, optional): Destination path. Defaults to current directory with timestamp.
+            verbose (bool, optional): Whether to print debug information. Defaults to False.
+            
+        Returns:
+            str: Path to the saved audio file
+            
+        Raises:
+            FileNotFoundError: If the audio file doesn't exist
+        """
+        import shutil
+        import time
+        
+        source_path = Path(audio_file)
+        
+        if not source_path.exists():
+            raise FileNotFoundError(f"Audio file not found: {audio_file}")
+        
+        if destination is None:
+            # Create a default destination with timestamp in current directory
+            timestamp = int(time.time())
+            destination = os.path.join(os.getcwd(), f"tts_audio_{timestamp}{source_path.suffix}")
+        
+        # Ensure the destination directory exists
+        os.makedirs(os.path.dirname(os.path.abspath(destination)), exist_ok=True)
+        
+        # Copy the file
+        shutil.copy2(source_path, destination)
+        
+        if verbose:
+            print(f"[debug] Audio saved to {destination}")
+            
+        return destination
+    
+    def stream_audio(self, text: str, voice: str = None, chunk_size: int = 1024, verbose: bool = False) -> Generator[bytes, None, None]:
+        """
+        Stream audio in chunks.
+        
+        Args:
+            text (str): The text to convert to speech
+            voice (str, optional): The voice to use. Defaults to provider's default voice.
+            chunk_size (int, optional): Size of audio chunks to yield. Defaults to 1024.
+            verbose (bool, optional): Whether to print debug information. Defaults to False.
+            
+        Yields:
+            Generator[bytes, None, None]: Audio data chunks
+        """
+        # Generate the audio file
+        audio_file = self.tts(text, voice=voice, verbose=verbose)
+        
+        # Stream the file in chunks
+        with open(audio_file, 'rb') as f:
+            while chunk := f.read(chunk_size):
+                yield chunk
+
+
+class AsyncBaseTTSProvider:
+    """
+    Base class for async TTS providers with common functionality.
+    
+    This class implements common async methods like save_audio and stream_audio
+    that can be used by all async TTS providers.
+    """
+    
+    def __init__(self):
+        """Initialize the async base TTS provider."""
+        self.temp_dir = tempfile.mkdtemp(prefix="webscout_tts_")
+    
+    async def save_audio(self, audio_file: str, destination: str = None, verbose: bool = False) -> str:
+        """
+        Save audio to a specific destination asynchronously.
+        
+        Args:
+            audio_file (str): Path to the source audio file
+            destination (str, optional): Destination path. Defaults to current directory with timestamp.
+            verbose (bool, optional): Whether to print debug information. Defaults to False.
+            
+        Returns:
+            str: Path to the saved audio file
+            
+        Raises:
+            FileNotFoundError: If the audio file doesn't exist
+        """
+        import shutil
+        import time
+        import asyncio
+        
+        source_path = Path(audio_file)
+        
+        if not source_path.exists():
+            raise FileNotFoundError(f"Audio file not found: {audio_file}")
+        
+        if destination is None:
+            # Create a default destination with timestamp in current directory
+            timestamp = int(time.time())
+            destination = os.path.join(os.getcwd(), f"tts_audio_{timestamp}{source_path.suffix}")
+        
+        # Ensure the destination directory exists
+        os.makedirs(os.path.dirname(os.path.abspath(destination)), exist_ok=True)
+        
+        # Copy the file using asyncio to avoid blocking
+        await asyncio.to_thread(shutil.copy2, source_path, destination)
+        
+        if verbose:
+            print(f"[debug] Audio saved to {destination}")
+            
+        return destination
+    
+    async def stream_audio(self, text: str, voice: str = None, chunk_size: int = 1024, verbose: bool = False):
+        """
+        Stream audio in chunks asynchronously.
+        
+        Args:
+            text (str): The text to convert to speech
+            voice (str, optional): The voice to use. Defaults to provider's default voice.
+            chunk_size (int, optional): Size of audio chunks to yield. Defaults to 1024.
+            verbose (bool, optional): Whether to print debug information. Defaults to False.
+            
+        Yields:
+            AsyncGenerator[bytes, None]: Audio data chunks
+        """
+        try:
+            import aiofiles
+        except ImportError:
+            raise ImportError("The 'aiofiles' package is required for async streaming. Install it with 'pip install aiofiles'.")
+        
+        # Generate the audio file
+        audio_file = await self.tts(text, voice=voice, verbose=verbose)
+        
+        # Stream the file in chunks
+        async with aiofiles.open(audio_file, 'rb') as f:
+            while chunk := await f.read(chunk_size):
+                yield chunk