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

webscout/Provider/TTS/streamElements.py

@@ -1,333 +0,0 @@
-import time
-import requests
-import pathlib
-import urllib.parse
-import tempfile
-from typing import Union
-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 StreamElements(BaseTTSProvider):
-    """
-    Text-to-speech provider using the StreamElements API.
-    """
-
-    # Request headers
-    headers: dict[str, str] = {
-        "User-Agent": LitAgent().random()
-    }
-    all_voices: list[str] = [
-        "Filiz",
-        "Astrid",
-        "Tatyana",
-        "Maxim",
-        "Carmen",
-        "Ines",
-        "Cristiano",
-        "Vitoria",
-        "Ricardo",
-        "Maja",
-        "Jan",
-        "Jacek",
-        "Ewa",
-        "Ruben",
-        "Lotte",
-        "Liv",
-        "Seoyeon",
-        "Takumi",
-        "Mizuki",
-        "Giorgio",
-        "Carla",
-        "Bianca",
-        "Karl",
-        "Dora",
-        "Mathieu",
-        "Celine",
-        "Chantal",
-        "Penelope",
-        "Miguel",
-        "Mia",
-        "Enrique",
-        "Conchita",
-        "Geraint",
-        "Salli",
-        "Matthew",
-        "Kimberly",
-        "Kendra",
-        "Justin",
-        "Joey",
-        "Joanna",
-        "Ivy",
-        "Raveena",
-        "Aditi",
-        "Emma",
-        "Brian",
-        "Amy",
-        "Russell",
-        "Nicole",
-        "Vicki",
-        "Marlene",
-        "Hans",
-        "Naja",
-        "Mads",
-        "Gwyneth",
-        "Zhiyu",
-        "es-ES-Standard-A",
-        "it-IT-Standard-A",
-        "it-IT-Wavenet-A",
-        "ja-JP-Standard-A",
-        "ja-JP-Wavenet-A",
-        "ko-KR-Standard-A",
-        "ko-KR-Wavenet-A",
-        "pt-BR-Standard-A",
-        "tr-TR-Standard-A",
-        "sv-SE-Standard-A",
-        "nl-NL-Standard-A",
-        "nl-NL-Wavenet-A",
-        "en-US-Wavenet-A",
-        "en-US-Wavenet-B",
-        "en-US-Wavenet-C",
-        "en-US-Wavenet-D",
-        "en-US-Wavenet-E",
-        "en-US-Wavenet-F",
-        "en-GB-Standard-A",
-        "en-GB-Standard-B",
-        "en-GB-Standard-C",
-        "en-GB-Standard-D",
-        "en-GB-Wavenet-A",
-        "en-GB-Wavenet-B",
-        "en-GB-Wavenet-C",
-        "en-GB-Wavenet-D",
-        "en-US-Standard-B",
-        "en-US-Standard-C",
-        "en-US-Standard-D",
-        "en-US-Standard-E",
-        "de-DE-Standard-A",
-        "de-DE-Standard-B",
-        "de-DE-Wavenet-A",
-        "de-DE-Wavenet-B",
-        "de-DE-Wavenet-C",
-        "de-DE-Wavenet-D",
-        "en-AU-Standard-A",
-        "en-AU-Standard-B",
-        "en-AU-Wavenet-A",
-        "en-AU-Wavenet-B",
-        "en-AU-Wavenet-C",
-        "en-AU-Wavenet-D",
-        "en-AU-Standard-C",
-        "en-AU-Standard-D",
-        "fr-CA-Standard-A",
-        "fr-CA-Standard-B",
-        "fr-CA-Standard-C",
-        "fr-CA-Standard-D",
-        "fr-FR-Standard-C",
-        "fr-FR-Standard-D",
-        "fr-FR-Wavenet-A",
-        "fr-FR-Wavenet-B",
-        "fr-FR-Wavenet-C",
-        "fr-FR-Wavenet-D",
-        "da-DK-Wavenet-A",
-        "pl-PL-Wavenet-A",
-        "pl-PL-Wavenet-B",
-        "pl-PL-Wavenet-C",
-        "pl-PL-Wavenet-D",
-        "pt-PT-Wavenet-A",
-        "pt-PT-Wavenet-B",
-        "pt-PT-Wavenet-C",
-        "pt-PT-Wavenet-D",
-        "ru-RU-Wavenet-A",
-        "ru-RU-Wavenet-B",
-        "ru-RU-Wavenet-C",
-        "ru-RU-Wavenet-D",
-        "sk-SK-Wavenet-A",
-        "tr-TR-Wavenet-A",
-        "tr-TR-Wavenet-B",
-        "tr-TR-Wavenet-C",
-        "tr-TR-Wavenet-D",
-        "tr-TR-Wavenet-E",
-        "uk-UA-Wavenet-A",
-        "ar-XA-Wavenet-A",
-        "ar-XA-Wavenet-B",
-        "ar-XA-Wavenet-C",
-        "cs-CZ-Wavenet-A",
-        "nl-NL-Wavenet-B",
-        "nl-NL-Wavenet-C",
-        "nl-NL-Wavenet-D",
-        "nl-NL-Wavenet-E",
-        "en-IN-Wavenet-A",
-        "en-IN-Wavenet-B",
-        "en-IN-Wavenet-C",
-        "fil-PH-Wavenet-A",
-        "fi-FI-Wavenet-A",
-        "el-GR-Wavenet-A",
-        "hi-IN-Wavenet-A",
-        "hi-IN-Wavenet-B",
-        "hi-IN-Wavenet-C",
-        "hu-HU-Wavenet-A",
-        "id-ID-Wavenet-A",
-        "id-ID-Wavenet-B",
-        "id-ID-Wavenet-C",
-        "it-IT-Wavenet-B",
-        "it-IT-Wavenet-C",
-        "it-IT-Wavenet-D",
-        "ja-JP-Wavenet-B",
-        "ja-JP-Wavenet-C",
-        "ja-JP-Wavenet-D",
-        "cmn-CN-Wavenet-A",
-        "cmn-CN-Wavenet-B",
-        "cmn-CN-Wavenet-C",
-        "cmn-CN-Wavenet-D",
-        "nb-no-Wavenet-E",
-        "nb-no-Wavenet-A",
-        "nb-no-Wavenet-B",
-        "nb-no-Wavenet-C",
-        "nb-no-Wavenet-D",
-        "vi-VN-Wavenet-A",
-        "vi-VN-Wavenet-B",
-        "vi-VN-Wavenet-C",
-        "vi-VN-Wavenet-D",
-        "sr-rs-Standard-A",
-        "lv-lv-Standard-A",
-        "is-is-Standard-A",
-        "bg-bg-Standard-A",
-        "af-ZA-Standard-A",
-        "Tracy",
-        "Danny",
-        "Huihui",
-        "Yaoyao",
-        "Kangkang",
-        "HanHan",
-        "Zhiwei",
-        "Asaf",
-        "An",
-        "Stefanos",
-        "Filip",
-        "Ivan",
-        "Heidi",
-        "Herena",
-        "Kalpana",
-        "Hemant",
-        "Matej",
-        "Andika",
-        "Rizwan",
-        "Lado",
-        "Valluvar",
-        "Linda",
-        "Heather",
-        "Sean",
-        "Michael",
-        "Karsten",
-        "Guillaume",
-        "Pattara",
-        "Jakub",
-        "Szabolcs",
-        "Hoda",
-        "Naayf",
-    ]
-
-    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
-
-    def tts(self, text: str, voice: str = "Mathieu", verbose: bool = True) -> str:
-        """
-        Converts text to speech using the StreamElements 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: "Mathieu")
-            verbose (bool): Whether to print progress messages (default: True)
-
-        Returns:
-            str: Path to the generated audio file
-        """
-        assert (
-            voice in self.all_voices
-        ), f"Voice '{voice}' not one of [{', '.join(self.all_voices)}]"
-
-        filename = pathlib.Path(tempfile.mktemp(suffix=".mp3", dir=self.temp_dir))
-
-        # 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:
-                    # 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()
-
-                    # 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__":
-    streamelements = StreamElements()
-    text = "This is a test of the StreamElements text-to-speech API. It supports multiple sentences and advanced logging."
-
-    print("[debug] Generating audio...")
-    audio_file = streamelements.tts(text, voice="Mathieu")
-    print(f"Audio saved to: {audio_file}")

webscout/Provider/TTS/utils.py

@@ -1,280 +0,0 @@
-"""
-Text processing utilities for TTS providers.
-"""
-from typing import Union, List, Dict, Tuple, Set, Optional, Pattern
-import re
-
-
-class SentenceTokenizer:
-    """Advanced sentence tokenizer with support for complex cases and proper formatting."""
-    
-    def __init__(self) -> None:
-        # Common abbreviations by category
-        self.TITLES: Set[str] = {
-            'mr', 'mrs', 'ms', 'dr', 'prof', 'rev', 'sr', 'jr', 'esq',
-            'hon', 'pres', 'gov', 'atty', 'supt', 'det', 'rev', 'col','maj', 'gen', 'capt', 'cmdr',
-            'lt', 'sgt', 'cpl', 'pvt'
-        }
-        
-        self.ACADEMIC: Set[str] = {
-            'ph.d', 'phd', 'm.d', 'md', 'b.a', 'ba', 'm.a', 'ma', 'd.d.s', 'dds',
-            'm.b.a', 'mba', 'b.sc', 'bsc', 'm.sc', 'msc', 'llb', 'll.b', 'bl'
-        }
-        
-        self.ORGANIZATIONS: Set[str] = {
-            'inc', 'ltd', 'co', 'corp', 'llc', 'llp', 'assn', 'bros', 'plc', 'cos',
-            'intl', 'dept', 'est', 'dist', 'mfg', 'div'
-        }
-        
-        self.MONTHS: Set[str] = {
-            'jan', 'feb', 'mar', 'apr', 'jun', 'jul', 'aug', 'sep', 'oct', 'nov', 'dec'
-        }
-        
-        self.UNITS: Set[str] = {
-            'oz', 'pt', 'qt', 'gal', 'ml', 'cc', 'km', 'cm', 'mm', 'ft', 'in',
-            'kg', 'lb', 'lbs', 'hz', 'khz', 'mhz', 'ghz', 'kb', 'mb', 'gb', 'tb'
-        }
-        
-        self.TECHNOLOGY: Set[str] = {
-            'v', 'ver', 'app', 'sys', 'dir', 'exe', 'lib', 'api', 'sdk', 'url',
-            'cpu', 'gpu', 'ram', 'rom', 'hdd', 'ssd', 'lan', 'wan', 'sql', 'html'
-        }
-        
-        self.MISC: Set[str] = {
-            'vs', 'etc', 'ie', 'eg', 'no', 'al', 'ca', 'cf', 'pp', 'est', 'st',
-            'approx', 'appt', 'apt', 'dept', 'depts', 'min', 'max', 'avg'
-        }
-
-        # Combine all abbreviations
-        self.all_abbreviations: Set[str] = (
-            self.TITLES | self.ACADEMIC | self.ORGANIZATIONS |
-            self.MONTHS | self.UNITS | self.TECHNOLOGY | self.MISC
-        )
-
-        # Special patterns
-        self.ELLIPSIS: str = r'\.{2,}|…'
-        self.URL_PATTERN: str = (
-            r'(?:https?:\/\/|www\.)[\w\-\.]+\.[a-zA-Z]{2,}(?:\/[^\s]*)?'
-        )
-        self.EMAIL_PATTERN: str = r'[\w\.-]+@[\w\.-]+\.\w+'
-        self.NUMBER_PATTERN: str = (
-            r'\d+(?:\.\d+)?(?:%|°|km|cm|mm|m|kg|g|lb|ft|in|mph|kmh|hz|mhz|ghz)?'
-        )
-        
-        # Quote and bracket pairs
-        self.QUOTE_PAIRS: Dict[str, str] = {
-            '"': '"', "'": "'", '"': '"', "「": "」", "『": "』",
-            "«": "»", "‹": "›", "'": "'", "‚": "'"
-        }
-        
-        self.BRACKETS: Dict[str, str] = {
-            '(': ')', '[': ']', '{': '}', '⟨': '⟩', '「': '」',
-            '『': '』', '【': '】', '〖': '〗', '｢': '｣'
-        }
-
-        # Compile regex patterns
-        self._compile_patterns()
-
-    def _compile_patterns(self) -> None:
-        """Compile regex patterns for better performance."""
-        # Pattern for finding potential sentence boundaries
-        self.SENTENCE_END: Pattern = re.compile(
-            r'''
-            # Group for sentence endings
-            (?:
-                # Standard endings with optional quotes/brackets
-                (?<=[.!?])[\"\'\)\]\}»›」』\s]*
-                
-                # Ellipsis
-                |(?:\.{2,}|…)
-                
-                # Asian-style endings
-                |(?<=[。！？」』】\s])
-            )
-            
-            # Must be followed by whitespace and capital letter or number
-            (?=\s+(?:[A-Z0-9]|["'({[\[「『《‹〈][A-Z]))
-            ''',
-            re.VERBOSE
-        )
-
-        # Pattern for abbreviations
-        abbrev_pattern = '|'.join(re.escape(abbr) for abbr in self.all_abbreviations)
-        self.ABBREV_PATTERN: Pattern = re.compile(
-            fr'\b(?:{abbrev_pattern})\.?',
-            re.IGNORECASE
-        )
-
-    def _protect_special_cases(self, text: str) -> Tuple[str, Dict[str, str]]:
-        """Protect URLs, emails, and other special cases from being split."""
-        protected = text
-        placeholders: Dict[str, str] = {}
-        counter = 0
-
-        # Protect URLs and emails
-        for pattern in [self.URL_PATTERN, self.EMAIL_PATTERN]:
-            for match in re.finditer(pattern, protected):
-                placeholder = f'__PROTECTED_{counter}__'
-                placeholders[placeholder] = match.group()
-                protected = protected.replace(match.group(), placeholder)
-                counter += 1
-
-        # Protect quoted content
-        stack = []
-        protected_chars = list(protected)
-        i = 0
-        while i < len(protected_chars):
-            char = protected_chars[i]
-            if char in self.QUOTE_PAIRS:
-                stack.append((char, i))
-            elif stack and char == self.QUOTE_PAIRS[stack[-1][0]]:
-                start_quote, start_idx = stack.pop()
-                content = ''.join(protected_chars[start_idx:i + 1])
-                placeholder = f'__PROTECTED_{counter}__'
-                placeholders[placeholder] = content
-                protected_chars[start_idx:i + 1] = list(placeholder)
-                counter += 1
-            i += 1
-
-        return ''.join(protected_chars), placeholders
-
-    def _restore_special_cases(self, text: str, placeholders: Dict[str, str]) -> str:
-        """Restore protected content."""
-        restored = text
-        for placeholder, original in placeholders.items():
-            restored = restored.replace(placeholder, original)
-        return restored
-
-    def _handle_abbreviations(self, text: str) -> str:
-        """Handle abbreviations to prevent incorrect sentence splitting."""
-        def replace_abbrev(match: re.Match) -> str:
-            abbr = match.group().lower().rstrip('.')
-            if abbr in self.all_abbreviations:
-                return match.group().replace('.', '__DOT__')
-            return match.group()
-
-        return self.ABBREV_PATTERN.sub(replace_abbrev, text)
-
-    def _normalize_whitespace(self, text: str) -> str:
-        """Normalize whitespace while preserving paragraph breaks."""
-        # Replace multiple newlines with special marker
-        text = re.sub(r'\n\s*\n', ' __PARA__ ', text)
-        # Normalize remaining whitespace
-        text = re.sub(r'\s+', ' ', text)
-        return text.strip()
-
-    def _restore_formatting(self, sentences: List[str]) -> List[str]:
-        """Restore original formatting and clean up sentences."""
-        restored = []
-        for sentence in sentences:
-            # Restore dots in abbreviations
-            sentence = sentence.replace('__DOT__', '.')
-            
-            # Restore paragraph breaks
-            sentence = sentence.replace('__PARA__', '\n\n')
-            
-            # Clean up whitespace
-            sentence = re.sub(r'\s+', ' ', sentence).strip()
-            
-            # Capitalize first letter if it's lowercase and not an abbreviation
-            words = sentence.split()
-            if words and words[0].lower() not in self.all_abbreviations:
-                sentence = sentence[0].upper() + sentence[1:]
-            
-            if sentence:
-                restored.append(sentence)
-        
-        return restored
-
-    def tokenize(self, text: str) -> List[str]:
-        """
-        Split text into sentences while handling complex cases.
-        
-        Args:
-            text (str): Input text to split into sentences.
-            
-        Returns:
-            List[str]: List of properly formatted sentences.
-        """
-        if not text or not text.strip():
-            return []
-
-        # Step 1: Protect special cases
-        protected_text, placeholders = self._protect_special_cases(text)
-        
-        # Step 2: Normalize whitespace
-        protected_text = self._normalize_whitespace(protected_text)
-        
-        # Step 3: Handle abbreviations
-        protected_text = self._handle_abbreviations(protected_text)
-        
-        # Step 4: Split into potential sentences
-        potential_sentences = self.SENTENCE_END.split(protected_text)
-        
-        # Step 5: Process and restore formatting
-        sentences = self._restore_formatting(potential_sentences)
-        
-        # Step 6: Restore special cases
-        sentences = [self._restore_special_cases(s, placeholders) for s in sentences]
-        
-        # Step 7: Post-process sentences
-        final_sentences = []
-        current_sentence = []
-        
-        for sentence in sentences:
-            # Skip empty sentences
-            if not sentence.strip():
-                continue
-                
-            # Check if sentence might be continuation of previous
-            if current_sentence and sentence[0].islower():
-                current_sentence.append(sentence)
-            else:
-                if current_sentence:
-                    final_sentences.append(' '.join(current_sentence))
-                current_sentence = [sentence]
-        
-        # Add last sentence if exists
-        if current_sentence:
-            final_sentences.append(' '.join(current_sentence))
-        
-        return final_sentences
-
-
-def split_sentences(text: str) -> List[str]:
-    """
-    Convenience function to split text into sentences using SentenceTokenizer.
-    
-    Args:
-        text (str): Input text to split into sentences.
-    
-    Returns:
-        List[str]: List of properly formatted sentences.
-    """
-    tokenizer = SentenceTokenizer()
-    return tokenizer.tokenize(text)
-
-
-if __name__ == "__main__":
-    # Test text with various challenging cases
-    test_text: str = """
-    Dr. Smith (Ph.D., M.D.) visited Washington D.C. on Jan. 20, 2024! He met with Prof. Johnson at 3:30 p.m. 
-    They discussed A.I. and machine learning... "What about the U.S. market?" asked Dr. Smith. 
-    The meeting ended at 5 p.m. Later, they went to Mr. Wilson's house (located at 123 Main St.) for dinner.
-    
-    Visit our website at https://www.example.com or email us at test@example.com!
-    The temperature was 72.5°F (22.5°C). The company's Q3 2023 revenue was $12.5M USD.
-    
-    「これは日本語の文章です。」This is a mixed-language text! How cool is that?
-    
-    Some technical specs: CPU: 3.5GHz, RAM: 16GB, Storage: 2TB SSD.
-    Common abbreviations: etc., i.e., e.g., vs., cf., approx. 100 units.
-    """
-    
-    # Process and print each sentence
-    sentences: List[str] = split_sentences(test_text)
-    print("Detected sentences:")
-    print("-" * 80)
-    for i, sentence in enumerate(sentences, 1):
-        print(f"{i}. {sentence}")
-        print("-" * 80)