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

webscout/Provider/TTS/base.py

@@ -1,159 +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
+"""
+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

webscout/Provider/TTS/openai_fm.py

@@ -0,0 +1,129 @@
+##################################################################################
+##  OpenAI.fm TTS Provider                                                     ##
+##################################################################################
+import time
+import requests
+import pathlib
+import tempfile
+from io import BytesIO
+from webscout import exceptions
+from webscout.litagent import LitAgent
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from webscout.Provider.TTS import utils
+from webscout.Provider.TTS.base import BaseTTSProvider
+
+class OpenAIFMTTS(BaseTTSProvider):
+    """
+    Text-to-speech provider using the OpenAI.fm API.
+    """
+    # Request headers
+    headers = {
+        "accept": "*/*",
+        "accept-language": "en-US,en;q=0.9",
+        "cache-control": "no-cache",
+        "pragma": "no-cache",
+        "sec-fetch-dest": "audio",
+        "sec-fetch-mode": "no-cors",
+        "sec-fetch-site": "same-origin",
+        "user-agent": LitAgent().random(),
+        "referer": "https://www.openai.fm"
+    }
+    
+    # Available voices with their IDs
+    all_voices = {
+        # OpenAI.fm voices
+        "Alloy": "alloy",  # Neutral voice with balanced tone
+        "Ash": "ash",      # Calm and thoughtful male voice
+        "Ballad": "ballad", # Soft and melodic voice
+        "Coral": "coral",   # Warm and inviting female voice
+        "Echo": "echo",     # Clear and precise voice
+        "Fable": "fable",   # Authoritative and narrative voice
+        "Onyx": "onyx",     # Deep and resonant male voice
+        "Nova": "nova",     # Energetic and bright female voice
+        "Sage": "sage",     # Measured and contemplative voice
+        "Shimmer": "shimmer", # Bright and optimistic voice
+        "Verse": "verse"     # Melodic and rhythmic voice
+    }
+
+    def __init__(self, timeout: int = 20, proxies: dict = None):
+        """Initializes the OpenAI.fm TTS client."""
+        super().__init__()
+        self.api_url = "https://www.openai.fm/api/generate"
+        self.session = requests.Session()
+        self.session.headers.update(self.headers)
+        if proxies:
+            self.session.proxies.update(proxies)
+        self.timeout = timeout
+
+    def tts(self, text: str, voice: str = "Coral", instructions: str = None, verbose: bool = True) -> str:
+        """
+        Converts text to speech using the OpenAI.fm API and saves it to a file.
+
+        Args:
+            text (str): The text to convert to speech
+            voice (str): The voice to use for TTS (default: "Coral")
+            instructions (str): Voice instructions/prompt (default: "A cheerful guide. Friendly, clear, and reassuring.")
+            verbose (bool): Whether to print debug information (default: True)
+
+        Returns:
+            str: Path to the generated audio file
+
+        Raises:
+            exceptions.FailedToGenerateResponseError: If there is an error generating or saving the audio.
+        """
+        # Validate input parameters
+        if not text or not isinstance(text, str):
+            raise ValueError("Text input must be a non-empty string")
+        if len(text) > 10000:  # Add reasonable length limit
+            raise ValueError("Text input exceeds maximum allowed length")
+            
+        assert (
+            voice in self.all_voices
+        ), f"Voice '{voice}' not one of [{', '.join(self.all_voices.keys())}]"
+
+        with tempfile.NamedTemporaryFile(suffix=".mp3", dir=self.temp_dir, delete=False) as temp_file:
+            filename = pathlib.Path(temp_file.name)
+        voice_id = self.all_voices[voice]
+        
+        if instructions is None:
+            instructions = "A cheerful guide. Friendly, clear, and reassuring."
+            
+        # Prepare parameters for the API request
+        params = {
+            "input": text,
+            "prompt": instructions,
+            "voice": voice_id
+        }
+
+        try:
+            # Make the API request
+            response = self.session.get(
+                self.api_url,
+                params=params,
+                timeout=self.timeout
+            )
+            response.raise_for_status()
+            
+            # Save the audio file
+            with open(filename, "wb") as f:
+                f.write(response.content)
+                
+            if verbose:
+                print(f"[debug] Audio saved to {filename}")
+                
+            return filename.as_posix()
+            
+        except requests.exceptions.RequestException as e:
+            if verbose:
+                print(f"[debug] Failed to perform the operation: {e}")
+            raise exceptions.FailedToGenerateResponseError(
+                f"Failed to perform the operation: {e}"
+            )
+if __name__ == "__main__":
+    # Example usage
+    tts_provider = OpenAIFMTTS()
+    try:
+        audio_file = tts_provider.tts("Hello, this is a test.", instructions="A cheerful guide. Friendly, clear, and reassuring.", voice="Coral")
+        print(f"Audio file generated: {audio_file}")
+    except exceptions.FailedToGenerateResponseError as e:
+        print(f"Error: {e}")