import os # Activer le serveur MCP os.environ['GRADIO_MCP_SERVER'] = 'True' import gradio as gr import torchaudio import torch from pydub import AudioSegment, effects import uuid import subprocess import time import nltk from nltk.tokenize import sent_tokenize from pathlib import Path import sys from pydub.silence import split_on_silence import re from unicodedata import normalize import numpy as np import spaces from huggingface_hub import snapshot_download import threading import requests import tempfile # Télécharger les ressources NLTK nltk.download("punkt", quiet=True) nltk.download("punkt_tab", quiet=True) # Definition of problematic characters by language PROBLEMATIC_CHARS = { 'global': ['&', '%', '@', '#', '$', '*', '+', '=', '()', '[]', '{}', '<>', '|', '/', '\\', '"', '…', '«', '»', '"', '"', ''', '''], 'fr': ['&', '%', '@', '#', '$', '*', '+', '=', 'etc.'], 'en': ['&', '%', '@', '#', '$', '*', '+', '=', 'etc.'], # Add specific characters for each language as needed } # Replacement rules by language REPLACEMENT_RULES = { 'global': { '&': {'fr': ' et ', 'en': ' and ', 'es': ' y ', 'de': ' und ', 'it': ' e ', 'pt': ' e ', 'default': ' and '}, '%': {'fr': ' pourcent ', 'en': ' percent ', 'de': ' prozent ', 'default': ' percent '}, '@': {'fr': ' arobase ', 'en': ' at ', 'default': ' at '}, '#': {'fr': ' hashtag ', 'en': ' hashtag ', 'default': ' hashtag '}, '...': {'default': ', '}, '…': {'default': ', '}, '"': {'default': ''}, "'": {'default': ''}, '«': {'default': ''}, '»': {'default': ''}, '"': {'default': ''}, '"': {'default': ''}, ''': {'default': ''}, ''': {'default': ''}, }, # You can add language-specific rules } def analyze_text(text, language_code): """Analyze text to detect potential pronunciation issues for voice synthesis. This function examines text for problematic characters, special symbols, URLs, numbers, and other elements that might affect speech quality in voice cloning. Args: text: The text to analyze for speech synthesis compatibility language_code: Language code (en, fr, es, de, it, pt, pl, tr, ru, nl, cs, ar, zh, hu, ko, ja, hi) Returns: Dictionary containing detected issues and suggestions for improvement """ issues = [] # Basic unicode normalization normalized_text = normalize('NFC', text) # Détection des emojis import re emoji_pattern = re.compile( "[" "\U0001F600-\U0001F64F" # emoticons "\U0001F300-\U0001F5FF" # symbols & pictographs "\U0001F680-\U0001F6FF" # transport & map symbols "\U0001F700-\U0001F77F" # alchemical symbols "\U0001F780-\U0001F7FF" # Geometric Shapes "\U0001F800-\U0001F8FF" # Supplemental Arrows-C "\U0001F900-\U0001F9FF" # Supplemental Symbols and Pictographs "\U0001FA00-\U0001FA6F" # Chess Symbols "\U0001FA70-\U0001FAFF" # Symbols and Pictographs Extended-A "\U00002702-\U000027B0" # Dingbats "\U000024C2-\U0001F251" "]+", flags=re.UNICODE ) emojis = emoji_pattern.findall(text) if emojis: issues.append({ 'type': 'emojis', 'description': 'Emojis that will be removed during preprocessing', 'instances': emojis, 'suggestion': 'Emojis are replaced with spaces for better pronunciation' }) # URL detection urls = re.findall(r'https?://\S+|www\.\S+', text) if urls: issues.append({ 'type': 'url', 'description': 'Detected URLs that may be mispronounced', 'instances': urls, 'suggestion': 'Replace URLs with textual descriptions' }) # Email detection emails = re.findall(r'\S+@\S+\.\S+', text) if emails: issues.append({ 'type': 'email', 'description': 'Detected email addresses that may be mispronounced', 'instances': emails, 'suggestion': 'Replace emails with descriptive text' }) # Detection of quotes and citation characters (completely exclude apostrophe) quote_chars = ['"', '«', '»', '"', '"', ''', '''] found_quotes = [] # For English, completely exclude apostrophes from problematic characters if language_code == 'en': # Don't report apostrophes as problematic in English pass else: # Look only for quotes, not apostrophes for char in quote_chars: if char in text: found_quotes.append(char) if found_quotes: issues.append({ 'type': 'quotes', 'description': 'Quotes and citation characters that may affect pronunciation', 'instances': found_quotes, 'suggestion': 'Remove quotes and citation characters for better pronunciation' }) # Detection of problematic characters (exclude apostrophes) global_chars = [c for c in PROBLEMATIC_CHARS.get('global', []) if c != "'"] lang_specific_chars = PROBLEMATIC_CHARS.get(language_code, []) all_problematic_chars = set(global_chars + lang_specific_chars) - set(quote_chars) # Exclude quotes already treated found_chars = [] for char in all_problematic_chars: if char in text: found_chars.append(char) if found_chars: issues.append({ 'type': 'special_chars', 'description': 'Special characters that may cause pronunciation problems', 'instances': found_chars, 'suggestion': 'Replace special characters with their textual equivalent' }) # Detection of long numbers (beyond 3 digits) numbers = re.findall(r'\b\d{4,}\b', text) if numbers: suggestion = "Write numbers in full" if language_code == 'fr': suggestion += " or add spaces between thousands (e.g., 10 000)" elif language_code == 'en': suggestion += " or use commas for thousands (e.g., 10,000)" issues.append({ 'type': 'numbers', 'description': 'Long numbers that may be mispronounced', 'instances': numbers, 'suggestion': suggestion }) # Detection of Roman numerals, with exception for the pronoun "I" in English if language_code == 'en': # In English, exclude "I" as a Roman numeral because it's a personal pronoun roman_pattern = r'\b(?!I\b)[IVXLCDM]+\b' roman_numerals = re.findall(roman_pattern, text) if roman_numerals: issues.append({ 'type': 'roman_numerals', 'description': 'Roman numerals that may be mispronounced', 'instances': roman_numerals, 'suggestion': 'Replace Roman numerals with Arabic numbers' }) else: # For other languages, keep normal detection roman_pattern = r'\b[IVXLCDM]+\b' roman_numerals = re.findall(roman_pattern, text) if roman_numerals: issues.append({ 'type': 'roman_numerals', 'description': 'Roman numerals that may be mispronounced', 'instances': roman_numerals, 'suggestion': 'Replace Roman numerals with Arabic numbers' }) # Detection of abbreviations by language abbreviation_patterns = { 'fr': [r'\bM\.\s', r'\bMme\.\s', r'\bMlle\.\s', r'\bDr\.\s', r'\bProf\.\s', r'\betc\.\s', r'\bex\.\s'], 'en': [r'\bMr\.\s', r'\bMrs\.\s', r'\bDr\.\s', r'\bProf\.\s', r'\betc\.\s', r'\be\.g\.\s', r'\bi\.e\.\s'], 'es': [r'\bSr\.\s', r'\bSra\.\s', r'\bDr\.\s', r'\betc\.\s'], 'default': [r'\b[A-Z]\.\s', r'\b[A-Z][a-z]+\.\s'] } patterns = abbreviation_patterns.get(language_code, abbreviation_patterns['default']) found_abbrevs = [] for pattern in patterns: matches = re.findall(pattern, text) found_abbrevs.extend(matches) if found_abbrevs: issues.append({ 'type': 'abbreviations', 'description': 'Detected abbreviations that may be mispronounced', 'instances': found_abbrevs, 'suggestion': 'Write abbreviations in full' }) # Detection of repeated punctuation repeated_punct = re.findall(r'([!?.,;:]{2,})', text) if repeated_punct: issues.append({ 'type': 'repeated_punct', 'description': 'Repeated punctuation that may cause incorrect pauses', 'instances': repeated_punct, 'suggestion': 'Simplify punctuation (use only one character)' }) # Detection of missing spaces around punctuation, excluding decimal numbers missing_spaces = [] # Specific patterns to look for patterns = [ r'[a-zA-ZÀ-ÿ][,.;:!?][a-zA-ZÀ-ÿ]' # letter+punctuation+letter ] # In English, exclude contractions with apostrophes (I'm, don't, isn't, etc.) if language_code != 'en': for pattern in patterns: matches = re.findall(pattern, text) if matches: missing_spaces.extend(matches) if missing_spaces: issues.append({ 'type': 'missing_spaces', 'description': 'Punctuation without spaces that may affect pronunciation', 'instances': missing_spaces, 'suggestion': 'Add appropriate spaces around punctuation (except for decimal numbers)' }) # Detection of language-specific issues if language_code == 'fr': # Poorly formatted ordinal numbers in French ordinals = re.findall(r'\b\d+(eme|ème|er|ere|ère)\b', text) if ordinals: issues.append({ 'type': 'fr_ordinals', 'description': 'Ordinal numbers that may be mispronounced', 'instances': ordinals, 'suggestion': 'Write ordinals in letters (premier, deuxième, etc.)' }) elif language_code == 'en': # English-specific issues dates = re.findall(r'\b\d{1,2}/\d{1,2}/\d{2,4}\b', text) if dates: issues.append({ 'type': 'en_dates', 'description': 'Dates in numeric format that may be misinterpreted', 'instances': dates, 'suggestion': 'Write dates in full (e.g., January 1st, 2022)' }) return { 'issues': issues, 'has_issues': len(issues) > 0, 'normalized_text': normalized_text } # Add a function to convert numbers to text def number_to_text_fr(number_str): """ Converts a number (integer or decimal) to French text. Args: number_str (str): The number to convert to text format Returns: str: The number written out in words """ parts = number_str.replace(',', '.').split('.') # Function to convert an integer to text def int_to_text(n): if n == '0': return 'zéro' units = ['', 'un', 'deux', 'trois', 'quatre', 'cinq', 'six', 'sept', 'huit', 'neuf'] teens = ['dix', 'onze', 'douze', 'treize', 'quatorze', 'quinze', 'seize', 'dix-sept', 'dix-huit', 'dix-neuf'] tens = ['', 'dix', 'vingt', 'trente', 'quarante', 'cinquante', 'soixante', 'soixante', 'quatre-vingt', 'quatre-vingt'] n = int(n) if n < 10: return units[n] elif n < 20: return teens[n-10] elif n < 70: div, mod = divmod(n, 10) return tens[div] + ('-et-un' if mod == 1 else ('-' + units[mod] if mod else '')) elif n < 80: div, mod = divmod(n, 10) return tens[div] + ('-' + teens[mod-10] if mod else '') elif n < 90: div, mod = divmod(n, 10) return tens[div] + (('-' + units[mod]) if mod else 's') elif n < 100: div, mod = divmod(n, 10) return tens[div] + ('-' + teens[mod-10] if mod else 's') else: if n < 200: return 'cent' + (' ' + int_to_text(n % 100) if n % 100 else '') else: div, mod = divmod(n, 100) return int_to_text(div) + ' cent' + ('s' if div > 1 and mod == 0 else '') + (' ' + int_to_text(mod) if mod else '') # Process the integer part integer_part = int_to_text(parts[0]) # If there's a decimal part if len(parts) > 1 and parts[1]: # If the decimal part is 1 or 2 digits decimal_part = parts[1] if len(decimal_part) <= 2: decimal_text = int_to_text(decimal_part) # For 01, 02, etc. we say "un", "deux", etc. rather than "un", "deux" if len(decimal_part) == 2 and decimal_part[0] == '0': decimal_text = int_to_text(decimal_part[1]) return f"{integer_part} virgule {decimal_text}" else: # For more than 2 digits, we pronounce each digit decimal_text = ' '.join(int_to_text(d) for d in decimal_part) return f"{integer_part} virgule {decimal_text}" return integer_part def preprocess_text(text, language_code, apply_replacements=True): """Preprocess and clean text for optimal voice synthesis results. This function automatically fixes common text issues like special characters, numbers, URLs, and language-specific elements to improve speech quality. Args: text: The text to preprocess for voice synthesis language_code: Language code (en, fr, es, de, it, pt, pl, tr, ru, nl, cs, ar, zh, hu, ko, ja, hi) apply_replacements: If True, applies automatic character replacements for better pronunciation Returns: The preprocessed text ready for high-quality voice synthesis """ # Unicode normalization text = normalize('NFC', text) if apply_replacements: # Détection et suppression des emojis et caractères spéciaux Unicode import re # Regex pour détecter les emojis et symboles Unicode emoji_pattern = re.compile( "[" "\U0001F600-\U0001F64F" # emoticons "\U0001F300-\U0001F5FF" # symbols & pictographs "\U0001F680-\U0001F6FF" # transport & map symbols "\U0001F700-\U0001F77F" # alchemical symbols "\U0001F780-\U0001F7FF" # Geometric Shapes "\U0001F800-\U0001F8FF" # Supplemental Arrows-C "\U0001F900-\U0001F9FF" # Supplemental Symbols and Pictographs "\U0001FA00-\U0001FA6F" # Chess Symbols "\U0001FA70-\U0001FAFF" # Symbols and Pictographs Extended-A "\U00002702-\U000027B0" # Dingbats "\U000024C2-\U0001F251" "]+", flags=re.UNICODE ) # Remplacer les emojis par un espace text = emoji_pattern.sub(' ', text) # Apply global replacement rules for char, replacements in REPLACEMENT_RULES.get('global', {}).items(): if char in text: # Use language-specific rule if available, otherwise default rule replacement = replacements.get(language_code, replacements.get('default', char)) text = text.replace(char, replacement) # Transform URLs and emails text = re.sub(r'https?://\S+|www\.\S+', ' URL link ', text) text = re.sub(r'\S+@\S+\.\S+', ' email address ', text) # Process quotes (removal or replacement) # Straight quotes " and ' text = text.replace('"', '') text = text.replace("'", '') # French quotes « and » text = text.replace('«', '') text = text.replace('»', '') # Smart typographic quotes (curly quotes) text = text.replace('"', '') # opening quote text = text.replace('"', '') # closing quote text = text.replace(''', '') # opening apostrophe text = text.replace(''', '') # closing apostrophe # Replace Roman numerals with their equivalent (if needed) if language_code in ['fr', 'en', 'es', 'it', 'pt']: roman_numerals = { 'I': '1', 'II': '2', 'III': '3', 'IV': '4', 'V': '5', 'VI': '6', 'VII': '7', 'VIII': '8', 'IX': '9', 'X': '10', 'XI': '11', 'XII': '12', 'XIII': '13', 'XIV': '14', 'XV': '15', 'XVI': '16', 'XVII': '17', 'XVIII': '18', 'XIX': '19', 'XX': '20' } # Exception for the personal pronoun "I" in English if language_code == 'en': # Use a regex that only detects true Roman numerals # and not the personal pronoun "I" in English for roman, arabic in roman_numerals.items(): if roman == 'I': # For "I" in English, check that it's not alone or between spaces # A true Roman numeral I will typically be followed by a period or # in a numeric context text = re.sub(r'\b(I)\b(?!\'m|\'ve|\'ll|\'d|\.)', roman, text) # Preserve "I" pronoun text = re.sub(r'\b(I)\.', arabic + '.', text) # I. => 1. else: # For other Roman numerals, standard behavior text = re.sub(fr'\b{roman}\b', arabic, text) else: # For other languages, replace all Roman numerals for roman, arabic in roman_numerals.items(): text = re.sub(fr'\b{roman}\b', arabic, text) # Language-specific processing for French if language_code == 'fr': # Replace common numbers text = re.sub(r'\b1er\b', 'premier', text) text = re.sub(r'\b1ère\b', 'première', text) text = re.sub(r'\b(\d+)(ème)\b', r'\1 ième', text) # Improved processing of decimal numbers and percentages in French # Search for patterns like "2,95 %" or "2,95%" def replace_decimal_percent(match): num = match.group(1) return number_to_text_fr(num) + " pour cent" # Search for decimal numbers followed by % (with or without space) text = re.sub(r'(\d+,\d+)\s*%', replace_decimal_percent, text) # Process decimal numbers without percentage def replace_decimal(match): return number_to_text_fr(match.group(0)) # Search for decimal numbers (with comma) text = re.sub(r'\b\d+,\d+\b', replace_decimal, text) # Process simple percentages text = re.sub(r'(\d+)\s*%', lambda m: number_to_text_fr(m.group(1)) + " pour cent", text) # Apply French typographical rules for punctuation: # - No space before: . , ... ) ] } # - Space after: . , ... ) ] } # - Space before and after: : ; ! ? « » # First, normalize by removing all spaces around punctuation text = re.sub(r'\s*([.,;:!?\[\]\(\)\{\}])\s*', r'\1', text) # Then, add spaces according to French rules # Simple punctuation with space after only text = re.sub(r'([.,)])', r'\1 ', text) # Punctuation with space before and after text = re.sub(r'([;:!?])', r' \1 ', text) # Special case for French quotes text = re.sub(r'«', r'« ', text) text = re.sub(r'»', r' »', text) # Language-specific processing for English elif language_code == 'en': # Replace ordinals text = re.sub(r'\b1st\b', 'first', text) text = re.sub(r'\b2nd\b', 'second', text) text = re.sub(r'\b3rd\b', 'third', text) text = re.sub(r'\b(\d+)th\b', r'\1th', text) # Process percentages in English (decimals with point) text = re.sub(r'(\d+\.\d+)%', r'\1 percent', text) text = re.sub(r'(\d+)%', r'\1 percent', text) # English typographical rules: no space before punctuation, space after text = re.sub(r'\s*([.,;:!?])\s*', r'\1 ', text) # For other languages, general rule: no space before, space after punctuation else: text = re.sub(r'\s*([.,;:!?])\s*', r'\1 ', text) # Clean up multiple spaces text = re.sub(r'\s+', ' ', text).strip() return text def format_issues_for_display(analysis_result, language_code, tokenizer_analysis=None): """ Formats detected issues for display in the interface. Args: analysis_result (dict): Result of the text analysis language_code (str): Language code tokenizer_analysis (dict): Result of tokenizer analysis (optional) Returns: str: Formatted text for display """ if not analysis_result['has_issues'] and (tokenizer_analysis is None or not tokenizer_analysis['has_issues']): return "✅ No issues detected in the text." formatted_text = "⚠️ Potential issues detected:\n\n" # Format standard text analysis issues if analysis_result['has_issues']: formatted_text += "📊 Text analysis results:\n" for issue in analysis_result['issues']: formatted_text += f"- {issue['description']}:\n" formatted_text += f" • Detected: {', '.join(repr(i) for i in issue['instances'])}\n" formatted_text += f" • Suggestion: {issue['suggestion']}\n\n" # Format tokenizer analysis issues (if available) if tokenizer_analysis and tokenizer_analysis['has_issues']: formatted_text += "\n🔍 Tokenizer analysis results:\n" for issue in tokenizer_analysis['issues']: formatted_text += f"- {issue['description']}:\n" formatted_text += f" • Detected: {', '.join(repr(i) for i in issue['instances'])}\n" formatted_text += f" • Suggestion: {issue['suggestion']}\n\n" if 'cleaned_text' in tokenizer_analysis: formatted_text += "\n📝 Cleaned text by XTTS tokenizer:\n" formatted_text += f"{tokenizer_analysis['cleaned_text']}\n\n" formatted_text += "\nEnable text preprocessing to automatically fix some of these issues." return formatted_text repo_id = "XTTS-v2" # Télécharger le modèle seulement s'il n'existe pas déjà if not os.path.exists(repo_id) or not os.path.exists(os.path.join(repo_id, "config.json")): try: print("Téléchargement du modèle XTTS-v2...") snapshot_download( repo_id="coqui/XTTS-v2", local_dir=repo_id, allow_patterns=["*.safetensors", "*.wav", "*.json", "*.pth"] ) print("Modèle téléchargé avec succès!") except Exception as e: print(f"Erreur lors du téléchargement: {e}") print("Essai avec git clone...") try: import subprocess result = subprocess.run( ["git", "clone", "https://huggingface.co/coqui/XTTS-v2", repo_id], capture_output=True, text=True ) if result.returncode == 0: print("Modèle téléchargé avec git clone!") else: print(f"Erreur git clone: {result.stderr}") raise Exception("Impossible de télécharger le modèle") except Exception as git_error: print(f"Erreur git clone: {git_error}") raise Exception("Veuillez télécharger le modèle manuellement avec: git clone https://huggingface.co/coqui/XTTS-v2") else: print("Modèle XTTS-v2 déjà présent.") # Relative path management BASE_DIR = Path(os.path.dirname(os.path.abspath(__file__))) MODELS_DIR = repo_id # BASE_DIR / "XTTS-v2" REF_AUDIO_DIR = BASE_DIR / "ref_audio_files" OUTPUT_DIR = BASE_DIR / "outputs" TEMP_DIR = OUTPUT_DIR / "temp" # Create necessary folders REF_AUDIO_DIR.mkdir(exist_ok=True) OUTPUT_DIR.mkdir(exist_ok=True) TEMP_DIR.mkdir(exist_ok=True) # Languages supported by XTTS SUPPORTED_LANGUAGES = { "English": "en", "French": "fr", "Spanish": "es", "German": "de", "Italian": "it", "Portuguese": "pt", "Polish": "pl", "Turkish": "tr", "Russian": "ru", "Dutch": "nl", "Czech": "cs", "Arabic": "ar", "Chinese": "zh-cn", "Japanese": "ja", "Korean": "ko", "Hungarian": "hu", "Hindi": "hi" } print(f"Initializing model from: {MODELS_DIR}") # Clean temporary files def cleanup_temp_files(): """Cleans temporary files in the TEMP_DIR folder""" try: for file in TEMP_DIR.glob("*"): if file.is_file(): os.remove(file) except Exception as e: print(f"Error while cleaning temporary files: {e}") # Clean old generated MP3 files (optional) def cleanup_old_outputs(max_age_days=7): """Deletes MP3 files older than max_age_days in the OUTPUT_DIR folder""" try: now = time.time() for file in OUTPUT_DIR.glob("*.mp3"): if file.is_file(): # If the file is older than max_age_days if os.path.getmtime(file) < now - (max_age_days * 86400): os.remove(file) except Exception as e: print("error cleanup old outputs") # Import XTTS modules try: from TTS.tts.configs.xtts_config import XttsConfig from TTS.tts.models.xtts import Xtts except ImportError as e: print(f"TTS import error: {e}") print("Please install dependencies with: pip install coqui-tts") sys.exit(1) # Install language-specific dependencies def install_language_dependencies(): """Check and install required dependencies for Asian languages""" try: # For Chinese (zh-cn) try: import pypinyin except ImportError: subprocess.check_call([sys.executable, "-m", "pip", "install", "pypinyin"]) # For Japanese (ja) try: import cutlet # Test if fugashi and mecab are also installed try: import fugashi except ImportError: subprocess.check_call([sys.executable, "-m", "pip", "install", "fugashi", "mecab-python3", "unidic-lite"]) except ImportError: subprocess.check_call([sys.executable, "-m", "pip", "install", "cutlet", "fugashi", "mecab-python3", "unidic-lite"]) # For Korean (ko) try: import hangul_romanize except ImportError: subprocess.check_call([sys.executable, "-m", "pip", "install", "hangul-romanize"]) return True except Exception as e: return False # Model initialization and configuration try: # Try to install language dependencies install_language_dependencies() config = XttsConfig() config.load_json(str("XTTS-v2/config.json")) model = Xtts.init_from_config(config) # model.load_safetensors_checkpoint( # config, checkpoint_dir=MODELS_DIR, use_deepspeed=False #) model.load_checkpoint(config, checkpoint_dir=str(MODELS_DIR), eval=True) if torch.cuda.is_available(): model.cuda() print("Model loaded on GPU") else: print("GPU not available, using CPU") except Exception as e: print(f"Error loading model: {e}") print(f"Make sure the XTTS-v2 model is present in: {MODELS_DIR}") sys.exit(1) def remove_silence( audio_segment, silence_thresh=-45, min_silence_len=300, keep_silence=100 ): """ Optimisé: Coupe audio_segment autour des silences puis reconstruit l'audio en supprimant les silences. Ajuste silence_thresh et min_silence_len en fonction du niveau sonore de votre audio. """ # Vérifie que l'audio n'est pas trop court pour éviter les problèmes if len(audio_segment) < 1000: # moins d'une seconde return audio_segment # Première tentative avec les paramètres fournis chunks = split_on_silence( audio_segment, min_silence_len=min_silence_len, silence_thresh=silence_thresh, keep_silence=keep_silence ) # Si aucun segment n'est détecté ou peu de segments, ajuster les paramètres if not chunks or len(chunks) < 2: # Essayer avec des paramètres plus souples chunks = split_on_silence( audio_segment, min_silence_len=200, # Réduire pour détecter des silences plus courts silence_thresh=silence_thresh + 5, # Augmenter le seuil (moins négatif) pour détecter plus de silences keep_silence=keep_silence ) # Recombiner toutes les pièces non silencieuses if chunks: processed_audio = AudioSegment.empty() for chunk in chunks: processed_audio += chunk # Vérifier que l'audio n'a pas été trop raccourci length_ratio = len(processed_audio) / len(audio_segment) if length_ratio < 0.7: # Si plus de 30% a été supprimé # Garder une version moins agressive chunks = split_on_silence( audio_segment, min_silence_len=min_silence_len * 2, # Plus long, détecte moins de silences silence_thresh=silence_thresh - 5, # Plus strict (plus négatif) keep_silence=keep_silence * 2 # Garder plus de silence ) if chunks: processed_audio = AudioSegment.empty() for chunk in chunks: processed_audio += chunk else: return audio_segment return processed_audio else: # Si tout l'audio est considéré comme du silence, retourner l'original return audio_segment def chunk_sentence_by_words(sentence, max_length=200): """ Divise une phrase en sous-chunks (max. max_length caractères) sans couper au milieu d'un mot. Optimisé pour la performance. """ # Si la phrase est déjà suffisamment courte, la retourner directement if len(sentence) <= max_length: return [sentence] words = sentence.split() # division par mots sub_chunks = [] current_chunk = [] current_length = 0 for word in words: # Si ajouter ce mot dépasserait la longueur max, commencer un nouveau chunk word_len = len(word) + (1 if current_length > 0 else 0) # +1 pour l'espace if current_length + word_len > max_length: if current_chunk: # S'assurer qu'on a quelque chose à ajouter sub_chunks.append(" ".join(current_chunk)) current_chunk = [] current_length = 0 # Traiter les mots individuels qui sont plus longs que max_length if len(word) > max_length: sub_chunks.append(word) continue # Ajouter le mot au chunk courant current_chunk.append(word) current_length += word_len # Ajouter le dernier chunk s'il en reste if current_chunk: sub_chunks.append(" ".join(current_chunk)) return sub_chunks def split_text(text, max_length=150): """ - Divise 'text' en phrases (via sent_tokenize). - Si une phrase dépasse max_length, la divise mot par mot en utilisant chunk_sentence_by_words. - Retourne une liste de chunks, chacun ≤ max_length caractères. Optimisé pour la performance. """ # Vérifier que le texte n'est pas vide if not text.strip(): return [] # Division en phrases avec gestion d'erreur améliorée try: raw_sentences = sent_tokenize(text) if not raw_sentences: raw_sentences = [text] except Exception as e: # En cas d'erreur, utiliser une simple division par points raw_sentences = [s.strip() + '.' for s in text.split('.') if s.strip()] if not raw_sentences: raw_sentences = [text] # Initialiser la liste finale de chunks final_chunks = [] # Traiter chaque phrase for sentence in raw_sentences: sentence = sentence.strip() if not sentence: continue # Si la phrase entière est courte, l'ajouter directement if len(sentence) <= max_length: final_chunks.append(sentence) else: # Sinon, la diviser en sous-chunks sub_chunks = chunk_sentence_by_words(sentence, max_length) final_chunks.extend(sub_chunks) # S'assurer qu'on a des chunks if not final_chunks: for i in range(0, len(text), max_length): chunk = text[i:i+max_length] if chunk.strip(): # Ne pas ajouter de segments vides final_chunks.append(chunk) return final_chunks def check_language_dependencies(language): """ Vérifie les dépendances nécessaires pour une langue donnée. Cette fonction s'exécute sur CPU. Args: language (str): Code de langue à vérifier Returns: tuple: (None, None) si tout est ok, ou (None, message_erreur) si problème """ # Dépendances spécifiques par langue language_dependencies = { "zh-cn": "pypinyin", "ja": "cutlet,fugashi,unidic-lite", "ko": "hangul-romanize", } if language in language_dependencies: try: # Essayer d'importer dynamiquement la dépendance if language == "zh-cn": import importlib importlib.import_module("pypinyin") elif language == "ja": import importlib importlib.import_module("cutlet") # Vérifier les dépendances supplémentaires pour le japonais try: importlib.import_module("fugashi") # Vérifier si unidic-lite est installé try: import unidic_lite except ImportError: raise ImportError("Japanese requires: unidic-lite") except ImportError: raise ImportError("Japanese requires: fugashi and unidic-lite") elif language == "ko": import importlib importlib.import_module("hangul_romanize") except ImportError as e: dependency = language_dependencies[language] language_name = { "zh-cn": "Chinese", "ja": "Japanese", "ko": "Korean" }[language] # Message personnalisé pour les dépendances japonaises if language == "ja" and "fugashi" in str(e): install_command = "pip install fugashi mecab-python3 unidic-lite" error_message = f""" Error: Missing dependencies for {language_name} language. Please run the following command to install the required packages: {install_command} Then restart the application. """ else: install_command = f"pip install {dependency}" error_message = f""" Error: Missing dependency for {language_name} language. Please run the following command to install the required package: {install_command} Then restart the application. """ return None, error_message return None, None @spaces.GPU() def synthesize_speech( text, language, temperature, speed, reference_audio, do_sample=True, repetition_penalty=1.0, length_penalty=1.0, gpt_cond_len=30, top_k=50, top_p=0.85, remove_silence_enabled=True, silence_threshold=-45, min_silence_len=300, keep_silence=100, text_splitting_method="Native XTTS splitting", max_chars_per_segment=250, enable_preprocessing=True ): """Generate speech from text by orchestrating preprocessing, synthesis, and post-processing. This function acts as the main pipeline for TTS generation. It takes raw text and parameters, handles dependencies, preprocesses text, generates a raw audio waveform using the XTTS model, and then post-processes the audio (normalization, silence removal) to produce a final MP3 file. Args: text (str): The text to convert to speech. language (str): Language code for synthesis (e.g., 'en', 'fr'). temperature (float): Controls randomness in generation (0.1-1.5, recommended: 0.75). speed (float): Speech speed multiplier (0.5-2.0, 1.0 = normal speed). reference_audio (str): File path or URL to reference audio for voice cloning. do_sample (bool): Enable sampling for more natural speech variation. repetition_penalty (float): Penalty for repetitive speech (1.0-5.0, recommended: 5.0). length_penalty (float): Penalty affecting speech length (1.0-2.0, recommended: 1.0). gpt_cond_len (int): Conditioning length for GPT model (10-50, recommended: 30). top_k (int): Top-K sampling parameter (0-50, 0 = disabled). top_p (float): Top-P sampling parameter (0.0-1.0, 0 = disabled). remove_silence_enabled (bool): Remove silent parts from generated audio. silence_threshold (int): dB threshold for silence detection (-60 to -20). min_silence_len (int): Minimum silence length in ms to detect (300-1000). keep_silence (int): Amount of silence to keep in ms (100-500). text_splitting_method (str): Method for splitting long text. max_chars_per_segment (int): Maximum characters per segment for custom splitting. enable_preprocessing (bool): Automatically preprocess text for better pronunciation. Returns: tuple: (audio_file_path, error_message, preprocessed_text) - audio_file_path (str): Path to the generated MP3 audio file, or None on error. - error_message (str): A description of the error if one occurred, otherwise None. - preprocessed_text (str): The text after preprocessing has been applied. """ # Part 1: Validation and Parameter Setup if not text.strip(): return None, "Error: Text cannot be empty", text _, error_message = check_language_dependencies(language) if error_message: return None, error_message, text if top_k == 0: top_k = None if top_p == 0: top_p = None if temperature <= 0: temperature = 0.75 if repetition_penalty <= 0: repetition_penalty = 5.0 if length_penalty <= 0: length_penalty = 1.0 reference_audio_path = reference_audio # Part 2: Text Preprocessing preprocessed_text = text if enable_preprocessing: preprocessed_text = preprocess_text(text, language) print(f"Preprocessed text: {preprocessed_text}") # Part 3: Waveform Generation (Core Synthesis) try: if text_splitting_method == "Custom splitting": text_chunks = split_text(preprocessed_text, max_length=max_chars_per_segment) print(f"Text split into {len(text_chunks)} segments (max {max_chars_per_segment} characters per segment)") if not text_chunks: return None, "Error: The text could not be split into segments", preprocessed_text outputs_wav_list = [] for i, chunk in enumerate(text_chunks): print(f"Processing segment {i+1}/{len(text_chunks)}: {chunk}") chunk_output = model.synthesize( chunk, config, speaker_wav=reference_audio_path, language=language, temperature=temperature, do_sample=do_sample, speed=speed, enable_text_splitting=True, repetition_penalty=repetition_penalty, length_penalty=length_penalty, gpt_cond_len=gpt_cond_len, top_k=top_k, top_p=top_p ) outputs_wav_list.append(chunk_output["wav"]) if outputs_wav_list: outputs_wav = np.concatenate(outputs_wav_list) else: return None, "Error: No audio segment could be generated", preprocessed_text else: # Always enable native XTTS splitting by default for better AI agent compatibility use_native_splitting = True if text_splitting_method == "No splitting": use_native_splitting = False print("Native XTTS splitting disabled by user request") elif len(preprocessed_text) > 150: print("Long text detected: native XTTS splitting is enabled") use_native_splitting = True print(f"Generating with parameters: temperature={temperature}, do_sample={do_sample}, repetition_penalty={repetition_penalty}, length_penalty={length_penalty}, top_k={top_k}, top_p={top_p}, enable_text_splitting={use_native_splitting}") outputs = model.synthesize( preprocessed_text, config, speaker_wav=reference_audio_path, language=language, temperature=temperature, do_sample=do_sample, speed=speed, enable_text_splitting=use_native_splitting, repetition_penalty=repetition_penalty, length_penalty=length_penalty, gpt_cond_len=gpt_cond_len, top_k=top_k, top_p=top_p ) outputs_wav = outputs["wav"] except Exception as e: error_message = f"Error during audio generation: {str(e)}" print(error_message) error_str = str(e) if "Chinese requires: pypinyin" in error_str: error_message = "Error: Missing pypinyin package for Chinese language support.\n\nPlease run: pip install pypinyin" elif "No module named 'cutlet'" in error_str: error_message = "Error: Missing cutlet package for Japanese language support.\n\nPlease run: pip install cutlet" elif "Japanese requires: fugashi" in error_str: error_message = "Error: Missing fugashi package for Japanese language support.\n\nPlease run: pip install fugashi mecab-python3 unidic-lite" elif "Japanese requires: unidic-lite" in error_str: error_message = "Error: Missing unidic-lite package for Japanese language support.\n\nPlease run: pip install unidic-lite" elif "Failed initializing MeCab" in error_str or "no such file or directory: /usr/local/etc/mecabrc" in error_str: error_message = """Error: MeCab initialization failed for Japanese language support. Please run: pip install fugashi mecab-python3 unidic-lite If the error persists, you may need to install MeCab dictionaries: - For Ubuntu/Debian: sudo apt-get install mecab mecab-ipadic - For macOS with Homebrew: brew install mecab mecab-ipadic """ elif "Korean requires: hangul_romanize" in error_str: error_message = "Error: Missing hangul-romanize package for Korean language support.\n\nPlease run: pip install hangul-romanize" return None, error_message, preprocessed_text # Part 4: Audio Post-Processing try: temp_audio_path = str(TEMP_DIR / f"temp_chunk_audio_{uuid.uuid4()}.wav") torchaudio.save(temp_audio_path, torch.tensor(outputs_wav).unsqueeze(0), 24000) audio_segment = AudioSegment.from_wav(temp_audio_path) # Normalisation du volume de manière moins agressive target_dbfs = -18.0 current_dbfs = audio_segment.dBFS if current_dbfs < -50: delta_db = -18.0 - current_dbfs delta_db = min(delta_db, 20.0) audio_segment = audio_segment.apply_gain(delta_db) else: delta_db = target_dbfs - current_dbfs audio_segment = audio_segment.apply_gain(delta_db) combined_audio = audio_segment # Suppression des silences si activée if remove_silence_enabled: padding = AudioSegment.silent(duration=500, frame_rate=combined_audio.frame_rate) padded_audio = padding + combined_audio + padding processed_audio = remove_silence( padded_audio, silence_thresh=silence_threshold, min_silence_len=min_silence_len, keep_silence=keep_silence ) if len(processed_audio) > len(combined_audio) + 900: trim_length = min(500, len(processed_audio) // 10) combined_audio = processed_audio[trim_length:-trim_length] else: combined_audio = processed_audio timestamp = time.strftime("%Y%m%d-%H%M%S") final_output_path = str(TEMP_DIR / f"temp_output_{timestamp}_{uuid.uuid4()}.mp3") combined_audio.export(final_output_path, format="mp3", bitrate="192k") try: os.remove(temp_audio_path) except: pass return final_output_path, None, preprocessed_text except Exception as e: error_message = f"Error during audio processing: {str(e)}" print(error_message) return None, error_message, preprocessed_text def download_audio_from_url(url): """Downloads an audio file from a URL and saves it to a temporary file.""" try: if not url.startswith(('http://', 'https://')): raise ValueError("URL must start with http:// or https://") response = requests.get(url, stream=True, timeout=20) # 20 seconds timeout response.raise_for_status() # Use a temporary file to store the audio with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as temp_audio: for chunk in response.iter_content(chunk_size=8192): temp_audio.write(chunk) print(f"Audio downloaded from {url} to {temp_audio.name}") return temp_audio.name except (requests.exceptions.RequestException, ValueError) as e: print(f"Failed to download audio from {url}: {e}") return None def voice_clone_synthesis( text: str, reference_audio_url: str = None, example_audio_name: str = None, language: str = "English", temperature: float = 0.75, speed: float = 1.0, do_sample: bool = True, repetition_penalty: float = 5.0, length_penalty: float = 1.0, gpt_cond_len: int = 30, top_k: int = 50, top_p: float = 0.85, remove_silence_enabled: bool = True, silence_threshold: int = -45, min_silence_len: int = 300, keep_silence: int = 100, text_splitting_method: str = "Native XTTS splitting", max_chars_per_segment: int = 250, enable_preprocessing: bool = False ): """ 🎤 Generates speech by cloning a voice from a reference audio URL. This tool takes text and a URL to a reference audio file, and synthesizes the text in the voice from the reference audio. It supports 17 languages and offers advanced control over the generation process. Args: text (str): The text to be synthesized. Required. reference_audio_url (str, optional): A public URL pointing to a reference audio file (WAV or MP3). Provide this OR example_audio_name, but not both. example_audio_name (str, optional): The name of a pre-defined example audio file. Valid choices: 'audio_1.wav', 'audio_2.wav', 'audio_3.wav', 'audio_4.wav', 'audio_5.wav', 'guzel_ses.wav', 'guzel_ses_rapide.wav'. Provide this OR reference_audio_url, but not both. language (str): The language of the text. Defaults to "English". Supported languages: English, French, Spanish, German, Italian, Portuguese, Polish, Turkish, Russian, Dutch, Czech, Arabic, Chinese, Japanese, Korean, Hungarian, Hindi. temperature (float): Controls the randomness of the output. Higher values make it more random. Range: 0.1-1.5. Default: 0.75. Recommended: 0.75 for balanced output. speed (float): The speed of the generated speech. Range: 0.5-2.0. Default: 1.0. Example: 0.8 = slower, 1.2 = faster. do_sample (bool): Whether to use sampling for generation. Recommended: True. Default: True. repetition_penalty (float): Penalty for repeating words or phrases. IMPORTANT: Must be > 1.0. Range: 1.0-5.0. Default: 5.0. Higher values reduce repetition. AI agents should use values like 1.1, 1.5, 2.0, 3.0, 4.0, 5.0. length_penalty (float): Penalty for sentence length. IMPORTANT: Must be > 1.0. Range: 1.0-2.0. Default: 1.0. Higher values encourage shorter sentences. gpt_cond_len (int): Conditioning length for the GPT model. Range: 10-50. Default: 30. Higher values use more context. top_k (int): Top-K sampling parameter. 0 to disable top-k. Range: 0-50. Default: 50. Lower values make output more focused. top_p (float): Top-P (nucleus) sampling parameter. 0.0 to disable top-p. Range: 0.0-1.0. Default: 0.85. Lower values make output more focused. remove_silence_enabled (bool): Enable/disable automatic silence removal. Default: True. silence_threshold (int): Silence threshold in dB for silence detection. Range: -60 to -20. Default: -45. More negative = more sensitive to silence. min_silence_len (int): Minimum length of silence to be removed in milliseconds. Range: 300-1000. Default: 300. keep_silence (int): Amount of silence to keep at the beginning/end in milliseconds. Range: 100-500. Default: 100. text_splitting_method (str): Method for splitting text. Valid choices: 'Native XTTS splitting', 'Custom splitting', 'No splitting'. Default: 'Native XTTS splitting'. Recommended for most use cases. max_chars_per_segment (int): Max characters per segment when using 'Custom splitting'. Range: 50-400. Default: 250. Only relevant when text_splitting_method = 'Custom splitting'. enable_preprocessing (bool): Enable automatic text preprocessing to clean problematic characters. Default: False. Recommended: True for better pronunciation. Returns: str: A URL to the generated MP3 audio file. Examples: Basic usage with example audio: voice_clone_synthesis( text="Hello world!", example_audio_name="audio_1.wav", language="English" ) Advanced usage with custom parameters: voice_clone_synthesis( text="Bonjour le monde!", example_audio_name="audio_2.wav", language="French", temperature=0.8, speed=1.1, repetition_penalty=2.0, # Note: > 1.0 required length_penalty=1.2, # Note: > 1.0 required enable_preprocessing=True ) Raises: gr.Error: If parameters are out of range or invalid combinations are used. """ # Validate and convert parameter types early for better AI agent feedback temperature = float(temperature) speed = float(speed) repetition_penalty = float(repetition_penalty) length_penalty = float(length_penalty) gpt_cond_len = int(gpt_cond_len) top_k = int(top_k) top_p = float(top_p) silence_threshold = int(silence_threshold) min_silence_len = int(min_silence_len) keep_silence = int(keep_silence) max_chars_per_segment = int(max_chars_per_segment) if not (0.1 <= temperature <= 1.5): raise gr.Error(f"Temperature must be between 0.1 and 1.5, got {temperature}") if not (0.5 <= speed <= 2.0): raise gr.Error(f"Speed must be between 0.5 and 2.0, got {speed}") if not (1.0 <= repetition_penalty <= 5.0): raise gr.Error(f"Repetition penalty must be between 1.0 and 5.0, got {repetition_penalty}") if not (1.0 <= length_penalty <= 2.0): raise gr.Error(f"Length penalty must be between 1.0 and 2.0, got {length_penalty}") if not (10 <= gpt_cond_len <= 50): raise gr.Error(f"GPT conditioning length must be between 10 and 50, got {gpt_cond_len}") if not (0 <= top_k <= 50): raise gr.Error(f"Top-K must be between 0 and 50, got {top_k}") if not (0.0 <= top_p <= 1.0): raise gr.Error(f"Top-P must be between 0.0 and 1.0, got {top_p}") if not (-60 <= silence_threshold <= -20): raise gr.Error(f"Silence threshold must be between -60 and -20 dB, got {silence_threshold}") if not (300 <= min_silence_len <= 1000): raise gr.Error(f"Minimum silence length must be between 300 and 1000 ms, got {min_silence_len}") if not (100 <= keep_silence <= 500): raise gr.Error(f"Keep silence must be between 100 and 500 ms, got {keep_silence}") if not (50 <= max_chars_per_segment <= 400): raise gr.Error(f"Max characters per segment must be between 50 and 400, got {max_chars_per_segment}") valid_splitting_methods = ["Native XTTS splitting", "Custom splitting", "No splitting"] if text_splitting_method not in valid_splitting_methods: raise gr.Error(f"Text splitting method must be one of {valid_splitting_methods}, got '{text_splitting_method}'") valid_example_audios = ["audio_1.wav", "audio_2.wav", "audio_3.wav", "audio_4.wav", "audio_5.wav", "guzel_ses.wav", "guzel_ses_rapide.wav"] if example_audio_name and example_audio_name not in valid_example_audios: raise gr.Error(f"Example audio name must be one of {valid_example_audios}, got '{example_audio_name}'") reference_audio_path = None downloaded_path = None # To keep track of downloaded file for cleanup # Ensure only one reference type is provided if reference_audio_url and example_audio_name: raise gr.Error("Please provide either 'reference_audio_url' or 'example_audio_name', but not both.") if not reference_audio_url and not example_audio_name: raise gr.Error("You must provide either 'reference_audio_url' or 'example_audio_name'.") # Use the example audio if provided if example_audio_name: if example_audio_name not in file_path_mapping: available_files = ", ".join(files_display) raise gr.Error(f"Invalid example audio name. Available files are: {available_files}") reference_audio_path = file_path_mapping[example_audio_name] print(f"Using example audio: {reference_audio_path}") # Otherwise, download from URL if reference_audio_url: print(f"Downloading reference audio from: {reference_audio_url}") downloaded_path = download_audio_from_url(reference_audio_url) if not downloaded_path: raise gr.Error("Failed to download or process the reference audio from the provided URL.") reference_audio_path = downloaded_path # Validate the selected audio file is_valid, error_message = validate_audio_file(reference_audio_path) if not is_valid: if downloaded_path and os.path.exists(downloaded_path): os.remove(downloaded_path) raise gr.Error(error_message) language_code = SUPPORTED_LANGUAGES.get(language) if not language_code: if downloaded_path and os.path.exists(downloaded_path): os.remove(downloaded_path) raise gr.Error(f"Language '{language}' is not supported.") audio_path, error, _ = synthesize_speech( text=text, language=language_code, temperature=temperature, speed=speed, reference_audio=reference_audio_path, do_sample=do_sample, repetition_penalty=repetition_penalty, length_penalty=length_penalty, gpt_cond_len=gpt_cond_len, top_k=top_k, top_p=top_p, remove_silence_enabled=remove_silence_enabled, silence_threshold=silence_threshold, min_silence_len=min_silence_len, keep_silence=keep_silence, text_splitting_method=text_splitting_method, max_chars_per_segment=max_chars_per_segment, enable_preprocessing=enable_preprocessing ) # Clean up downloaded file if it exists if downloaded_path and os.path.exists(downloaded_path): os.remove(downloaded_path) if error: raise gr.Error(error) return audio_path def analyze_text_for_speech(text: str, language: str): """ 📊 Analyzes text for potential pronunciation and synthesis issues. This tool examines text for elements that could be mispronounced by the TTS model, such as special characters, numbers, URLs, and language-specific patterns. It provides a structured report of potential issues. Args: text (str): The text to analyze. Required. language (str): The language of the text. Required. Supported languages: English, French, Spanish, German, Italian, Portuguese, Polish, Turkish, Russian, Dutch, Czech, Arabic, Chinese, Japanese, Korean, Hungarian, Hindi. Note: Use exact language names (case-sensitive). Returns: dict: A dictionary containing the analysis results with these keys: - standard_analysis_issues: List of detected issues with descriptions and suggestions - has_issues: Boolean indicating if any issues were found - xtts_cleaned_text: Preprocessed version of the text ready for synthesis Example: analyze_text_for_speech( text="Hello! This costs $15.99 & includes free shipping.", language="English" ) Raises: gr.Error: If the language is not supported. """ language_code = SUPPORTED_LANGUAGES.get(language) if not language_code: raise gr.Error(f"Language '{language}' is not supported.") standard_analysis = analyze_text(text, language_code) # tokenizer_analysis = analyze_with_tokenizer(text, language_code) combined_issues = { "standard_analysis_issues": standard_analysis.get('issues', []), # "tokenizer_analysis_issues": tokenizer_analysis.get('issues', []), "has_issues": standard_analysis.get('has_issues', False), # or tokenizer_analysis.get('has_issues', False), "xtts_cleaned_text": preprocess_text(text, language_code) # tokenizer_analysis.get('cleaned_text', text) } return combined_issues def preprocess_text_for_speech(text: str, language: str): """ 🔧 Preprocesses and cleans text for optimal speech synthesis. This tool applies a series of cleaning and normalization rules to the input text to improve its compatibility with the TTS model. This includes handling numbers, special characters, URLs, and applying language-specific typographical rules. Args: text (str): The text to preprocess. Required. language (str): The language of the text. Required. Supported languages: English, French, Spanish, German, Italian, Portuguese, Polish, Turkish, Russian, Dutch, Czech, Arabic, Chinese, Japanese, Korean, Hungarian, Hindi. Note: Use exact language names (case-sensitive). Returns: str: The cleaned and preprocessed text ready for speech synthesis. Example: preprocess_text_for_speech( text="Visit https://example.com & pay $25.50!", language="English" ) # Returns: "Visit example.com and pay twenty-five dollars and fifty cents!" Raises: gr.Error: If the language is not supported. """ language_code = SUPPORTED_LANGUAGES.get(language) if not language_code: raise gr.Error(f"Language '{language}' is not supported.") return preprocess_text(text, language_code, apply_replacements=True) # Example texts for different languages EXAMPLE_TEXTS = { "fr": "Bonjour, je suis une voix générée par intelligence artificielle. Comment puis-je vous aider aujourd'hui?", "en": "Hello, I am a voice generated by artificial intelligence. How may I assist you today?", "es": "Hola, soy una voz generada por inteligencia artificial. ¿Cómo puedo ayudarte hoy?", "de": "Hallo, ich bin eine von künstlicher Intelligenz generierte Stimme. Wie kann ich Ihnen heute helfen?", "it": "Ciao, sono una voce generata dall'intelligenza artificiale. Come posso aiutarti oggi?", "pt": "Olá, sou uma voz gerada por inteligência artificial. Como posso ajudá-lo hoje?", "ar": "مرحبا، أنا صوت تم إنشاؤه بواسطة الذكاء الاصطناعي. كيف يمكنني مساعدتك اليوم؟", "zh-cn": "你好，我是由人工智能生成的声音。今天我能为您提供什么帮助？", "ja": "こんにちは、私は人工知能によって生成された音声です。今日はどのようにお手伝いできますか？", "ko": "안녕하세요, 저는 인공지능으로 생성된 목소리입니다. 오늘 어떻게 도와드릴까요?", "ru": "Здравствуйте, я голос, сгенерированный искусственным интеллектом. Чем я могу вам помочь сегодня?", "nl": "Hallo, ik ben een stem gegenereerd door kunstmatige intelligentie. Hoe kan ik u vandaag helpen?", "cs": "Dobrý den, jsem hlas vytvořený umělou inteligencí. Jak vám mohu dnes pomoci?", "pl": "Dzień dobry, jestem głosem wygenerowanym przez sztuczną inteligencję. Jak mogę ci dziś pomóc?", "tr": "Merhaba, ben yapay zeka tarafından oluşturulan bir sesim. Bugün size nasıl yardımcı olabilirim?", "hu": "Üdvözlöm, én egy mesterséges intelligencia által generált hang vagyok. Hogyan segíthetek ma?", "hi": "नमस्ते, मैं कृत्रिम बुद्धिमत्ता द्वारा उत्पन्न एक आवाज हूं। मैं आज आपकी कैसे मदद कर सकता हूं?" } # Function to analyze text with the XTTS tokenizer def analyze_with_tokenizer(text, language_code): """ Analyzes text using the XTTS model's tokenizer to detect parts that may be problematic for pronunciation. Args: text (str): The text to analyze language_code (str): Language code (fr, en, etc.) Returns: dict: A dictionary containing detected issues and suggestions """ import torch from TTS.tts.layers.xtts.tokenizer import multilingual_cleaners issues = [] original_text = text try: # 1. Run the same preprocessing as the XTTS model uses internally cleaned_text = text print(f"Using XTTS cleaners for language: {language_code}") # The multilingual_cleaners object is a dictionary mapping language codes to cleaner functions. if language_code in multilingual_cleaners: cleaner_fn = multilingual_cleaners[language_code] cleaned_text = cleaner_fn(text) else: # If no specific cleaner is available, we just use the original text. # The TTS model will use its default basic cleaners internally. print(f"No specific cleaner for language {language_code}, using original text for analysis.") cleaned_text = text # 2. Tokenize the text as XTTS would # Compare the original and cleaned text to detect changes if original_text != cleaned_text: # Find the parts that have been modified import difflib # Create an object to compare the two texts differ = difflib.Differ() diff = list(differ.compare(original_text.split(), cleaned_text.split())) # Find the words that have been removed or changed modified_words = [] for d in diff: if d.startswith('- '): word = d[2:] if len(word) > 1: # Ignore individual characters modified_words.append(word) if modified_words: issues.append({ 'type': 'tokenizer_changes', 'description': 'Words that might be mispronounced', 'instances': modified_words, 'suggestion': 'Consider reformulating these parts or using automatic preprocessing' }) # 3. Check for words out of vocabulary (OOV) using the XTTS tokenizer # This part would require accessing the tokenizer's vocabulary, # which might not be directly accessible. # 4. Check for rare words that might be mispronounced words = text.split() long_words = [w for w in words if len(w) > 12] # Extremely long words if long_words: issues.append({ 'type': 'long_words', 'description': 'Extremely long words that might be mispronounced', 'instances': long_words, 'suggestion': 'Check if these words are pronounced correctly, try splitting them or reformulating' }) # 5. Check for special characters that are preserved after cleaning import re special_chars = re.findall(r'[^a-zA-Z0-9\s.,;:!?\'"-]', cleaned_text) if special_chars: unique_special_chars = list(set(special_chars)) issues.append({ 'type': 'special_chars_preserved', 'description': 'Special characters preserved by the tokenizer', 'instances': unique_special_chars, 'suggestion': 'These characters might cause pronunciation issues' }) return { 'issues': issues, 'has_issues': len(issues) > 0, 'cleaned_text': cleaned_text } except Exception as e: print(f"Error in tokenizer analysis: {e}") return { 'issues': [{ 'type': 'analysis_error', 'description': 'Error during analysis with the tokenizer', 'instances': [str(e)], 'suggestion': 'Technical error, please try again' }], 'has_issues': True, 'cleaned_text': text } # Function to combine both analyses def combined_analysis(text, language): """Perform comprehensive text analysis for optimal voice synthesis quality. This function combines standard text analysis with XTTS tokenizer analysis to detect and report all potential issues that might affect speech synthesis. Args: text: The text to analyze for speech synthesis compatibility language: Language name (English, French, Spanish, German, Italian, Portuguese, Polish, Turkish, Russian, Dutch, Czech, Arabic, Chinese, Hungarian, Korean, Japanese, Hindi) Returns: A tuple containing detailed analysis report and cleaned text ready for synthesis """ language_code = SUPPORTED_LANGUAGES[language] # Run standard analysis standard_analysis = analyze_text(text, language_code) # Run analysis with tokenizer tokenizer_analysis = analyze_with_tokenizer(text, language_code) # Combine results display_text = format_issues_for_display(standard_analysis, language_code, tokenizer_analysis) # Get the preprocessed text (prefer the result from the tokenizer if it exists) cleaned_text = tokenizer_analysis.get('cleaned_text', "") if not cleaned_text or cleaned_text == text: cleaned_text = preprocess_text(text, language_code) if text else "" return display_text, cleaned_text def cleanup_old_files(max_age_minutes=60): """ Optimized: deletes temporary files older than max_age_minutes. This function can be called regularly to prevent accumulation of files. """ try: now = time.time() count_removed = 0 # Clean temporary files for file in TEMP_DIR.glob("*"): if file.is_file(): file_age_minutes = (now - os.path.getmtime(file)) / 60 if file_age_minutes > max_age_minutes: os.remove(file) count_removed += 1 # Clean old output files for file in OUTPUT_DIR.glob("*.mp3"): if file.is_file(): file_age_days = (now - os.path.getmtime(file)) / (24 * 60 * 60) if file_age_days > 7: # Keep one week os.remove(file) count_removed += 1 return count_removed except Exception as e: return 0 # Create interface with Gradio Blocks with gr.Blocks(theme=gr.themes.Ocean(), css=""" .gradio-container { max-width: 1280px !important; margin: auto !important; } #header { display: flex; justify-content: center; align-items: center; padding: 10px 0; } """) as interface: with gr.Row(elem_id="header"): gr.Markdown( """

🎙️ Voice Cloning Studio

Bring any voice to life from a 3-second audio sample.

""" ) # Get all reference audio files and simplify their display try: files_paths = [str(f) for f in REF_AUDIO_DIR.iterdir() if f.is_file() and f.suffix.lower() in ['.wav', '.mp3']] files_display = [os.path.basename(f) for f in files_paths] file_path_mapping = dict(zip(files_display, files_paths)) except Exception as e: files_paths = [] files_display = [] file_path_mapping = {} with gr.Row(equal_height=False): # LEFT COLUMN: Inputs & Settings with gr.Column(scale=2): with gr.Tabs(): with gr.TabItem("1. Voice"): gr.Markdown("### Select a Reference Voice") gr.Markdown("Choose a pre-defined example or upload your own 3-10 second audio clip. For best results, use a clear, high-quality recording with no background noise.") example_audio_dropdown = gr.Dropdown( choices=files_display, label="Reference Audio (from examples)", value=files_display[0] if files_display else None, interactive=True ) reference_audio_input = gr.Audio( label="Reference Audio (upload your own)", type="filepath" ) with gr.TabItem("2. Text & Language"): gr.Markdown("### Enter Text and Select Language") lang_dropdown = gr.Dropdown( choices=list(SUPPORTED_LANGUAGES.keys()), value="English", label="Language" ) text_input = gr.Textbox( label="Text to Synthesize", placeholder="Enter text here...", lines=5, value="Hello, I am a voice generated by artificial intelligence. How may I assist you today?" ) with gr.Row(): example_buttons = [] example_langs_to_show = ["en", "fr", "es", "de", "zh-cn"] for lang in example_langs_to_show: if lang in EXAMPLE_TEXTS: example_buttons.append(gr.Button(f"Example ({lang.upper()})")) with gr.Accordion("Text Analysis & Preprocessing", open=True): with gr.Row(): analyze_button = gr.Button("Analyze Text") enable_preprocessing = gr.Checkbox( value=False, label="Preprocess text automatically" ) text_analysis_output = gr.Textbox( label="Text Analysis", value="Click 'Analyze Text' to see results here.", lines=6 ) preprocessed_text_output = gr.Textbox( label="Preprocessed Text", value="The processed text will appear here after analysis or generation.", lines=3, visible=True ) with gr.TabItem("3. Settings"): gr.Markdown("### Fine-Tune Your Audio") gr.Markdown("Adjust these settings to control the style and quality of the generated speech.") with gr.Accordion("Generation Settings", open=True): with gr.Row(): with gr.Column(): temperature_slider = gr.Slider(minimum=0.1, maximum=1.5, step=0.05, value=0.75, label="Temperature") speed_slider = gr.Slider(minimum=0.5, maximum=2.0, step=0.05, value=1.0, label="Speed") do_sample = gr.Checkbox(value=True, label="Enable Sampling (do_sample)") with gr.Column(): repetition_penalty = gr.Slider(minimum=1.0, maximum=5.0, step=0.1, value=5.0, label="Repetition Penalty") length_penalty = gr.Slider(minimum=1.0, maximum=2.0, step=0.1, value=1.0, label="Length Penalty") gpt_cond_len = gr.Slider(minimum=10, maximum=50, step=1, value=30, label="GPT Conditioning Length") top_k = gr.Slider(minimum=0, maximum=50, step=1, value=50, label="Top-K") top_p = gr.Slider(minimum=0.0, maximum=1.0, step=0.05, value=0.85, label="Top-P") with gr.Accordion("Text Splitting", open=False): text_splitting_method = gr.Radio( choices=["Native XTTS splitting", "Custom splitting", "No splitting"], value="Native XTTS splitting", label="Text Splitting Method" ) enable_text_splitting = gr.Checkbox( value=True, label="enable_text_splitting (XTTS parameter)", visible=False ) max_chars_per_segment = gr.Slider( minimum=50, maximum=400, step=10, value=250, label="Max characters per segment", visible=False ) with gr.Accordion("Silence Removal", open=False): remove_silence_enabled = gr.Checkbox(value=True, label="Remove silences from audio") silence_threshold = gr.Slider(minimum=-60, maximum=-20, step=5, value=-45, label="Silence threshold (dB)") min_silence_len = gr.Slider(minimum=300, maximum=1000, step=50, value=300, label="Minimum silence length (ms)") keep_silence = gr.Slider(minimum=100, maximum=500, step=10, value=100, label="Silence to keep (ms)") # RIGHT COLUMN: Output with gr.Column(scale=1): gr.Markdown("### 4. Generate & Listen") gr.Markdown("Click the button to generate your audio. Results will appear below.") generate_button = gr.Button("Generate Audio", variant="primary", scale=1) output_audio = gr.Audio(label="Generated Audio") output_message = gr.Textbox(label="Status & Tips", visible=True, lines=8) with gr.Accordion("User Guide, Disclaimer & API Info", open=False): with gr.Tabs(): with gr.TabItem("🎯 Quick Start Guide"): gr.Markdown(""" ## 🎯 Quick User Guide 1. **Choose a reference voice**: In the **Voice** tab, select an example from the dropdown or upload your own clear audio file (3-10 seconds). 2. **Enter your text**: In the **Text & Language** tab, type or paste the text you want to synthesize and select the correct language. 3. **Generate**: Click the "Generate Audio" button. 4. **Iterate**: If you're not happy with the result, try regenerating. Small changes to the settings in the **Settings** tab can produce different results. ### 🔍 Essential Tips - **Reference Audio Quality**: The quality of the generated audio heavily depends on the reference. Use clean recordings with no background noise. - **Text Preprocessing**: Keep "Preprocess text automatically" enabled. It improves pronunciation of numbers, symbols, and URLs. Use the "Analyze Text" button to see potential issues. - **Optimizing Results**: For long texts, "Native XTTS splitting" is recommended. To change the speech style, try regenerating, adjusting the `Temperature`, or changing the `Speed`. - **Languages**: Ensure the selected language matches the text. """) with gr.TabItem("⚠️ Disclaimer"): gr.Markdown(""" ## ⚠️ Disclaimer and Legal Notice **By using this voice cloning application, you acknowledge and agree to the following:** 1. This application is provided "as is" without any warranties of any kind, either express or implied. 2. The creator(s) of this application accept no responsibility or liability for any misuse of the technology. 3. You are solely responsible for obtaining proper consent when cloning someone else's voice. 4. You agree not to use this technology for deceptive, harmful, or illegal purposes. 5. Voice cloning results may vary in quality and accuracy; no specific results are guaranteed. 6. You understand that voice cloning technology has ethical implications and agree to use it responsibly. The technology is intended for legitimate creative, educational, and accessibility purposes only. --- ### License & Model Information By accessing or using any feature within this space, you acknowledge and accept the terms of the following license: [https://coqui.ai/cpml](https://coqui.ai/cpml). **Model source:** [coqui/XTTS-v2](https://huggingface.co/coqui/XTTS-v2) """) with gr.TabItem("🔧 API Tools"): gr.Markdown(f""" ## 🛠️ Model Context Protocol (MCP) Tools This application exposes MCP tools that you can use with LLMs. **MCP Endpoint:** `https://hasanbasbunar-voice-cloning-xtts-v2.hf.space/gradio_api/mcp/sse` --- ### 🎤 `voice_clone_synthesis` Generates an audio file by cloning a voice from a reference audio file (provided via URL or a local example). **Parameters:** - `text` (string, required): The text to synthesize. - `reference_audio_url` (string, optional): A public URL for a reference audio file (WAV, MP3). **Provide this OR `example_audio_name`.** - `example_audio_name` (string, optional): The name of a predefined example audio file. **Provide this OR `reference_audio_url`.** Available files are: {', '.join(files_display)}. - `language` (string, optional): The language of the text. Default: "English". - ... (and other advanced parameters, see the function's docstring for a full list). **Returns:** - `string`: A URL to the generated MP3 audio file. --- ### 📊 `analyze_text_for_speech` Analyzes text for potential pronunciation issues. **Parameters:** - `text` (string, required): The text to analyze. - `language` (string, required): The language of the text. **Returns:** - `object`: A JSON object with the detected issues. --- ### 🔧 `preprocess_text_for_speech` Cleans and preprocesses text for optimal speech synthesis. **Parameters:** - `text` (string, required): The text to preprocess. - `language` (string, required): The language of the text. **Returns:** - `string`: The cleaned text. """) # Functions for example texts for i, lang_code in enumerate(example_langs_to_show): if lang_code in EXAMPLE_TEXTS: lang_name = next((k for k, v in SUPPORTED_LANGUAGES.items() if v == lang_code), None) if lang_name: example_buttons[i].click( lambda t, l: (t, l), inputs=[gr.Textbox(value=EXAMPLE_TEXTS[lang_code], visible=False), gr.Textbox(value=lang_name, visible=False)], outputs=[text_input, lang_dropdown], api_name=False ) # Function to analyze text and display results def analyze_input_text(text, language): language_code = SUPPORTED_LANGUAGES[language] analysis = analyze_text(text, language_code) display_text = format_issues_for_display(analysis, language_code) # Preprocess text and display it preprocessed = preprocess_text(text, language_code) if text else "" return display_text, preprocessed # Connect event handlers for text analysis text_input.change( analyze_input_text, inputs=[text_input, lang_dropdown], outputs=[text_analysis_output, preprocessed_text_output], api_name=False ) lang_dropdown.change( analyze_input_text, inputs=[text_input, lang_dropdown], outputs=[text_analysis_output, preprocessed_text_output], api_name=False ) analyze_button.click( combined_analysis, inputs=[text_input, lang_dropdown], outputs=[text_analysis_output, preprocessed_text_output], api_name=False ) # Function to validate audio files def validate_audio_file(file_path, max_size_mb=20, min_duration_sec=1, max_duration_sec=60): """ Validates audio files to ensure they are valid, have appropriate size and duration. Args: file_path (str): Path to the audio file max_size_mb (int): Maximum file size in MB min_duration_sec (float): Minimum duration in seconds max_duration_sec (float): Maximum duration in seconds Returns: tuple: (is_valid, error_message) """ # Check if file exists if not os.path.exists(file_path): return False, "Error: File does not exist" # Check file extension file_ext = os.path.splitext(file_path)[1].lower() if file_ext not in ['.mp3', '.wav']: return False, f"Error: Invalid file format {file_ext}. Only MP3 and WAV files are supported." # Check file size file_size_mb = os.path.getsize(file_path) / (1024 * 1024) if file_size_mb > max_size_mb: return False, f"Error: File size ({file_size_mb:.1f} MB) exceeds the maximum allowed size ({max_size_mb} MB)" try: # Check audio duration and integrity if file_ext == '.mp3': audio = AudioSegment.from_mp3(file_path) else: audio = AudioSegment.from_wav(file_path) duration_sec = len(audio) / 1000 if duration_sec < min_duration_sec: return False, f"Error: Audio duration ({duration_sec:.1f} sec) is too short (min: {min_duration_sec} sec)" if duration_sec > max_duration_sec: return False, f"Error: Audio duration ({duration_sec:.1f} sec) is too long (max: {max_duration_sec} sec)" # Additional check for very quiet audio if audio.dBFS < -50: return True, "Warning: Audio is very quiet, which may result in poor voice cloning quality" return True, None except Exception as e: return False, f"Error: Failed to process audio file - {str(e)}" def handle_synthesis_request( text, language, temperature, speed, reference_audio, example_audio_name, do_sample, enable_text_splitting, repetition_penalty, length_penalty, gpt_cond_len, top_k, top_p, remove_silence_enabled, silence_threshold, min_silence_len, keep_silence, text_splitting_method, max_chars_per_segment, enable_preprocessing ): """ Gradio callback to handle the "Generate Audio" button click. This function orchestrates the synthesis process by: 1. Selecting and validating the reference audio. 2. Calling the main `synthesize_speech` function. 3. Formatting the output (audio and messages) for the Gradio interface. """ language_code = SUPPORTED_LANGUAGES[language] # Ensure penalties are float repetition_penalty = float(repetition_penalty) length_penalty = float(length_penalty) # Select reference audio final_reference_audio = reference_audio if not final_reference_audio and example_audio_name: final_reference_audio = file_path_mapping.get(example_audio_name) # Validate reference audio if final_reference_audio: is_valid, error_message = validate_audio_file(final_reference_audio) if not is_valid: return None, error_message, "" # Call the main synthesis function audio_path, error_message, preprocessed_text = synthesize_speech( text=text, language=language_code, temperature=temperature, speed=speed, reference_audio=final_reference_audio, do_sample=do_sample, repetition_penalty=repetition_penalty, length_penalty=length_penalty, gpt_cond_len=gpt_cond_len, top_k=top_k, top_p=top_p, remove_silence_enabled=remove_silence_enabled, silence_threshold=silence_threshold, min_silence_len=min_silence_len, keep_silence=keep_silence, text_splitting_method=text_splitting_method, max_chars_per_segment=max_chars_per_segment, enable_preprocessing=enable_preprocessing ) if error_message: return None, error_message, preprocessed_text success_message = f""" ✅ Audio generation successful! 💾 Use the download button to save the audio. 🔄 If you're not satisfied with the result (e.g., pronunciation, intonation, or pace), feel free to click "Generate Audio" again. ℹ️ The generation process includes randomness controlled by the temperature parameter ({temperature:.2f}), so each output is unique. 🎤 For different results, try another voice from the "Reference Audio (examples)" dropdown or upload your own. ⚙️ If the result is still not satisfactory after several attempts, consider adjusting parameters in the "Advanced Settings" accordion. """ return audio_path, success_message, preprocessed_text generate_button.click( handle_synthesis_request, inputs=[ text_input, lang_dropdown, temperature_slider, speed_slider, reference_audio_input, example_audio_dropdown, do_sample, enable_text_splitting, repetition_penalty, length_penalty, gpt_cond_len, top_k, top_p, remove_silence_enabled, silence_threshold, min_silence_len, keep_silence, text_splitting_method, max_chars_per_segment, enable_preprocessing ], outputs=[output_audio, output_message, preprocessed_text_output], api_name=False ) # Function to update visibility and value of fields based on the splitting method def update_text_splitting_options(method): # Update the state of enable_text_splitting based on the selected method is_native = method == "Native XTTS splitting" is_custom = method == "Custom splitting" # Value of the enable_text_splitting checkbox enable_splitting = is_native # Visibility of the max_chars_per_segment slider show_max_chars = is_custom return gr.update(value=enable_splitting), gr.update(visible=show_max_chars) # Connect the function to the radio button change event text_splitting_method.change( update_text_splitting_options, inputs=[text_splitting_method], outputs=[enable_text_splitting, max_chars_per_segment], api_name=False ) # Section for API endpoints (hidden from UI) with gr.Tab("API Endpoints", visible=False): # API: voice_clone_synthesis with gr.Row(): api_synth_text = gr.Textbox(label="Text") api_synth_ref_url = gr.Textbox(label="Reference Audio URL") api_synth_example_name = gr.Dropdown(files_display, label="Example Audio Name") api_synth_lang = gr.Dropdown(list(SUPPORTED_LANGUAGES.keys()), label="Language", value="English") api_synth_temp = gr.Slider(minimum=0.1, maximum=1.5, value=0.75, label="Temperature") api_synth_speed = gr.Slider(minimum=0.5, maximum=2.0, value=1.0, label="Speed") api_synth_do_sample = gr.Checkbox(value=True, label="Do Sample") api_synth_rep_penalty = gr.Slider(minimum=1.0, maximum=5.0, value=5.0, label="Repetition Penalty") api_synth_len_penalty = gr.Slider(minimum=1.0, maximum=2.0, value=1.0, label="Length Penalty") api_synth_gpt_cond_len = gr.Slider(minimum=10, maximum=50, value=30, label="GPT Cond Length") api_synth_top_k = gr.Slider(minimum=0, maximum=50, value=50, label="Top K") api_synth_top_p = gr.Slider(minimum=0.0, maximum=1.0, value=0.85, label="Top P") api_synth_remove_silence = gr.Checkbox(value=True, label="Remove Silence") api_synth_silence_thresh = gr.Slider(minimum=-60, maximum=-20, value=-45, label="Silence Threshold") api_synth_min_silence_len = gr.Slider(minimum=300, maximum=1000, value=300, label="Min Silence Length") api_synth_keep_silence = gr.Slider(minimum=100, maximum=500, value=100, label="Keep Silence") api_synth_split_method = gr.Radio(choices=["Native XTTS splitting", "Custom splitting", "No splitting"], value="Native XTTS splitting", label="Splitting Method") api_synth_max_chars = gr.Slider(minimum=50, maximum=400, value=250, label="Max Chars") api_synth_preprocess = gr.Checkbox(value=False, label="Enable Preprocessing") api_synth_output_audio = gr.Audio(label="Generated Audio") api_synth_trigger = gr.Button("Synthesize_API") # API: analyze_text_for_speech with gr.Row(): api_analyze_text = gr.Textbox(label="Text") api_analyze_lang = gr.Dropdown(list(SUPPORTED_LANGUAGES.keys()), label="Language", value="English") api_analyze_output = gr.JSON(label="Analysis Result") api_analyze_trigger = gr.Button("Analyze_API") # API: preprocess_text_for_speech with gr.Row(): api_preprocess_text = gr.Textbox(label="Text") api_preprocess_lang = gr.Dropdown(list(SUPPORTED_LANGUAGES.keys()), label="Language", value="English") api_preprocess_output = gr.Textbox(label="Preprocessed Text") api_preprocess_trigger = gr.Button("Preprocess_API") # Hook API names to the triggers api_synth_trigger.click( fn=voice_clone_synthesis, inputs=[ api_synth_text, api_synth_ref_url, api_synth_example_name, api_synth_lang, api_synth_temp, api_synth_speed, api_synth_do_sample, api_synth_rep_penalty, api_synth_len_penalty, api_synth_gpt_cond_len, api_synth_top_k, api_synth_top_p, api_synth_remove_silence, api_synth_silence_thresh, api_synth_min_silence_len, api_synth_keep_silence, api_synth_split_method, api_synth_max_chars, api_synth_preprocess ], outputs=[api_synth_output_audio], api_name="voice_clone_synthesis" ) api_analyze_trigger.click( fn=analyze_text_for_speech, inputs=[api_analyze_text, api_analyze_lang], outputs=[api_analyze_output], api_name="analyze_text_for_speech" ) api_preprocess_trigger.click( fn=preprocess_text_for_speech, inputs=[api_preprocess_text, api_preprocess_lang], outputs=[api_preprocess_output], api_name="preprocess_text_for_speech" ) if __name__ == "__main__": # Setup periodic cleanup task to run every hour def periodic_cleanup(): """Run cleanup task periodically in background""" while True: try: # Sleep for 60 minutes time.sleep(60 * 60) # Run cleanup files_removed = cleanup_old_files(max_age_minutes=60) except Exception as e: print(f"Error in background cleanup task: {e}") # Start cleanup thread cleanup_thread = threading.Thread(target=periodic_cleanup, daemon=True) cleanup_thread.start() # Launch main interface with MCP enabled directly interface.queue() interface.launch(share=False, allowed_paths=[str(REF_AUDIO_DIR)])