webscout 7.5__py3-none-any.whl → 7.6__py3-none-any.whl

webscout/Provider/TTS/murfai.py

@@ -1,12 +1,11 @@
 import time
 import requests
 import pathlib
+import tempfile
 from io import BytesIO
 from urllib.parse import urlencode
-from playsound import playsound
 from webscout import exceptions
 from webscout.AIbase import TTSProvider
-from webscout.Litlogger import Logger, LogFormat
 from webscout.litagent import LitAgent
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from . import utils
@@ -17,7 +16,6 @@ class MurfAITTS(TTSProvider):
     headers: dict[str, str] = {
         "User-Agent": LitAgent().random()
     }
-    cache_dir = pathlib.Path("./audio_cache")
     all_voices: dict[str, str] = {"Hazel": "en-UK-hazel"}
 
     def __init__(self, timeout: int = 20, proxies: dict = None):
@@ -27,11 +25,7 @@ class MurfAITTS(TTSProvider):
         if proxies:
             self.session.proxies.update(proxies)
         self.timeout = timeout
-        self.logger = Logger(
-            name="MurfAITTS",
-            format=LogFormat.MODERN_EMOJI,
-
-        )
+        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."""
@@ -39,7 +33,7 @@ class MurfAITTS(TTSProvider):
             voice in self.all_voices
         ), f"Voice '{voice}' not one of [{', '.join(self.all_voices.keys())}]"
 
-        filename = self.cache_dir / f"{int(time.time())}.mp3"
+        filename = pathlib.Path(tempfile.mktemp(suffix=".mp3", dir=self.temp_dir))
 
         voice_id = self.all_voices[voice]
 
@@ -58,20 +52,17 @@ class MurfAITTS(TTSProvider):
                     response = self.session.get(f"https://murf.ai/Prod/anonymous-tts/audio?{encode_param}", headers=self.headers, timeout=self.timeout)
                     response.raise_for_status()
 
-                    # Create the audio_cache directory if it doesn't exist
-                    self.cache_dir.mkdir(parents=True, exist_ok=True) 
-
                     # Check if the request was successful
                     if response.ok and response.status_code == 200:
                         if verbose:
-                            self.logger.success(f"Chunk {part_number} processed successfully 🎉")
+                            print(f"[debug] Chunk {part_number} processed successfully")
                         return part_number, response.content
                     else:
                         if verbose:
-                            self.logger.warning(f"No data received for chunk {part_number}. Retrying...")
+                            print(f"[debug] No data received for chunk {part_number}. Retrying...")
                 except requests.RequestException as e:
                     if verbose:
-                        self.logger.error(f"Error for chunk {part_number}: {e}. Retrying... 🔄")
+                        print(f"[debug] Error for chunk {part_number}: {e}. Retrying...")
                     time.sleep(1)
         try:
             # Using ThreadPoolExecutor to handle requests concurrently
@@ -89,51 +80,34 @@ class MurfAITTS(TTSProvider):
                         audio_chunks[part_number] = audio_data  # Store the audio data in correct sequence
                     except Exception as e:
                         if verbose:
-                            self.logger.error(f"Failed to generate audio for chunk {chunk_num}: {e} 🚨")
+                            print(f"[debug] Failed to generate audio for chunk {chunk_num}: {e}")
 
             # Combine audio chunks in the correct sequence
             combined_audio = BytesIO()
             for part_number in sorted(audio_chunks.keys()):
                 combined_audio.write(audio_chunks[part_number])
                 if verbose:
-                    self.logger.debug(f"Added chunk {part_number} to the combined file.")
+                    print(f"[debug] Added chunk {part_number} to the combined file.")
 
             # Save the combined audio data to a single file
             with open(filename, 'wb') as f:
                 f.write(combined_audio.getvalue())
             if verbose:
-                self.logger.info(f"Final Audio Saved as {filename} 🔊")
+                print(f"[debug] Final Audio Saved as {filename}")
             return filename.as_posix()
 
         except requests.exceptions.RequestException as e:
-            self.logger.critical(f"Failed to perform the operation: {e} 🚨")
+            if verbose:
+                print(f"[debug] Failed to perform the operation: {e}")
             raise exceptions.FailedToGenerateResponseError(
                 f"Failed to perform the operation: {e}"
             )
-        
-    def play_audio(self, filename: str):
-        """
-        Plays an audio file using playsound.
-
-        Args:
-            filename (str): The path to the audio file.
-
-        Raises:
-            RuntimeError: If there is an error playing the audio.
-        """
-        try:
-            playsound(filename)
-        except Exception as e:
-            self.logger.error(f"Error playing audio: {e} 🔇")
-            raise RuntimeError(f"Error playing audio: {e}")
 
 # Example usage
 if __name__ == "__main__":
     murfai = MurfAITTS()
     text = "This is a test of the MurfAITTS text-to-speech API. It supports multiple sentences and advanced logging."
 
-    murfai.logger.info("Generating audio...")
+    print("[debug] Generating audio...")
     audio_file = murfai.tts(text, voice="Hazel") 
-
-    murfai.logger.info("Playing audio...")
-    murfai.play_audio(audio_file)
+    print(f"Audio saved to: {audio_file}")

webscout/Provider/TTS/parler.py

@@ -1,10 +1,8 @@
 import time
+import tempfile
 from pathlib import Path
-from typing import Generator
-from playsound import playsound
 from webscout import exceptions
 from webscout.AIbase import TTSProvider
-from webscout.Litlogger import Logger, LogFormat
 from gradio_client import Client
 import os
 
@@ -19,11 +17,7 @@ class ParlerTTS(TTSProvider):
         self.api_endpoint = "/gen_tts"
         self.client = Client("parler-tts/parler_tts")  # Initialize the Gradio client
         self.timeout = timeout
-        self.audio_cache_dir = Path("./audio_cache")
-        self.logger = Logger(
-            name="ParlerTTS",
-            format=LogFormat.MODERN_EMOJI,
-        )
+        self.temp_dir = tempfile.mkdtemp(prefix="webscout_tts_")
 
     def tts(self, text: str, description: str = "", use_large: bool = False, verbose: bool = True) -> str:
         """
@@ -41,11 +35,11 @@ class ParlerTTS(TTSProvider):
         Raises:
             exceptions.FailedToGenerateResponseError: If there is an error generating or saving the audio.
         """
-        filename = self.audio_cache_dir / f"{int(time.time())}.wav"
+        filename = Path(tempfile.mktemp(suffix=".wav", dir=self.temp_dir))
 
         try:
             if verbose:
-                self.logger.info(f"Generating TTS with description: {description} 🎙️")
+                print(f"[debug] Generating TTS with description: {description}")
             
             result = self.client.predict(
                 text=text,
@@ -62,58 +56,43 @@ class ParlerTTS(TTSProvider):
             else:
                 raise ValueError(f"Unexpected response from API: {result}")
 
-            self._save_audio(audio_bytes, filename)
+            self._save_audio(audio_bytes, filename, verbose)
             
             if verbose:
-                self.logger.success(f"Audio generated successfully: {filename} 🔊")
+                print(f"[debug] Audio generated successfully: {filename}")
             
             return filename.as_posix()
 
         except Exception as e:
-            self.logger.critical(f"Error generating audio: {e} 🚨")
+            if verbose:
+                print(f"[debug] Error generating audio: {e}")
             raise exceptions.FailedToGenerateResponseError(
                 f"Error generating audio after multiple retries: {e}"
             ) from e
 
-    def _save_audio(self, audio_data: bytes, filename: Path):
+    def _save_audio(self, audio_data: bytes, filename: Path, verbose: bool = True):
         """
-        Saves the audio data to a WAV file in the audio cache directory.
+        Saves the audio data to a WAV file.
 
         Args:
             audio_data (bytes): Audio data to save
             filename (Path): Path to save the audio file
+            verbose (bool): Whether to print debug information
 
         Raises:
             exceptions.FailedToGenerateResponseError: If there is an error saving the audio.
         """
         try:
-            self.audio_cache_dir.mkdir(parents=True, exist_ok=True)
             with open(filename, "wb") as f:
                 f.write(audio_data)
-            self.logger.debug(f"Audio saved to {filename} 💾")
+            if verbose:
+                print(f"[debug] Audio saved to {filename}")
 
         except Exception as e:
-            self.logger.error(f"Error saving audio: {e} 🔇")
+            if verbose:
+                print(f"[debug] Error saving audio: {e}")
             raise exceptions.FailedToGenerateResponseError(f"Error saving audio: {e}")
 
-    def play_audio(self, filename: str):
-        """
-        Plays an audio file using playsound.
-
-        Args:
-            filename (str): The path to the audio file.
-
-        Raises:
-            RuntimeError: If there is an error playing the audio.
-        """
-        try:
-            self.logger.info(f"Playing audio: {filename} 🎵")
-            playsound(filename)
-        except Exception as e:
-            self.logger.error(f"Error playing audio: {e} 🔇")
-            raise RuntimeError(f"Error playing audio: {e}")
-
-
 # Example usage
 if __name__ == "__main__":
     parlertts = ParlerTTS()
@@ -127,8 +106,6 @@ if __name__ == "__main__":
         "recording that almost has no background noise."
     )
 
-    parlertts.logger.info("Generating audio...")
+    print("[debug] Generating audio...")
     audio_file = parlertts.tts(text, description=voice_description, use_large=False)
-
-    parlertts.logger.info("Playing audio...")
-    parlertts.play_audio(audio_file)
+    print(f"Audio saved to: {audio_file}")

webscout/Provider/TTS/speechma.py

@@ -0,0 +1,180 @@
+##################################################################################
+##  Modified version of code written by t.me/infip1217                          ##
+##################################################################################
+import time
+import requests
+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
+
+class SpeechMaTTS(TTSProvider):
+    """
+    Text-to-speech provider using the SpeechMa API.
+    """
+    # Request headers
+    headers = {
+        "accept": "*/*",
+        "accept-language": "en-IN,en-GB;q=0.9,en-US;q=0.8,en;q=0.7,en-AU;q=0.6",
+        "content-type": "application/json",
+        "origin": "https://speechma.com",
+        "priority": "u=1, i",
+        "User-Agent": LitAgent().random()
+    }
+    
+    # Available voices with their IDs
+    all_voices = {
+        "Ava": "voice-110",     # Multilingual female voice
+        "Emma": "voice-115",    # Multilingual female voice
+        "Andrew": "voice-107",  # Multilingual male voice
+        "Brian": "voice-112"    # Multilingual male voice
+    }
+
+    def __init__(self, timeout: int = 20, proxies: dict = None):
+        """Initializes the SpeechMa TTS client."""
+        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:
+        """
+        Converts text to speech using the SpeechMa 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: "Emma")
+            pitch (int): Voice pitch adjustment (-10 to 10, default: 0)
+            rate (int): Voice rate/speed adjustment (-10 to 10, default: 0)
+            verbose (bool): Whether to print progress messages (default: True)
+
+        Returns:
+            str: Path to the generated audio file
+        
+        Raises:
+            exceptions.FailedToGenerateResponseError: If there is an error generating or saving the audio.
+        """
+        assert (
+            voice in self.all_voices
+        ), 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,
+                        "voice": voice_id,
+                        "pitch": pitch,
+                        "rate": rate
+                    }
+                    
+                    response = self.session.post(
+                        self.api_url, 
+                        headers=self.headers, 
+                        json=payload, 
+                        timeout=self.timeout
+                    )
+                    response.raise_for_status()
+
+                    # Check if the request was successful
+                    if response.ok and response.status_code == 200:
+                        # Ensure we got audio data
+                        if len(response.content) > 100:  # Basic check for actual content
+                            if verbose:
+                                print(f"[debug] Chunk {part_number} processed successfully")
+                            return part_number, response.content
+                        else:
+                            if verbose:
+                                print(f"[debug] Received too small response for chunk {part_number}. Retrying...")
+                    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 
+                        for chunk_num, sentence in enumerate(sentences, start=1)}
+                
+                # Dictionary to store results with order preserved
+                audio_chunks = {}
+
+                for future in as_completed(futures):
+                    chunk_num = futures[future]
+                    try:
+                        part_number, audio_data = future.result()
+                        audio_chunks[part_number] = audio_data  # Store the audio data in correct sequence
+                        if verbose:
+                            print(f"[debug] Received audio data for chunk {part_number}")
+                    except Exception as e:
+                        if verbose:
+                            print(f"[debug] Failed to generate audio for chunk {chunk_num}: {e}")
+
+            if verbose:
+                print(f"[debug] Successfully processed {len(audio_chunks)}/{len(sentences)} chunks")
+
+            # Combine audio chunks in the correct sequence
+            combined_audio = BytesIO()
+            for part_number in sorted(audio_chunks.keys()):
+                combined_audio.write(audio_chunks[part_number])
+                if verbose:
+                    print(f"[debug] Added chunk {part_number} to the combined file")
+
+            # 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:
+            if verbose:
+                print(f"[debug] Failed to perform the operation: {e}")
+            raise exceptions.FailedToGenerateResponseError(
+                f"Failed to perform the operation: {e}"
+            )
+
+# Example usage
+if __name__ == "__main__":
+    speechma = SpeechMaTTS()
+    text = "This is a test of the SpeechMa text-to-speech API. It supports multiple sentences."
+    audio_file = speechma.tts(text, voice="Emma")
+    print(f"Audio saved to: {audio_file}")

webscout/Provider/TTS/streamElements.py

@@ -2,15 +2,14 @@ import time
 import requests
 import pathlib
 import urllib.parse
-from typing import Union, Generator
-from playsound import playsound
+import tempfile
+from typing import Union
+from io import BytesIO
 from webscout import exceptions
 from webscout.AIbase import TTSProvider
-from webscout.Litlogger import Logger, LogFormat
 from webscout.litagent import LitAgent
-from . import utils
 from concurrent.futures import ThreadPoolExecutor, as_completed
-from io import BytesIO
+from . import utils
 
 class StreamElements(TTSProvider): 
     """
@@ -21,7 +20,6 @@ class StreamElements(TTSProvider):
     headers: dict[str, str] = {
         "User-Agent": LitAgent().random()
     }
-    cache_dir = pathlib.Path("./audio_cache")
     all_voices: list[str] = [
         "Filiz",
         "Astrid",
@@ -238,11 +236,7 @@ class StreamElements(TTSProvider):
         if proxies:
             self.session.proxies.update(proxies)
         self.timeout = timeout
-        self.logger = Logger(
-            name="StreamElementsTTS",
-            format=LogFormat.MODERN_EMOJI,
-
-        )
+        self.temp_dir = tempfile.mkdtemp(prefix="webscout_tts_")
 
     def tts(self, text: str, voice: str = "Mathieu", verbose: bool = True) -> str:
         """
@@ -260,7 +254,7 @@ class StreamElements(TTSProvider):
             voice in self.all_voices
         ), f"Voice '{voice}' not one of [{', '.join(self.all_voices)}]"
 
-        filename = self.cache_dir / f"{int(time.time())}.mp3"
+        filename = pathlib.Path(tempfile.mktemp(suffix=".mp3", dir=self.temp_dir))
 
         # Split text into sentences
         sentences = utils.split_sentences(text)
@@ -278,20 +272,17 @@ class StreamElements(TTSProvider):
                     response = self.session.get(url, headers=self.headers, timeout=self.timeout)
                     response.raise_for_status()
 
-                    # Create the audio_cache directory if it doesn't exist
-                    self.cache_dir.mkdir(parents=True, exist_ok=True) 
-
                     # Check if the request was successful
                     if response.ok and response.status_code == 200:
                         if verbose:
-                            self.logger.success(f"Chunk {part_number} processed successfully 🎉")
+                            print(f"[debug] Chunk {part_number} processed successfully")
                         return part_number, response.content
                     else:
                         if verbose:
-                            self.logger.warning(f"No data received for chunk {part_number}. Retrying...")
+                            print(f"[debug] No data received for chunk {part_number}. Retrying...")
                 except requests.RequestException as e:
                     if verbose:
-                        self.logger.error(f"Error for chunk {part_number}: {e}. Retrying... 🔄")
+                        print(f"[debug] Error for chunk {part_number}: {e}. Retrying...")
                     time.sleep(1)
         try:
             # Using ThreadPoolExecutor to handle requests concurrently
@@ -309,52 +300,34 @@ class StreamElements(TTSProvider):
                         audio_chunks[part_number] = audio_data  # Store the audio data in correct sequence
                     except Exception as e:
                         if verbose:
-                            self.logger.error(f"Failed to generate audio for chunk {chunk_num}: {e} 🚨")
+                            print(f"[debug] Failed to generate audio for chunk {chunk_num}: {e}")
 
             # Combine audio chunks in the correct sequence
             combined_audio = BytesIO()
             for part_number in sorted(audio_chunks.keys()):
                 combined_audio.write(audio_chunks[part_number])
                 if verbose:
-                    self.logger.debug(f"Added chunk {part_number} to the combined file.")
+                    print(f"[debug] Added chunk {part_number} to the combined file.")
 
             # Save the combined audio data to a single file
             with open(filename, 'wb') as f:
                 f.write(combined_audio.getvalue())
             if verbose:
-                self.logger.info(f"Final Audio Saved as {filename} 🔊")
+                print(f"[debug] Final Audio Saved as {filename}")
             return filename.as_posix()
 
         except requests.exceptions.RequestException as e:
-            self.logger.critical(f"Failed to perform the operation: {e} 🚨")
+            if verbose:
+                print(f"[debug] Failed to perform the operation: {e}")
             raise exceptions.FailedToGenerateResponseError(
                 f"Failed to perform the operation: {e}"
             )
-        
-    def play_audio(self, filename: str):
-        """
-        Plays an audio file using playsound.
-
-        Args:
-            filename (str): The path to the audio file.
-
-        Raises:
-            RuntimeError: If there is an error playing the audio.
-        """
-        try:
-            self.logger.info(f"Playing audio: {filename} 🎵")
-            playsound(filename)
-        except Exception as e:
-            self.logger.error(f"Error playing audio: {e} 🔇")
-            raise RuntimeError(f"Error playing audio: {e}")
 
 # Example usage
 if __name__ == "__main__":
     streamelements = StreamElements()
     text = "This is a test of the StreamElements text-to-speech API. It supports multiple sentences and advanced logging."
 
-    streamelements.logger.info("Generating audio...")
-    audio_file = streamelements.tts(text, voice="Mathieu") 
-
-    streamelements.logger.info("Playing audio...")
-    streamelements.play_audio(audio_file)
+    print("[debug] Generating audio...")
+    audio_file = streamelements.tts(text, voice="Mathieu")
+    print(f"Audio saved to: {audio_file}")