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

webscout/Provider/TTS/gesserit.py

@@ -1,128 +0,0 @@
-import time
-import requests
-import pathlib
-import base64
-from io import BytesIO
-from webscout import exceptions
-from webscout.litagent import LitAgent
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from . import utils
-from .base import BaseTTSProvider
-
-class GesseritTTS(BaseTTSProvider):
-    """Text-to-speech provider using the GesseritTTS API."""
-    # Request headers
-    headers: dict[str, str] = {
-        "User-Agent": LitAgent().random()
-    }
-    cache_dir = pathlib.Path("./audio_cache")
-    all_voices: dict[str, str] = {
-        "Emma": "en_us_001",  # Female Voice
-        "Liam": "en_us_006",  # Male Voice
-        "Noah": "en_us_007",  # Male Voice
-        "Oliver": "en_us_009",  # Male Voice
-        "Elijah": "en_us_010",  # Male Voice
-        "James": "en_male_narration",  # Male Voice
-        "Charlie": "en_male_funny",  # Male Voice
-        "Sophia": "en_female_emotional",  # Female Voice
-        "Cody": "en_male_cody",  # Male Voice
-    }
-
-    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:
-            self.session.proxies.update(proxies)
-        self.timeout = timeout
-
-    def tts(self, text: str, voice: str = "Oliver", verbose:bool = True) -> str:
-        """Converts text to speech using the GesseritTTS API and saves it to a file."""
-        assert (
-            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"
-
-        voice_id = self.all_voices[voice]
-
-        # Split text into sentences
-        sentences = utils.split_sentences(text)
-
-        # Function to request audio for each chunk
-        def generate_audio_for_chunk(part_text: str, part_number: int):
-            while True:
-                try:
-                    payload = {
-                        "text": part_text,
-                        "voice": voice_id
-                    }
-                    response = self.session.post('https://gesserit.co/api/tiktok-tts', headers=self.headers, json=payload, 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:
-                        data = response.json()
-                        audio_base64 = data["audioUrl"].split(",")[1]
-                        audio_data = base64.b64decode(audio_base64)
-                        if verbose:
-                            print(f"[debug] Chunk {part_number} processed successfully")
-                        return part_number, audio_data
-                    else:
-                        if verbose:
-                            print(f"[debug] No data received for chunk {part_number}. Retrying...")
-                except requests.RequestException as e:
-                    if verbose:
-                        print(f"[debug] Error for chunk {part_number}: {e}. Retrying...")
-                    time.sleep(1)
-        try:
-            # 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
-                    except Exception as e:
-                        if verbose:
-                            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:
-                    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__":
-    gesserit = GesseritTTS()
-    text = "This is a test of the GesseritTTS text-to-speech API. It supports multiple sentences and advanced logging."
-
-    print("[debug] Generating audio...")
-    audio_file = gesserit.tts(text, voice="Oliver")
-    print(f"Audio saved to: {audio_file}")

webscout/Provider/TTS/murfai.py

@@ -1,113 +0,0 @@
-import time
-import requests
-import pathlib
-import tempfile
-from io import BytesIO
-from urllib.parse import urlencode
-from webscout import exceptions
-from webscout.litagent import LitAgent
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from . import utils
-from .base import BaseTTSProvider
-
-class MurfAITTS(BaseTTSProvider):
-    """Text-to-speech provider using the MurfAITTS API."""
-    # Request headers
-    headers: dict[str, str] = {
-        "User-Agent": LitAgent().random()
-    }
-    all_voices: dict[str, str] = {"Hazel": "en-UK-hazel"}
-
-    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
-
-    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."""
-        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))
-
-        voice_id = self.all_voices[voice]
-
-        # Split text into sentences
-        sentences = utils.split_sentences(text)
-
-        # Function to request audio for each chunk
-        def generate_audio_for_chunk(part_text: str, part_number: int):
-            while True:
-                try:
-                    params: dict[str, str] = {
-                    "name": voice_id,
-                    "text": part_text
-                    }
-                    encode_param: str = urlencode(params)
-                    response = self.session.get(f"https://murf.ai/Prod/anonymous-tts/audio?{encode_param}", headers=self.headers, timeout=self.timeout)
-                    response.raise_for_status()
-
-                    # Check if the request was successful
-                    if response.ok and response.status_code == 200:
-                        if verbose:
-                            print(f"[debug] Chunk {part_number} processed successfully")
-                        return part_number, response.content
-                    else:
-                        if verbose:
-                            print(f"[debug] No data received for chunk {part_number}. Retrying...")
-                except requests.RequestException as e:
-                    if verbose:
-                        print(f"[debug] Error for chunk {part_number}: {e}. Retrying...")
-                    time.sleep(1)
-        try:
-            # 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
-                    except Exception as e:
-                        if verbose:
-                            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:
-                    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__":
-    murfai = MurfAITTS()
-    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")
-    print(f"Audio saved to: {audio_file}")

webscout/Provider/TTS/parler.py

@@ -1,111 +0,0 @@
-import time
-import tempfile
-from pathlib import Path
-from webscout import exceptions
-from gradio_client import Client
-import os
-from .base import BaseTTSProvider
-
-
-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
-
-    def tts(self, text: str, description: str = "", use_large: bool = False, verbose: bool = True) -> str:
-        """
-        Converts text to speech using the Parler TTS API.
-
-        Args:
-            text (str): The text to be converted to speech.
-            description (str, optional): Description of the desired voice characteristics. Defaults to "".
-            use_large (bool, optional): Whether to use the large model variant. Defaults to False.
-            verbose (bool, optional): Whether to log detailed information. Defaults to True.
-
-        Returns:
-            str: The filename of the saved audio file.
-
-        Raises:
-            exceptions.FailedToGenerateResponseError: If there is an error generating or saving the audio.
-        """
-        filename = Path(tempfile.mktemp(suffix=".wav", dir=self.temp_dir))
-
-        try:
-            if verbose:
-                print(f"[debug] Generating TTS with description: {description}")
-
-            result = self.client.predict(
-                text=text,
-                description=description,
-                use_large=use_large,
-                api_name=self.api_endpoint,
-            )
-
-            if isinstance(result, bytes):
-                audio_bytes = result
-            elif isinstance(result, str) and os.path.isfile(result):
-                with open(result, "rb") as f:
-                    audio_bytes = f.read()
-            else:
-                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:
-            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, verbose: bool = True):
-        """
-        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:
-            with open(filename, "wb") as f:
-                f.write(audio_data)
-            if verbose:
-                print(f"[debug] Audio saved to {filename}")
-
-        except Exception as e:
-            if verbose:
-                print(f"[debug] Error saving audio: {e}")
-            raise exceptions.FailedToGenerateResponseError(f"Error saving audio: {e}")
-
-# Example usage
-if __name__ == "__main__":
-    parlertts = ParlerTTS()
-    text = (
-        "All of the data, pre-processing, training code, and weights are released "
-        "publicly under a permissive license, enabling the community to build on our work "
-        "and develop their own powerful models."
-    )
-    voice_description = (
-        "Laura's voice is monotone yet slightly fast in delivery, with a very close "
-        "recording that almost has no background noise."
-    )
-
-    print("[debug] Generating audio...")
-    audio_file = parlertts.tts(text, description=voice_description, use_large=False)
-    print(f"Audio saved to: {audio_file}")

webscout/Provider/TTS/speechma.py

@@ -1,180 +0,0 @@
-##################################################################################
-##  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.litagent import LitAgent
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from . import utils
-from .base import BaseTTSProvider
-
-class SpeechMaTTS(BaseTTSProvider):
-    """
-    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."""
-        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
-
-    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}")