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

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}")

webscout/Provider/TTS/elevenlabs.py

@@ -4,12 +4,12 @@ import pathlib
 import tempfile
 from io import BytesIO
 from webscout import exceptions
-from webscout.AIbase import TTSProvider
 from webscout.litagent import LitAgent
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from . import utils
+from .base import BaseTTSProvider
 
-class ElevenlabsTTS(TTSProvider): 
+class ElevenlabsTTS(BaseTTSProvider):
     """
     Text-to-speech provider using the ElevenlabsTTS API.
     """
@@ -21,13 +21,13 @@ class ElevenlabsTTS(TTSProvider):
 
     def __init__(self, timeout: int = 20, proxies: dict = None):
         """Initializes the ElevenlabsTTS 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.params = {'allow_unauthenticated': '1'}
-        self.temp_dir = tempfile.mkdtemp(prefix="webscout_tts_")
 
     def tts(self, text: str, voice: str = "Brian", verbose:bool = True) -> str:
         """
@@ -65,9 +65,9 @@ class ElevenlabsTTS(TTSProvider):
         try:
             # Using ThreadPoolExecutor to handle requests concurrently
             with ThreadPoolExecutor() as executor:
-                futures = {executor.submit(generate_audio_for_chunk, sentence.strip(), chunk_num): chunk_num 
+                futures = {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 = {}
 

webscout/Provider/TTS/gesserit.py

@@ -4,12 +4,12 @@ import pathlib
 import base64
 from io import BytesIO
 from webscout import exceptions
-from webscout.AIbase import TTSProvider
 from webscout.litagent import LitAgent
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from . import utils
+from .base import BaseTTSProvider
 
-class GesseritTTS(TTSProvider): 
+class GesseritTTS(BaseTTSProvider):
     """Text-to-speech provider using the GesseritTTS API."""
     # Request headers
     headers: dict[str, str] = {
@@ -30,6 +30,7 @@ class GesseritTTS(TTSProvider):
 
     def __init__(self, timeout: int = 20, proxies: dict = None):
         """Initializes the GesseritTTS TTS client."""
+        super().__init__()
         self.session = requests.Session()
         self.session.headers.update(self.headers)
         if proxies:
@@ -61,7 +62,7 @@ class GesseritTTS(TTSProvider):
                     response.raise_for_status()
 
                     # Create the audio_cache directory if it doesn't exist
-                    self.cache_dir.mkdir(parents=True, exist_ok=True) 
+                    self.cache_dir.mkdir(parents=True, exist_ok=True)
 
                     # Check if the request was successful
                     if response.ok and response.status_code == 200:
@@ -81,9 +82,9 @@ class GesseritTTS(TTSProvider):
         try:
             # Using ThreadPoolExecutor to handle requests concurrently
             with ThreadPoolExecutor() as executor:
-                futures = {executor.submit(generate_audio_for_chunk, sentence.strip(), chunk_num): chunk_num 
+                futures = {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 = {}
 

webscout/Provider/TTS/murfai.py

@@ -5,12 +5,12 @@ import tempfile
 from io import BytesIO
 from urllib.parse import urlencode
 from webscout import exceptions
-from webscout.AIbase import TTSProvider
 from webscout.litagent import LitAgent
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from . import utils
+from .base import BaseTTSProvider
 
-class MurfAITTS(TTSProvider):
+class MurfAITTS(BaseTTSProvider):
     """Text-to-speech provider using the MurfAITTS API."""
     # Request headers
     headers: dict[str, str] = {
@@ -20,12 +20,12 @@ class MurfAITTS(TTSProvider):
 
     def __init__(self, timeout: int = 20, proxies: dict = None):
         """Initializes the MurfAITTS 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 = "Hazel", verbose:bool = True) -> str:
         """Converts text to speech using the MurfAITTS API and saves it to a file."""
@@ -45,7 +45,7 @@ class MurfAITTS(TTSProvider):
             while True:
                 try:
                     params: dict[str, str] = {
-                    "name": voice_id, 
+                    "name": voice_id,
                     "text": part_text
                     }
                     encode_param: str = urlencode(params)
@@ -67,9 +67,9 @@ class MurfAITTS(TTSProvider):
         try:
             # Using ThreadPoolExecutor to handle requests concurrently
             with ThreadPoolExecutor() as executor:
-                futures = {executor.submit(generate_audio_for_chunk, sentence.strip(), chunk_num): chunk_num 
+                futures = {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 = {}
 
@@ -109,5 +109,5 @@ if __name__ == "__main__":
     text = "This is a test of the MurfAITTS text-to-speech API. It supports multiple sentences and advanced logging."
 
     print("[debug] Generating audio...")
-    audio_file = murfai.tts(text, voice="Hazel") 
+    audio_file = murfai.tts(text, voice="Hazel")
     print(f"Audio saved to: {audio_file}")

webscout/Provider/TTS/parler.py

@@ -2,22 +2,22 @@ import time
 import tempfile
 from pathlib import Path
 from webscout import exceptions
-from webscout.AIbase import TTSProvider
 from gradio_client import Client
 import os
+from .base import BaseTTSProvider
 
 
-class ParlerTTS(TTSProvider):
+class ParlerTTS(BaseTTSProvider):
     """
     A class to interact with the Parler TTS API through Gradio Client.
     """
 
     def __init__(self, timeout: int = 20, proxies: dict = None):
         """Initializes the Parler TTS client."""
+        super().__init__()
         self.api_endpoint = "/gen_tts"
         self.client = Client("parler-tts/parler_tts")  # Initialize the Gradio client
         self.timeout = timeout
-        self.temp_dir = tempfile.mkdtemp(prefix="webscout_tts_")
 
     def tts(self, text: str, description: str = "", use_large: bool = False, verbose: bool = True) -> str:
         """
@@ -40,7 +40,7 @@ class ParlerTTS(TTSProvider):
         try:
             if verbose:
                 print(f"[debug] Generating TTS with description: {description}")
-            
+
             result = self.client.predict(
                 text=text,
                 description=description,
@@ -57,10 +57,10 @@ class ParlerTTS(TTSProvider):
                 raise ValueError(f"Unexpected response from API: {result}")
 
             self._save_audio(audio_bytes, filename, verbose)
-            
+
             if verbose:
                 print(f"[debug] Audio generated successfully: {filename}")
-            
+
             return filename.as_posix()
 
         except Exception as e:

webscout/Provider/TTS/speechma.py

@@ -7,12 +7,12 @@ import pathlib
 import tempfile
 from io import BytesIO
 from webscout import exceptions
-from webscout.AIbase import TTSProvider
 from webscout.litagent import LitAgent
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from . import utils
+from .base import BaseTTSProvider
 
-class SpeechMaTTS(TTSProvider):
+class SpeechMaTTS(BaseTTSProvider):
     """
     Text-to-speech provider using the SpeechMa API.
     """
@@ -25,7 +25,7 @@ class SpeechMaTTS(TTSProvider):
         "priority": "u=1, i",
         "User-Agent": LitAgent().random()
     }
-    
+
     # Available voices with their IDs
     all_voices = {
         "Ava": "voice-110",     # Multilingual female voice
@@ -36,13 +36,13 @@ class SpeechMaTTS(TTSProvider):
 
     def __init__(self, timeout: int = 20, proxies: dict = None):
         """Initializes the SpeechMa TTS client."""
+        super().__init__()
         self.api_url = "https://speechma.com/com.api/tts-api.php"
         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 = "Emma", pitch: int = 0, rate: int = 0, verbose: bool = False) -> str:
         """
@@ -57,7 +57,7 @@ class SpeechMaTTS(TTSProvider):
 
         Returns:
             str: Path to the generated audio file
-        
+
         Raises:
             exceptions.FailedToGenerateResponseError: If there is an error generating or saving the audio.
         """
@@ -66,26 +66,26 @@ class SpeechMaTTS(TTSProvider):
         ), f"Voice '{voice}' not one of [{', '.join(self.all_voices.keys())}]"
 
         filename = pathlib.Path(tempfile.mktemp(suffix=".mp3", dir=self.temp_dir))
-        
+
         # Get the voice ID
         voice_id = self.all_voices[voice]
-        
+
         if verbose:
             print(f"[debug] Using voice: {voice} (ID: {voice_id})")
-        
+
         # Split text into sentences for better processing
         sentences = utils.split_sentences(text)
-        
+
         if verbose:
             print(f"[debug] Text split into {len(sentences)} sentences")
-        
+
         # Function to request audio for each chunk
         def generate_audio_for_chunk(part_text: str, part_number: int):
             while True:
                 try:
                     if verbose:
                         print(f"[debug] Processing chunk {part_number}: '{part_text[:30]}...'")
-                    
+
                     # Prepare payload for this sentence
                     payload = {
                         "text": part_text,
@@ -93,11 +93,11 @@ class SpeechMaTTS(TTSProvider):
                         "pitch": pitch,
                         "rate": rate
                     }
-                    
+
                     response = self.session.post(
-                        self.api_url, 
-                        headers=self.headers, 
-                        json=payload, 
+                        self.api_url,
+                        headers=self.headers,
+                        json=payload,
                         timeout=self.timeout
                     )
                     response.raise_for_status()
@@ -115,23 +115,23 @@ class SpeechMaTTS(TTSProvider):
                     else:
                         if verbose:
                             print(f"[debug] Failed request for chunk {part_number} (status code: {response.status_code}). Retrying...")
-                    
+
                     # If we get here, something went wrong with the request
                     time.sleep(1)
                 except requests.RequestException as e:
                     if verbose:
                         print(f"[debug] Error for chunk {part_number}: {e}. Retrying...")
                     time.sleep(1)
-        
+
         try:
             if verbose:
                 print(f"[debug] Starting concurrent audio generation for {len(sentences)} chunks")
-            
+
             # Using ThreadPoolExecutor to handle requests concurrently
             with ThreadPoolExecutor() as executor:
-                futures = {executor.submit(generate_audio_for_chunk, sentence.strip(), chunk_num): chunk_num 
+                futures = {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 = {}
 
@@ -159,10 +159,10 @@ class SpeechMaTTS(TTSProvider):
             # Save the combined audio data to a single file
             with open(filename, 'wb') as f:
                 f.write(combined_audio.getvalue())
-                
+
             if verbose:
                 print(f"[debug] Final audio saved as {filename}")
-                
+
             return filename.as_posix()
 
         except requests.exceptions.RequestException as e:

webscout/Provider/TTS/streamElements.py

@@ -6,12 +6,12 @@ import tempfile
 from typing import Union
 from io import BytesIO
 from webscout import exceptions
-from webscout.AIbase import TTSProvider
 from webscout.litagent import LitAgent
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from . import utils
+from .base import BaseTTSProvider
 
-class StreamElements(TTSProvider): 
+class StreamElements(BaseTTSProvider):
     """
     Text-to-speech provider using the StreamElements API.
     """
@@ -231,12 +231,12 @@ class StreamElements(TTSProvider):
 
     def __init__(self, timeout: int = 20, proxies: dict = None):
         """Initializes the StreamElements 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 = "Mathieu", verbose: bool = True) -> str:
         """
@@ -266,9 +266,9 @@ class StreamElements(TTSProvider):
                     # URL encode the text and voice
                     encoded_text = urllib.parse.quote(part_text)
                     encoded_voice = urllib.parse.quote(voice)
-                    
+
                     url = f"https://streamelements.com/tts/{encoded_voice}/{encoded_text}"
-                    
+
                     response = self.session.get(url, headers=self.headers, timeout=self.timeout)
                     response.raise_for_status()
 
@@ -287,9 +287,9 @@ class StreamElements(TTSProvider):
         try:
             # Using ThreadPoolExecutor to handle requests concurrently
             with ThreadPoolExecutor() as executor:
-                futures = {executor.submit(generate_audio_for_chunk, sentence.strip(), chunk_num): chunk_num 
+                futures = {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 = {}
 

webscout/Provider/TextPollinationsAI.py

@@ -1,6 +1,6 @@
 import requests
 import json
-from typing import Union, Any, Dict, Generator
+from typing import Union, Any, Dict, Generator, Optional, List
 from webscout.AIutel import Optimizers, Conversation, AwesomePrompts
 from webscout.AIbase import Provider
 from webscout import exceptions
@@ -12,33 +12,28 @@ class TextPollinationsAI(Provider):
     """
 
     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__(
@@ -68,14 +63,14 @@ class TextPollinationsAI(Provider):
         self.last_response = {}
         self.model = model
         self.system_prompt = system_prompt
-        
+
         self.headers = {
             'Accept': '*/*',
             'Accept-Language': 'en-US,en;q=0.9',
             'User-Agent': Lit().random(),
             'Content-Type': 'application/json',
         }
-        
+
         self.session.headers.update(self.headers)
         self.session.proxies = proxies
 
@@ -104,6 +99,8 @@ class TextPollinationsAI(Provider):
         raw: bool = False,
         optimizer: str = None,
         conversationally: bool = False,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        tool_choice: Optional[Dict[str, Any]] = None,
     ) -> Union[Dict[str, Any], Generator[Any, None, None]]:
         """Chat with AI"""
         conversation_prompt = self.conversation.gen_complete_prompt(prompt)
@@ -124,6 +121,12 @@ class TextPollinationsAI(Provider):
             "stream": stream,
         }
 
+        # Add function calling parameters if provided
+        if tools:
+            payload["tools"] = tools
+        if tool_choice:
+            payload["tool_choice"] = tool_choice
+
         def for_stream():
             response = self.session.post(
                 self.api_endpoint,
@@ -149,12 +152,15 @@ class TextPollinationsAI(Provider):
                             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']
-                                else:
-                                    content = ""
-                                full_response += content
-                                yield content if raw else dict(text=content)
+                                if 'delta' in choice:
+                                    if 'content' in choice['delta']:
+                                        content = choice['delta']['content']
+                                        full_response += content
+                                        yield content if raw else dict(text=content)
+                                    elif 'tool_calls' in choice['delta']:
+                                        # Handle tool calls in streaming response
+                                        tool_calls = choice['delta']['tool_calls']
+                                        yield tool_calls if raw else dict(tool_calls=tool_calls)
                         except json.JSONDecodeError:
                             continue
 
@@ -176,11 +182,14 @@ class TextPollinationsAI(Provider):
         stream: bool = False,
         optimizer: str = None,
         conversationally: bool = False,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        tool_choice: Optional[Dict[str, Any]] = None,
     ) -> Union[str, Generator[str, None, None]]:
         """Generate response as a string"""
         def for_stream():
             for response in self.ask(
-                prompt, True, optimizer=optimizer, conversationally=conversationally
+                prompt, True, optimizer=optimizer, conversationally=conversationally,
+                tools=tools, tool_choice=tool_choice
             ):
                 yield self.get_message(response)
 
@@ -191,6 +200,8 @@ class TextPollinationsAI(Provider):
                     False,
                     optimizer=optimizer,
                     conversationally=conversationally,
+                    tools=tools,
+                    tool_choice=tool_choice,
                 )
             )
 
@@ -199,17 +210,21 @@ class TextPollinationsAI(Provider):
     def get_message(self, response: dict) -> str:
         """Retrieves message only from response"""
         assert isinstance(response, dict), "Response should be of dict data-type only"
-        return response["text"]
+        if "text" in response:
+            return response["text"]
+        elif "tool_calls" in response:
+            # For tool calls, return a string representation
+            return json.dumps(response["tool_calls"])
 
 if __name__ == "__main__":
     print("-" * 80)
     print(f"{'Model':<50} {'Status':<10} {'Response'}")
     print("-" * 80)
-    
+
     # Test all available models
     working = 0
     total = len(TextPollinationsAI.AVAILABLE_MODELS)
-    
+
     for model in TextPollinationsAI.AVAILABLE_MODELS:
         try:
             test_ai = TextPollinationsAI(model=model, timeout=60)
@@ -218,7 +233,7 @@ if __name__ == "__main__":
             for chunk in response:
                 response_text += chunk
                 print(f"\r{model:<50} {'Testing...':<10}", end="", flush=True)
-            
+
             if response_text and len(response_text.strip()) > 0:
                 status = "✓"
                 # Truncate response if too long