webscout 8.2.2__py3-none-any.whl → 8.2.3__py3-none-any.whl

webscout/AIbase.py

@@ -68,15 +68,152 @@ class AsyncProvider(ABC):
 class TTSProvider(ABC):
 
     @abstractmethod
-    def tts(self, text: str) -> ImageData:
+    def tts(self, text: str, voice: str = None, verbose: bool = False) -> str:
+        """Convert text to speech and save to a temporary file.
+
+        Args:
+            text (str): The text to convert to speech
+            voice (str, optional): The voice to use. Defaults to provider's default voice.
+            verbose (bool, optional): Whether to print debug information. Defaults to False.
+
+        Returns:
+            str: Path to the generated audio file
+        """
         raise NotImplementedError("Method needs to be implemented in subclass")
 
+    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
+        """
+        import shutil
+        import os
+        from pathlib import Path
+        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 AsyncTTSProvider(ABC):
 
     @abstractmethod
-    async def tts(self, text: str) -> AsyncImageData:
+    async def tts(self, text: str, voice: str = None, verbose: bool = False) -> str:
+        """Convert text to speech and save to a temporary file asynchronously.
+
+        Args:
+            text (str): The text to convert to speech
+            voice (str, optional): The voice to use. Defaults to provider's default voice.
+            verbose (bool, optional): Whether to print debug information. Defaults to False.
+
+        Returns:
+            str: Path to the generated audio file
+        """
         raise NotImplementedError("Method needs to be implemented in subclass")
 
+    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
+        """
+        import shutil
+        import os
+        from pathlib import Path
+        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) -> AsyncGenerator[bytes, None]:
+        """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
+        """
+        import 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
+
 class ImageProvider(ABC):
 
     @abstractmethod
@@ -85,9 +222,9 @@ class ImageProvider(ABC):
 
     @abstractmethod
     def save(
-        self, 
-        response: List[bytes], 
-        name: Optional[str] = None, 
+        self,
+        response: List[bytes],
+        name: Optional[str] = None,
         dir: Optional[Union[str, Path]] = None
     ) -> List[str]:
         raise NotImplementedError("Method needs to be implemented in subclass")
@@ -96,8 +233,8 @@ class AsyncImageProvider(ABC):
 
     @abstractmethod
     async def generate(
-        self, 
-        prompt: str, 
+        self,
+        prompt: str,
         amount: int = 1
     ) -> Union[AsyncGenerator[bytes, None], List[bytes]]:
         raise NotImplementedError("Method needs to be implemented in subclass")

webscout/Provider/Cloudflare.py

@@ -23,6 +23,7 @@ class Cloudflare(Provider):
         "@cf/deepseek-ai/deepseek-r1-distill-qwen-32b",
         "@cf/thebloke/discolm-german-7b-v1-awq",
         "@cf/tiiuae/falcon-7b-instruct",
+        "@cf/google/gemma-3-12b-it",
         "@hf/google/gemma-7b-it",
         "@hf/nousresearch/hermes-2-pro-mistral-7b",
         "@hf/thebloke/llama-2-13b-chat-awq",
@@ -37,12 +38,14 @@ class Cloudflare(Provider):
         "@cf/meta/llama-3.2-1b-instruct",
         "@cf/meta/llama-3.2-3b-instruct",
         "@cf/meta/llama-3.3-70b-instruct-fp8-fast",
+        "@cf/meta/llama-4-scout-17b-16e-instruct",
         "@cf/meta/llama-guard-3-8b",
         "@hf/thebloke/llamaguard-7b-awq",
         "@hf/meta-llama/meta-llama-3-8b-instruct",
         "@cf/mistral/mistral-7b-instruct-v0.1",
         "@hf/thebloke/mistral-7b-instruct-v0.1-awq",
         "@hf/mistral/mistral-7b-instruct-v0.2",
+        "@cf/mistralai/mistral-small-3.1-24b-instruct",
         "@hf/thebloke/neural-chat-7b-v3-1-awq",
         "@cf/openchat/openchat-3.5-0106",
         "@hf/thebloke/openhermes-2.5-mistral-7b-awq",
@@ -51,6 +54,8 @@ class Cloudflare(Provider):
         "@cf/qwen/qwen1.5-1.8b-chat",
         "@cf/qwen/qwen1.5-14b-chat-awq",
         "@cf/qwen/qwen1.5-7b-chat-awq",
+        "@cf/qwen/qwen2.5-coder-32b-instruct",
+        "@cf/qwen/qwq-32b",
         "@cf/defog/sqlcoder-7b-2",
         "@hf/nexusflow/starling-lm-7b-beta",
         "@cf/tinyllama/tinyllama-1.1b-chat-v1.0",

webscout/Provider/OPENAI/textpollinations.py

@@ -8,7 +8,7 @@ from typing import List, Dict, Optional, Union, Generator, Any
 from .base import OpenAICompatibleProvider, BaseChat, BaseCompletions
 from .utils import (
     ChatCompletionChunk, ChatCompletion, Choice, ChoiceDelta,
-    ChatCompletionMessage, CompletionUsage
+    ChatCompletionMessage, CompletionUsage, ToolCall, ToolFunction
 )
 
 # Import LitAgent for browser fingerprinting
@@ -32,6 +32,8 @@ class Completions(BaseCompletions):
         stream: bool = False,
         temperature: Optional[float] = None,
         top_p: Optional[float] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
         **kwargs: Any
     ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
         """
@@ -49,6 +51,10 @@ class Completions(BaseCompletions):
             payload["temperature"] = temperature
         if top_p is not None:
             payload["top_p"] = top_p
+        if tools is not None:
+            payload["tools"] = tools
+        if tool_choice is not None:
+            payload["tool_choice"] = tool_choice
 
         payload.update(kwargs)
 
@@ -95,16 +101,39 @@ class Completions(BaseCompletions):
                             json_data = json.loads(line[6:])
                             if 'choices' in json_data and len(json_data['choices']) > 0:
                                 choice = json_data['choices'][0]
-                                if 'delta' in choice and 'content' in choice['delta']:
-                                    content = choice['delta']['content']
-                                    full_response += content
+                                if 'delta' in choice:
+                                    delta_obj = ChoiceDelta()
+
+                                    # Handle content in delta
+                                    if 'content' in choice['delta']:
+                                        content = choice['delta']['content']
+                                        full_response += content
+                                        delta_obj.content = content
+
+                                    # Handle tool calls in delta
+                                    if 'tool_calls' in choice['delta']:
+                                        tool_calls = []
+                                        for tool_call_data in choice['delta']['tool_calls']:
+                                            if 'function' in tool_call_data:
+                                                function = ToolFunction(
+                                                    name=tool_call_data['function'].get('name', ''),
+                                                    arguments=tool_call_data['function'].get('arguments', '')
+                                                )
+                                                tool_call = ToolCall(
+                                                    id=tool_call_data.get('id', str(uuid.uuid4())),
+                                                    type=tool_call_data.get('type', 'function'),
+                                                    function=function
+                                                )
+                                                tool_calls.append(tool_call)
+
+                                        if tool_calls:
+                                            delta_obj.tool_calls = tool_calls
 
                                     # Create and yield a chunk
-                                    delta = ChoiceDelta(content=content)
-                                    choice = Choice(index=0, delta=delta, finish_reason=None)
+                                    choice_obj = Choice(index=0, delta=delta_obj, finish_reason=None)
                                     chunk = ChatCompletionChunk(
                                         id=request_id,
-                                        choices=[choice],
+                                        choices=[choice_obj],
                                         created=created_time,
                                         model=model
                                     )
@@ -155,18 +184,40 @@ class Completions(BaseCompletions):
 
             # Extract the content
             if 'choices' in response_json and len(response_json['choices']) > 0:
-                if 'message' in response_json['choices'][0]:
-                    full_content = response_json['choices'][0]['message']['content']
+                choice_data = response_json['choices'][0]
+                if 'message' in choice_data:
+                    message_data = choice_data['message']
+
+                    # Extract content
+                    full_content = message_data.get('content', '')
+
+                    # Create the completion message with potential tool calls
+                    message = ChatCompletionMessage(role="assistant", content=full_content)
+
+                    # Handle tool calls if present
+                    if 'tool_calls' in message_data:
+                        tool_calls = []
+                        for tool_call_data in message_data['tool_calls']:
+                            if 'function' in tool_call_data:
+                                function = ToolFunction(
+                                    name=tool_call_data['function'].get('name', ''),
+                                    arguments=tool_call_data['function'].get('arguments', '')
+                                )
+                                tool_call = ToolCall(
+                                    id=tool_call_data.get('id', str(uuid.uuid4())),
+                                    type=tool_call_data.get('type', 'function'),
+                                    function=function
+                                )
+                                tool_calls.append(tool_call)
+
+                        if tool_calls:
+                            message.tool_calls = tool_calls
                 else:
-                    full_content = ""
+                    # Fallback if no message is present
+                    message = ChatCompletionMessage(role="assistant", content="")
             else:
-                full_content = ""
-
-            # Create the completion message
-            message = ChatCompletionMessage(
-                role="assistant",
-                content=full_content
-            )
+                # Fallback if no choices are present
+                message = ChatCompletionMessage(role="assistant", content="")
 
             # Create the choice
             choice = Choice(
@@ -217,33 +268,28 @@ class TextPollinations(OpenAICompatibleProvider):
     """
 
     AVAILABLE_MODELS = [
-        "openai",
-        "openai-large",
-        "openai-reasoning",
-        "qwen-coder",
-        "llama",
-        "llamascout",
-        "mistral",
-        "unity",
-        "midijourney",
-        "rtist",
-        "searchgpt",
-        "evil",
-        "deepseek-reasoning",
-        "deepseek-reasoning-large",
-        "llamalight",
-        "phi",
-        "llama-vision",
-        "pixtral",
-        "gemini",
-        "hormoz",
-        "hypnosis-tracy",
-        "mistral-roblox",
-        "roblox-rp",
-        "deepseek",
-        "sur",
-        "llama-scaleway",
-        "openai-audio",
+        "openai",              # OpenAI GPT-4.1-nano (Azure) - vision capable
+        "openai-large",        # OpenAI GPT-4.1 mini (Azure) - vision capable
+        "openai-reasoning",    # OpenAI o4-mini (Azure) - vision capable, reasoning
+        "qwen-coder",          # Qwen 2.5 Coder 32B (Scaleway)
+        "llama",               # Llama 3.3 70B (Cloudflare)
+        "llamascout",          # Llama 4 Scout 17B (Cloudflare)
+        "mistral",             # Mistral Small 3 (Scaleway) - vision capable
+        "unity",               # Unity Mistral Large (Scaleway) - vision capable, uncensored
+        "midijourney",         # Midijourney (Azure)
+        "rtist",               # Rtist (Azure)
+        "searchgpt",           # SearchGPT (Azure) - vision capable
+        "evil",                # Evil (Scaleway) - vision capable, uncensored
+        "deepseek-reasoning",  # DeepSeek-R1 Distill Qwen 32B (Cloudflare) - reasoning
+        "deepseek-reasoning-large", # DeepSeek R1 - Llama 70B (Scaleway) - reasoning
+        "phi",                 # Phi-4 Instruct (Cloudflare) - vision and audio capable
+        "llama-vision",        # Llama 3.2 11B Vision (Cloudflare) - vision capable
+        "gemini",              # gemini-2.5-flash-preview-04-17 (Azure) - vision and audio capable
+        "hormoz",              # Hormoz 8b (Modal)
+        "hypnosis-tracy",      # Hypnosis Tracy 7B (Azure) - audio capable
+        "deepseek",            # DeepSeek-V3 (DeepSeek)
+        "sur",                 # Sur AI Assistant (Mistral) (Scaleway) - vision capable
+        "openai-audio",        # OpenAI GPT-4o-audio-preview (Azure) - vision and audio capable
     ]
 
     def __init__(

webscout/Provider/OPENAI/toolbaz.py

@@ -284,20 +284,20 @@ class Toolbaz(OpenAICompatibleProvider):
     """
 
     AVAILABLE_MODELS = [
+        "gemini-2.5-flash",
         "gemini-2.0-flash-thinking",
         "gemini-2.0-flash",
         "gemini-1.5-flash",
         "gpt-4o-latest",
-        "gpt-4o-mini",
         "gpt-4o",
         "deepseek-r1",
+        "Llama-4-Maverick",
+        "Llama-4-Scout",
         "Llama-3.3-70B",
-        "Llama-3.1-405B",
-        "Llama-3.1-70B",
         "Qwen2.5-72B",
         "Qwen2-72B",
         "grok-2-1212",
-        "grok-beta",
+        "grok-3-beta",
         "toolbaz_v3.5_pro",
         "toolbaz_v3",
         "mixtral_8x22b",

webscout/Provider/TTS/__init__.py

@@ -1,3 +1,4 @@
+from .base import BaseTTSProvider, AsyncBaseTTSProvider
 from .streamElements import *
 from .parler import *
 from .deepgram 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

webscout/Provider/TTS/deepgram.py

@@ -5,12 +5,12 @@ import base64
 import tempfile
 from io import BytesIO
 from webscout import exceptions
-from webscout.AIbase import TTSProvider
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from webscout.litagent import LitAgent
-from . import utils 
+from . import utils
+from .base import BaseTTSProvider
 
-class DeepgramTTS(TTSProvider): 
+class DeepgramTTS(BaseTTSProvider):
     """
     Text-to-speech provider using the DeepgramTTS API.
     """
@@ -27,12 +27,12 @@ class DeepgramTTS(TTSProvider):
 
     def __init__(self, timeout: int = 20, proxies: dict = None):
         """Initializes the DeepgramTTS TTS client."""
+        super().__init__()
         self.session = requests.Session()
         self.session.headers.update(self.headers)
         if proxies:
             self.session.proxies.update(proxies)
         self.timeout = timeout
-        self.temp_dir = tempfile.mkdtemp(prefix="webscout_tts_")
 
     def tts(self, text: str, voice: str = "Brian", verbose: bool = True) -> str:
         """
@@ -80,15 +80,15 @@ class DeepgramTTS(TTSProvider):
             """
             max_retries = 3
             retry_count = 0
-            
+
             while retry_count < max_retries:
                 try:
                     payload = {"text": part_text, "model": self.all_voices[voice]}
                     response = self.session.post(
-                        url=url, 
-                        headers=self.headers, 
-                        json=payload, 
-                        stream=True, 
+                        url=url,
+                        headers=self.headers,
+                        json=payload,
+                        stream=True,
                         timeout=self.timeout
                     )
                     response.raise_for_status()
@@ -99,29 +99,29 @@ class DeepgramTTS(TTSProvider):
                         if verbose:
                             print(f"[debug] Chunk {part_number} processed successfully")
                         return part_number, audio_data
-                    
+
                     if verbose:
                         print(f"[debug] No data received for chunk {part_number}. Attempt {retry_count + 1}/{max_retries}")
-                    
+
                 except requests.RequestException as e:
                     if verbose:
                         print(f"[debug] Error processing chunk {part_number}: {str(e)}. Attempt {retry_count + 1}/{max_retries}")
                     if retry_count == max_retries - 1:
                         raise
-                
+
                 retry_count += 1
                 time.sleep(1)
-            
+
             raise RuntimeError(f"Failed to generate audio for chunk {part_number} after {max_retries} attempts")
 
         try:
             # Using ThreadPoolExecutor to handle requests concurrently
             with ThreadPoolExecutor() as executor:
                 futures = {
-                    executor.submit(generate_audio_for_chunk, sentence.strip(), chunk_num): chunk_num 
+                    executor.submit(generate_audio_for_chunk, sentence.strip(), chunk_num): chunk_num
                     for chunk_num, sentence in enumerate(sentences, start=1)
                 }
-                
+
                 # Dictionary to store results with order preserved
                 audio_chunks = {}
 
@@ -152,5 +152,5 @@ if __name__ == "__main__":
     text = "This is a test of the DeepgramTTS text-to-speech API. It supports multiple sentences. Let's see how it works!"
 
     print("[debug] Generating audio...")
-    audio_file = deepgram.tts(text, voice="Asteria") 
+    audio_file = deepgram.tts(text, voice="Asteria")
     print(f"Audio saved to: {audio_file}")