| import os
|
| import gradio as gr
|
| from groq import Groq
|
| import tempfile
|
| import requests
|
| import json
|
| import base64
|
| from pathlib import Path
|
| import time
|
| import sys
|
| import platform
|
| import torch
|
| from collections import defaultdict
|
| import spaces
|
|
|
|
|
| @spaces.GPU
|
| def gpu_detection():
|
| """Required for ZeroGPU spaces - detects GPU availability"""
|
| import torch
|
| if torch.cuda.is_available():
|
| return "GPU available: " + torch.cuda.get_device_name(0)
|
| else:
|
| return "No GPU available - running on CPU"
|
|
|
|
|
| def gpu_detection():
|
| """Required for ZeroGPU spaces - detects GPU availability"""
|
| try:
|
| import torch
|
| if torch.cuda.is_available():
|
| return f"GPU: {torch.cuda.get_device_name(0)}"
|
| else:
|
| return "No GPU available"
|
| except ImportError:
|
| return "PyTorch not installed"
|
|
|
|
|
| groq_voices = [
|
| "Arista-PlayAI", "Atlas-PlayAI", "Basil-PlayAI", "Briggs-PlayAI",
|
| "Calum-PlayAI", "Celeste-PlayAI", "Cheyenne-PlayAI", "Chip-PlayAI",
|
| "Cillian-PlayAI", "Deedee-PlayAI", "Fritz-PlayAI", "Gail-PlayAI",
|
| "Indigo-PlayAI", "Mamaw-PlayAI", "Mason-PlayAI", "Mikail-PlayAI",
|
| "Mitch-PlayAI", "Quinn-PlayAI", "Thunder-PlayAI"
|
| ]
|
|
|
|
|
| openai_voices = ["alloy", "ash", "coral", "sage", "echo", "fable", "onyx", "nova", "shimmer"]
|
|
|
|
|
| edge_voices = [
|
| "af-ZA-AdriNeural",
|
| "af-ZA-WillemNeural",
|
| "sq-AL-AnilaNeural",
|
| "sq-AL-IlirNeural",
|
| "am-ET-AmehaNeural",
|
| "am-ET-MekdesNeural",
|
| "ar-DZ-AminaNeural",
|
| "ar-DZ-IsmaelNeural",
|
| "ar-BH-AliNeural",
|
| "ar-BH-LailaNeural",
|
| "ar-EG-SalmaNeural",
|
| "ar-EG-ShakirNeural",
|
| "ar-IQ-BasselNeural",
|
| "ar-IQ-RanaNeural",
|
| "ar-JO-SanaNeural",
|
| "ar-JO-TaimNeural",
|
| "ar-KW-FahedNeural",
|
| "ar-KW-NouraNeural",
|
| "ar-LB-LaylaNeural",
|
| "ar-LB-RamiNeural",
|
| "ar-LY-ImanNeural",
|
| "ar-LY-OmarNeural",
|
| "ar-MA-JamalNeural",
|
| "ar-MA-MounaNeural",
|
| "ar-OM-AbdullahNeural",
|
| "ar-OM-AyshaNeural",
|
| "ar-QA-AmalNeural",
|
| "ar-QA-MoazNeural",
|
| "ar-SA-HamedNeural",
|
| "ar-SA-ZariyahNeural",
|
| "ar-SY-AmanyNeural",
|
| "ar-SY-LaithNeural",
|
| "ar-TN-HediNeural",
|
| "ar-TN-ReemNeural",
|
| "ar-AE-FatimaNeural",
|
| "ar-AE-HamdanNeural",
|
| "ar-YE-MaryamNeural",
|
| "ar-YE-SalehNeural",
|
| "az-AZ-BabekNeural",
|
| "az-AZ-BanuNeural",
|
| "bn-BD-NabanitaNeural",
|
| "bn-BD-PradeepNeural",
|
| "bn-IN-BashkarNeural",
|
| "bn-IN-TanishaaNeural",
|
| "bs-BA-GoranNeural",
|
| "bs-BA-VesnaNeural",
|
| "bg-BG-BorislavNeural",
|
| "bg-BG-KalinaNeural",
|
| "my-MM-NilarNeural",
|
| "my-MM-ThihaNeural",
|
| "ca-ES-EnricNeural",
|
| "ca-ES-JoanaNeural",
|
| "zh-HK-HiuGaaiNeural",
|
| "zh-HK-HiuMaanNeural",
|
| "zh-HK-WanLungNeural",
|
| "zh-CN-XiaoxiaoNeural",
|
| "zh-CN-XiaoyiNeural",
|
| "zh-CN-YunjianNeural",
|
| "zh-CN-YunxiNeural",
|
| "zh-CN-YunxiaNeural",
|
| "zh-CN-YunyangNeural",
|
| "zh-CN-liaoning-XiaobeiNeural",
|
| "zh-TW-HsiaoChenNeural",
|
| "zh-TW-YunJheNeural",
|
| "zh-TW-HsiaoYuNeural",
|
| "zh-CN-shaanxi-XiaoniNeural",
|
| "hr-HR-GabrijelaNeural",
|
| "hr-HR-SreckoNeural",
|
| "cs-CZ-AntoninNeural",
|
| "cs-CZ-VlastaNeural",
|
| "da-DK-ChristelNeural",
|
| "da-DK-JeppeNeural",
|
| "nl-BE-ArnaudNeural",
|
| "nl-BE-DenaNeural",
|
| "nl-NL-ColetteNeural",
|
| "nl-NL-FennaNeural",
|
| "nl-NL-MaartenNeural",
|
| "en-AU-NatashaNeural",
|
| "en-AU-WilliamNeural",
|
| "en-CA-ClaraNeural",
|
| "en-CA-LiamNeural",
|
| "en-HK-SamNeural",
|
| "en-HK-YanNeural",
|
| "en-IN-NeerjaNeural",
|
| "en-IN-PrabhatNeural",
|
| "en-IE-ConnorNeural",
|
| "en-IE-EmilyNeural",
|
| "en-KE-AsiliaNeural",
|
| "en-KE-ChilembaNeural",
|
| "en-NZ-MitchellNeural",
|
| "en-NZ-MollyNeural",
|
| "en-NG-AbeoNeural",
|
| "en-NG-EzinneNeural",
|
| "en-PH-JamesNeural",
|
| "en-PH-RosaNeural",
|
| "en-SG-LunaNeural",
|
| "en-SG-WayneNeural",
|
| "en-ZA-LeahNeural",
|
| "en-ZA-LukeNeural",
|
| "en-TZ-ElimuNeural",
|
| "en-TZ-ImaniNeural",
|
| "en-GB-LibbyNeural",
|
| "en-GB-MaisieNeural",
|
| "en-GB-RyanNeural",
|
| "en-GB-SoniaNeural",
|
| "en-GB-ThomasNeural",
|
| "en-US-AriaNeural",
|
| "en-US-AnaNeural",
|
| "en-US-ChristopherNeural",
|
| "en-US-EricNeural",
|
| "en-US-GuyNeural",
|
| "en-US-JennyNeural",
|
| "en-US-MichelleNeural",
|
| "en-US-RogerNeural",
|
| "en-US-SteffanNeural",
|
| "et-EE-AnuNeural",
|
| "et-EE-KertNeural",
|
| "fil-PH-AngeloNeural",
|
| "fil-PH-BlessicaNeural",
|
| "fi-FI-HarriNeural",
|
| "fi-FI-NooraNeural",
|
| "fr-BE-CharlineNeural",
|
| "fr-BE-GerardNeural",
|
| "fr-CA-AntoineNeural",
|
| "fr-CA-JeanNeural",
|
| "fr-CA-SylvieNeural",
|
| "fr-FR-DeniseNeural",
|
| "fr-FR-EloiseNeural",
|
| "fr-FR-HenriNeural",
|
| "fr-CH-ArianeNeural",
|
| "fr-CH-FabriceNeural",
|
| "gl-ES-RoiNeural",
|
| "gl-ES-SabelaNeural",
|
| "ka-GE-EkaNeural",
|
| "ka-GE-GiorgiNeural",
|
| "de-AT-IngridNeural",
|
| "de-AT-JonasNeural",
|
| "de-DE-AmalaNeural",
|
| "de-DE-ConradNeural",
|
| "de-DE-KatjaNeural",
|
| "de-DE-KillianNeural",
|
| "de-CH-JanNeural",
|
| "de-CH-LeniNeural",
|
| "el-GR-AthinaNeural",
|
| "el-GR-NestorasNeural",
|
| "gu-IN-DhwaniNeural",
|
| "gu-IN-NiranjanNeural",
|
| "he-IL-AvriNeural",
|
| "he-IL-HilaNeural",
|
| "hi-IN-MadhurNeural",
|
| "hi-IN-SwaraNeural",
|
| "hu-HU-NoemiNeural",
|
| "hu-HU-TamasNeural",
|
| "is-IS-GudrunNeural",
|
| "is-IS-GunnarNeural",
|
| "id-ID-ArdiNeural",
|
| "id-ID-GadisNeural",
|
| "ga-IE-ColmNeural",
|
| "ga-IE-OrlaNeural",
|
| "it-IT-DiegoNeural",
|
| "it-IT-ElsaNeural",
|
| "it-IT-IsabellaNeural",
|
| "ja-JP-KeitaNeural",
|
| "ja-JP-NanamiNeural",
|
| "jv-ID-DimasNeural",
|
| "jv-ID-SitiNeural",
|
| "kn-IN-GaganNeural",
|
| "kn-IN-SapnaNeural",
|
| "kk-KZ-AigulNeural",
|
| "kk-KZ-DauletNeural",
|
| "km-KH-PisethNeural",
|
| "km-KH-SreymomNeural",
|
| "ko-KR-InJoonNeural",
|
| "ko-KR-SunHiNeural",
|
| "lo-LA-ChanthavongNeural",
|
| "lo-LA-KeomanyNeural",
|
| "lv-LV-EveritaNeural",
|
| "lv-LV-NilsNeural",
|
| "lt-LT-LeonasNeural",
|
| "lt-LT-OnaNeural",
|
| "mk-MK-AleksandarNeural",
|
| "mk-MK-MarijaNeural",
|
| "ms-MY-OsmanNeural",
|
| "ms-MY-YasminNeural",
|
| "ml-IN-MidhunNeural",
|
| "ml-IN-SobhanaNeural",
|
| "mt-MT-GraceNeural",
|
| "mt-MT-JosephNeural",
|
| "mr-IN-AarohiNeural",
|
| "mr-IN-ManoharNeural",
|
| "mn-MN-BataaNeural",
|
| "mn-MN-YesuiNeural",
|
| "ne-NP-HemkalaNeural",
|
| "ne-NP-SagarNeural",
|
| "nb-NO-FinnNeural",
|
| "nb-NO-PernilleNeural",
|
| "ps-AF-GulNawazNeural",
|
| "ps-AF-LatifaNeural",
|
| "fa-IR-DilaraNeural",
|
| "fa-IR-FaridNeural",
|
| "pl-PL-MarekNeural",
|
| "pl-PL-ZofiaNeural",
|
| "pt-BR-AntonioNeural",
|
| "pt-BR-FranciscaNeural",
|
| "pt-PT-DuarteNeural",
|
| "pt-PT-RaquelNeural",
|
| "ro-RO-AlinaNeural",
|
| "ro-RO-EmilNeural",
|
| "ru-RU-DmitryNeural",
|
| "ru-RU-SvetlanaNeural",
|
| "sr-RS-NicholasNeural",
|
| "sr-RS-SophieNeural",
|
| "si-LK-SameeraNeural",
|
| "si-LK-ThiliniNeural",
|
| "sk-SK-LukasNeural",
|
| "sk-SK-ViktoriaNeural",
|
| "sl-SI-PetraNeural",
|
| "sl-SI-RokNeural",
|
| "so-SO-MuuseNeural",
|
| "so-SO-UbaxNeural",
|
| "es-AR-ElenaNeural",
|
| "es-AR-TomasNeural",
|
| "es-BO-MarceloNeural",
|
| "es-BO-SofiaNeural",
|
| "es-CL-CatalinaNeural",
|
| "es-CL-LorenzoNeural",
|
| "es-CO-GonzaloNeural",
|
| "es-CO-SalomeNeural",
|
| "es-CR-JuanNeural",
|
| "es-CR-MariaNeural",
|
| "es-CU-BelkysNeural",
|
| "es-CU-ManuelNeural",
|
| "es-DO-EmilioNeural",
|
| "es-DO-RamonaNeural",
|
| "es-EC-AndreaNeural",
|
| "es-EC-LuisNeural",
|
| "es-SV-LorenaNeural",
|
| "es-SV-RodrigoNeural",
|
| "es-GQ-JavierNeural",
|
| "es-GQ-TeresaNeural",
|
| "es-GT-AndresNeural",
|
| "es-GT-MartaNeural",
|
| "es-HN-CarlosNeural",
|
| "es-HN-KarlaNeural",
|
| "es-MX-DaliaNeural",
|
| "es-MX-JorgeNeural",
|
| "es-MX-LorenzoEsCLNeural",
|
| "es-NI-FedericoNeural",
|
| "es-NI-YolandaNeural",
|
| "es-PA-MargaritaNeural",
|
| "es-PA-RobertoNeural",
|
| "es-PY-MarioNeural",
|
| "es-PY-TaniaNeural",
|
| "es-PE-AlexNeural",
|
| "es-PE-CamilaNeural",
|
| "es-PR-KarinaNeural",
|
| "es-PR-VictorNeural",
|
| "es-ES-AlvaroNeural",
|
| "es-ES-ElviraNeural",
|
| "es-ES-ManuelEsCUNeural",
|
| "es-US-AlonsoNeural",
|
| "es-US-PalomaNeural",
|
| "es-UY-MateoNeural",
|
| "es-UY-ValentinaNeural",
|
| "es-VE-PaolaNeural",
|
| "es-VE-SebastianNeural",
|
| "su-ID-JajangNeural",
|
| "su-ID-TutiNeural",
|
| "sw-KE-RafikiNeural",
|
| "sw-KE-ZuriNeural",
|
| "sw-TZ-DaudiNeural",
|
| "sw-TZ-RehemaNeural",
|
| "sv-SE-MattiasNeural",
|
| "sv-SE-SofieNeural",
|
| "ta-IN-PallaviNeural",
|
| "ta-IN-ValluvarNeural",
|
| "ta-MY-KaniNeural",
|
| "ta-MY-SuryaNeural",
|
| "ta-SG-AnbuNeural",
|
| "ta-SG-VenbaNeural",
|
| "ta-LK-KumarNeural",
|
| "ta-LK-SaranyaNeural",
|
| "te-IN-MohanNeural",
|
| "te-IN-ShrutiNeural",
|
| "th-TH-NiwatNeural",
|
| "th-TH-PremwadeeNeural",
|
| "tr-TR-AhmetNeural",
|
| "tr-TR-EmelNeural",
|
| "uk-UA-OstapNeural",
|
| "uk-UA-PolinaNeural",
|
| "ur-IN-GulNeural",
|
| "ur-IN-SalmanNeural",
|
| "ur-PK-AsadNeural",
|
| "ur-PK-UzmaNeural",
|
| "uz-UZ-MadinaNeural",
|
| "uz-UZ-SardorNeural",
|
| "vi-VN-HoaiMyNeural",
|
| "vi-VN-NamMinhNeural",
|
| "cy-GB-AledNeural",
|
| "cy-GB-NiaNeural",
|
| "zu-ZA-ThandoNeural",
|
| "zu-ZA-ThembaNeural"
|
| ]
|
|
|
|
|
| country_mapping = {
|
| 'ZA': 'South Africa', 'AL': 'Albania', 'ET': 'Ethiopia', 'DZ': 'Algeria', 'BH': 'Bahrain',
|
| 'EG': 'Egypt', 'IQ': 'Iraq', 'JO': 'Jordan', 'KW': 'Kuwait', 'LB': 'Lebanon', 'LY': 'Libya',
|
| 'MA': 'Morocco', 'OM': 'Oman', 'QA': 'Qatar', 'SA': 'Saudi Arabia', 'SY': 'Syria',
|
| 'TN': 'Tunisia', 'AE': 'United Arab Emirates', 'YE': 'Yemen', 'AZ': 'Azerbaijan',
|
| 'BD': 'Bangladesh', 'IN': 'India', 'BA': 'Bosnia and Herzegovina', 'BG': 'Bulgaria',
|
| 'MM': 'Myanmar', 'ES': 'Spain', 'HK': 'Hong Kong', 'CN': 'China', 'TW': 'Taiwan',
|
| 'HR': 'Croatia', 'CZ': 'Czech Republic', 'DK': 'Denmark', 'BE': 'Belgium', 'NL': 'Netherlands',
|
| 'AU': 'Australia', 'CA': 'Canada', 'IE': 'Ireland', 'KE': 'Kenya', 'NZ': 'New Zealand',
|
| 'NG': 'Nigeria', 'PH': 'Philippines', 'SG': 'Singapore', 'TZ': 'Tanzania', 'GB': 'United Kingdom',
|
| 'US': 'United States', 'EE': 'Estonia', 'FI': 'Finland', 'FR': 'France', 'CH': 'Switzerland',
|
| 'GE': 'Georgia', 'AT': 'Austria', 'DE': 'Germany', 'GR': 'Greece', 'GU': 'India',
|
| 'IL': 'Israel', 'HU': 'Hungary', 'IS': 'Iceland', 'ID': 'Indonesia', 'IT': 'Italy',
|
| 'JP': 'Japan', 'KN': 'India',
|
| 'KZ': 'Kazakhstan', 'KH': 'Cambodia', 'KR': 'South Korea', 'LA': 'Laos', 'LV': 'Latvia',
|
| 'LT': 'Lithuania', 'MK': 'North Macedonia', 'MY': 'Malaysia', 'ML': 'India',
|
| 'MT': 'Malta', 'MR': 'India',
|
| 'MN': 'Mongolia', 'NP': 'Nepal', 'NO': 'Norway', 'AF': 'Afghanistan', 'IR': 'Iran',
|
| 'PL': 'Poland', 'BR': 'Brazil', 'PT': 'Portugal', 'RO': 'Romania', 'RU': 'Russia',
|
| 'RS': 'Serbia', 'LK': 'Sri Lanka', 'SK': 'Slovakia', 'SI': 'Slovenia', 'SO': 'Somalia',
|
| 'AR': 'Argentina', 'BO': 'Bolivia', 'CL': 'Chile', 'CO': 'Colombia', 'CR': 'Costa Rica',
|
| 'CU': 'Cuba', 'DO': 'Dominican Republic', 'EC': 'Ecuador', 'SV': 'El Salvador',
|
| 'GQ': 'Equatorial Guinea', 'GT': 'Guatemala', 'HN': 'Honduras', 'MX': 'Mexico',
|
| 'NI': 'Nicaragua', 'PA': 'Panama', 'PY': 'Paraguay', 'PE': 'Peru', 'PR': 'Puerto Rico',
|
| 'UY': 'Uruguay', 'VE': 'Venezuela', 'SU': 'Indonesia',
|
| 'KE': 'Kenya', 'SE': 'Sweden', 'TA': 'India',
|
| 'LK': 'Sri Lanka',
|
| 'SG': 'Singapore',
|
| 'MY': 'Malaysia',
|
| 'TE': 'India',
|
| 'TH': 'Thailand', 'TR': 'Turkey', 'UA': 'Ukraine', 'PK': 'Pakistan', 'UZ': 'Uzbekistan',
|
| 'VN': 'Vietnam', 'CY': 'Wales', 'ZU': 'South Africa'
|
| }
|
|
|
|
|
| voices_by_country = defaultdict(list)
|
| for voice in edge_voices:
|
| country_code = voice.split('-')[1]
|
| country_name = country_mapping.get(country_code, country_code)
|
| voices_by_country[country_name].append(voice)
|
|
|
|
|
| def display_voices(country):
|
| voices = voices_by_country.get(country, [])
|
| if not voices:
|
| return "No voices available for this country."
|
| return "\n".join(voices)
|
|
|
| def check_internet_connection():
|
| """Check if internet connection is available"""
|
| try:
|
| import socket
|
| socket.create_connection(("8.8.8.8", 53), timeout=3)
|
| return True
|
| except OSError:
|
| return False
|
|
|
| def chunk_text(text, max_length=4000):
|
| """Split text into chunks to avoid rate limits"""
|
| if len(text) <= max_length:
|
| return [text]
|
|
|
| chunks = []
|
| words = text.split()
|
| current_chunk = []
|
| current_length = 0
|
|
|
| for word in words:
|
| if current_length + len(word) + 1 <= max_length:
|
| current_chunk.append(word)
|
| current_length += len(word) + 1
|
| else:
|
| if current_chunk:
|
| chunks.append(" ".join(current_chunk))
|
| current_chunk = [word]
|
| current_length = len(word)
|
|
|
| if current_chunk:
|
| chunks.append(" ".join(current_chunk))
|
|
|
| return chunks
|
|
|
| def try_groq_tts(api_key, text, voice):
|
| """Try Groq TTS with chunking and retry logic"""
|
| try:
|
| if not check_internet_connection():
|
| return None, "❌ No internet connection available for Groq TTS"
|
|
|
| client = Groq(api_key=api_key)
|
|
|
|
|
| chunks = chunk_text(text, 3500)
|
|
|
| if len(chunks) == 1:
|
|
|
| response = client.audio.speech.create(
|
| model="playai-tts",
|
| voice=voice,
|
| input=text,
|
| response_format="wav"
|
| )
|
|
|
| with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as temp_file:
|
| response.write_to_file(temp_file.name)
|
| return temp_file.name, "✅ Speech generated successfully with Groq PlayAI!"
|
| else:
|
|
|
| return None, f"⚠️ Text too long for single request ({len(text)} chars). Try shorter text or use Edge TTS for longer content."
|
|
|
| except Exception as e:
|
| error_msg = str(e)
|
| if "rate_limit_exceeded" in error_msg:
|
| return None, "🔄 Groq rate limit reached. Switching to alternative providers..."
|
| elif "429" in error_msg:
|
| return None, "🔄 Groq rate limit reached. Switching to alternative providers..."
|
| else:
|
| return None, f"❌ Groq error: {error_msg}"
|
|
|
| def try_openai_tts(api_key, text, voice):
|
| """Try OpenAI TTS as fallback"""
|
| try:
|
| if not check_internet_connection():
|
| return None, "❌ No internet connection available for OpenAI TTS"
|
|
|
| import openai
|
| client = openai.OpenAI(api_key=api_key)
|
|
|
| response = client.audio.speech.create(
|
| model="tts-1",
|
| voice=voice,
|
| input=text[:4096]
|
| )
|
|
|
| with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as temp_file:
|
| response.stream_to_file(temp_file.name)
|
| return temp_file.name, "✅ Speech generated successfully with OpenAI TTS!"
|
|
|
| except ImportError:
|
| return None, "❌ OpenAI library not installed. Install with: pip install openai"
|
| except Exception as e:
|
| return None, f"❌ OpenAI error: {str(e)}"
|
|
|
| def try_edge_tts(text, voice="en-US-JennyNeural"):
|
| """Try Microsoft Edge TTS as free fallback"""
|
| try:
|
| if not check_internet_connection():
|
| return None, "❌ No internet connection available for Edge TTS"
|
|
|
| import edge_tts
|
| import asyncio
|
|
|
| async def generate_edge_speech():
|
| communicate = edge_tts.Communicate(text, voice)
|
| with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as temp_file:
|
| async for chunk in communicate.stream():
|
| if chunk["type"] == "audio":
|
| temp_file.write(chunk["data"])
|
| return temp_file.name
|
|
|
|
|
| try:
|
| loop = asyncio.get_event_loop()
|
| except RuntimeError:
|
| loop = asyncio.new_event_loop()
|
| asyncio.set_event_loop(loop)
|
|
|
| audio_file = loop.run_until_complete(generate_edge_speech())
|
|
|
| return audio_file, "✅ Speech generated successfully with Microsoft Edge TTS (Free & High Quality)!"
|
|
|
| except ImportError:
|
| return None, "❌ Edge TTS not installed. Install with: pip install edge-tts"
|
| except Exception as e:
|
| return None, f"❌ Edge TTS error: {str(e)}"
|
|
|
| def try_pyttsx3_fallback(text):
|
| """Ultimate fallback using pyttsx3 (offline)"""
|
| try:
|
| import pyttsx3
|
|
|
|
|
| engine = pyttsx3.init()
|
|
|
|
|
| voices = engine.getProperty('voices')
|
| if voices:
|
|
|
| english_voice = None
|
| for voice in voices:
|
| voice_id = voice.id.lower()
|
| voice_name = voice.name.lower() if hasattr(voice, 'name') else ""
|
|
|
|
|
| if any(keyword in voice_id or keyword in voice_name
|
| for keyword in ['english', 'en-us', 'en_us', 'zira', 'hazel', 'eva']):
|
| english_voice = voice.id
|
| if any(female_keyword in voice_name
|
| for female_keyword in ['zira', 'hazel', 'eva', 'female']):
|
| break
|
|
|
| if english_voice:
|
| engine.setProperty('voice', english_voice)
|
|
|
|
|
| engine.setProperty('rate', 180)
|
| engine.setProperty('volume', 0.9)
|
|
|
|
|
| with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as temp_file:
|
| temp_path = temp_file.name
|
|
|
|
|
| limited_text = text[:2000]
|
|
|
|
|
| engine.save_to_file(limited_text, temp_path)
|
| engine.runAndWait()
|
|
|
|
|
| if os.path.exists(temp_path) and os.path.getsize(temp_path) > 0:
|
| return temp_path, "✅ Speech generated with offline TTS! (No internet required)"
|
| else:
|
|
|
| return try_alternative_offline_tts(limited_text)
|
|
|
| except ImportError:
|
| return None, "❌ pyttsx3 not installed. Install with: pip install pyttsx3"
|
| except Exception as e:
|
|
|
| return try_alternative_offline_tts(text[:2000])
|
|
|
| def try_alternative_offline_tts(text):
|
| """Alternative offline TTS using system commands"""
|
| try:
|
| system = platform.system().lower()
|
|
|
| with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as temp_file:
|
| temp_path = temp_file.name
|
|
|
| if system == "windows":
|
|
|
| try:
|
| import win32com.client
|
| speaker = win32com.client.Dispatch("SAPI.SpVoice")
|
|
|
|
|
| file_stream = win32com.client.Dispatch("SAPI.SpFileStream")
|
| file_stream.Open(temp_path, 3)
|
| speaker.AudioOutputStream = file_stream
|
| speaker.Speak(text)
|
| file_stream.Close()
|
|
|
| if os.path.exists(temp_path) and os.path.getsize(temp_path) > 0:
|
| return temp_path, "✅ Speech generated with Windows SAPI TTS (Offline)!"
|
| except ImportError:
|
| pass
|
|
|
| elif system == "darwin":
|
|
|
| import subprocess
|
| try:
|
| subprocess.run(['say', '-o', temp_path, '--data-format=LEF32@22050', text],
|
| check=True, timeout=30)
|
| if os.path.exists(temp_path) and os.path.getsize(temp_path) > 0:
|
| return temp_path, "✅ Speech generated with macOS TTS (Offline)!"
|
| except (subprocess.CalledProcessError, subprocess.TimeoutExpired, FileNotFoundError):
|
| pass
|
|
|
| elif system == "linux":
|
|
|
| import subprocess
|
| try:
|
|
|
| subprocess.run(['espeak', '-w', temp_path, text],
|
| check=True, timeout=30)
|
| if os.path.exists(temp_path) and os.path.getsize(temp_path) > 0:
|
| return temp_path, "✅ Speech generated with espeak TTS (Offline)!"
|
| except (subprocess.CalledProcessError, subprocess.TimeoutExpired, FileNotFoundError):
|
| try:
|
|
|
| subprocess.run(['text2wave', '-o', temp_path],
|
| input=text, text=True, check=True, timeout=30)
|
| if os.path.exists(temp_path) and os.path.getsize(temp_path) > 0:
|
| return temp_path, "✅ Speech generated with Festival TTS (Offline)!"
|
| except (subprocess.CalledProcessError, subprocess.TimeoutExpired, FileNotFoundError):
|
| pass
|
|
|
| return None, f"❌ No offline TTS available for {system}. Install: pip install pyttsx3"
|
|
|
| except Exception as e:
|
| return None, f"❌ Alternative offline TTS error: {str(e)}"
|
|
|
|
|
| def generate_speech(groq_api_key, openai_api_key, text, voice_provider, voice):
|
| if not text:
|
| return None, "⚠️ Please enter some text to generate speech."
|
|
|
|
|
| if voice_provider != "Edge TTS (Free)" and len(text) > 10000:
|
| return None, "🚫 Text input exceeds 10,000 character limit for this provider. Try Edge TTS for unlimited text length."
|
|
|
|
|
| has_internet = check_internet_connection()
|
| internet_status = "🌐 Internet: Connected" if has_internet else "📴 Internet: Offline"
|
|
|
|
|
| status_msg = f"🔄 Generating speech...\n{internet_status}\n"
|
|
|
|
|
| if not has_internet and voice_provider in ["Groq (PlayAI)", "OpenAI TTS", "Edge TTS (Free)"]:
|
| status_msg += "⚠️ No internet connection. Using offline TTS...\n"
|
| audio_file, message = try_pyttsx3_fallback(text)
|
| if audio_file:
|
| return audio_file, status_msg + message
|
| else:
|
| return None, status_msg + message
|
|
|
|
|
| if voice_provider == "Groq (PlayAI)" and groq_api_key and has_internet:
|
| status_msg += "🎯 Using Groq PlayAI...\n"
|
| audio_file, message = try_groq_tts(groq_api_key, text, voice)
|
| if audio_file:
|
| return audio_file, message
|
| else:
|
| status_msg += f"❌ Groq failed: {message}\n"
|
|
|
|
|
| if openai_api_key and voice_provider in ["OpenAI TTS", "Auto (Try All)"] and has_internet:
|
| status_msg += "🔄 Trying OpenAI TTS...\n"
|
| openai_voice = voice if voice in openai_voices else "alloy"
|
| audio_file, message = try_openai_tts(openai_api_key, text, openai_voice)
|
| if audio_file:
|
| return audio_file, message
|
| else:
|
| status_msg += f"❌ OpenAI failed: {message}\n"
|
|
|
|
|
| if voice_provider in ["Edge TTS (Free)", "Auto (Try All)"] and (has_internet or not groq_api_key):
|
| if has_internet:
|
| status_msg += "🔄 Using Edge TTS (Free & High Quality)...\n"
|
| edge_voice = voice if voice in edge_voices else "en-US-JennyNeural"
|
| audio_file, message = try_edge_tts(text, edge_voice)
|
| if audio_file:
|
| return audio_file, message
|
| else:
|
| status_msg += f"❌ Edge TTS failed: {message}\n"
|
| else:
|
| status_msg += "❌ Edge TTS requires internet connection\n"
|
|
|
|
|
| status_msg += "🔄 Using offline TTS (works without internet)...\n"
|
| audio_file, message = try_pyttsx3_fallback(text)
|
| if audio_file:
|
| return audio_file, status_msg + message
|
| else:
|
| status_msg += f"❌ Offline TTS failed: {message}\n"
|
|
|
| return None, status_msg + "❌ All TTS providers failed. Please check your setup or try shorter text."
|
|
|
| def update_voice_options(provider):
|
| """Update voice dropdown based on selected provider"""
|
| if provider == "Groq (PlayAI)":
|
| return gr.Dropdown(choices=groq_voices, value="Fritz-PlayAI", visible=True)
|
| elif provider == "OpenAI TTS":
|
| return gr.Dropdown(choices=openai_voices, value="alloy", visible=True)
|
| elif provider == "Edge TTS (Free)":
|
| return gr.Dropdown(choices=edge_voices, value="en-US-JennyNeural", visible=True)
|
| elif provider == "Offline TTS":
|
| return gr.Dropdown(choices=["Default System Voice"], value="Default System Voice", visible=True)
|
| else:
|
| return gr.Dropdown(choices=groq_voices, value="Fritz-PlayAI", visible=True, label="🎭 Voice (Auto mode will try best match)")
|
|
|
|
|
| custom_css = """
|
| @import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap');
|
| * {
|
| box-sizing: border-box;
|
| }
|
| :root {
|
| --primary-gradient: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
|
| --secondary-gradient: linear-gradient(135deg, #f093fb 0%, #f5576c 100%);
|
| --accent-gradient: linear-gradient(135deg, #4facfe 0%, #00f2fe 100%);
|
| --dark-bg: linear-gradient(135deg, #0c0c0c 0%, #1a1a2e 50%, #16213e 100%);
|
| --glass-bg: rgba(255, 255, 255, 0.08);
|
| --glass-border: rgba(255, 255, 255, 0.15);
|
| --text-primary: #ffffff;
|
| --text-secondary: rgba(255, 255, 255, 0.7);
|
| --shadow-primary: 0 8px 32px rgba(0, 0, 0, 0.4);
|
| --shadow-hover: 0 12px 48px rgba(0, 0, 0, 0.6);
|
| --border-radius: 16px;
|
| }
|
|
|
| body, .gradio-container {
|
| background: var(--dark-bg) !important;
|
| font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif !important;
|
| color: var(--text-primary) !important;
|
| overflow-x: hidden;
|
| }
|
|
|
| .gradio-container {
|
| max-width: 1400px !important;
|
| margin: 40px auto !important;
|
| padding: 0 20px !important;
|
| min-height: 100vh;
|
| }
|
|
|
| .gradio-container > div {
|
| background: var(--glass-bg) !important;
|
| backdrop-filter: blur(20px) !important;
|
| border: 1px solid var(--glass-border) !important;
|
| border-radius: var(--border-radius) !important;
|
| padding: 40px !important;
|
| box-shadow: var(--shadow-primary) !important;
|
| position: relative;
|
| overflow: hidden;
|
| }
|
|
|
| h1 {
|
| text-align: center !important;
|
| font-size: clamp(2.5rem, 5vw, 4rem) !important;
|
| font-weight: 700 !important;
|
| background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
|
| -webkit-background-clip: text !important;
|
| -webkit-text-fill-color: transparent !important;
|
| background-clip: text !important;
|
| margin: 0 0 50px 0 !important;
|
| animation: glow 3s ease-in-out infinite alternate;
|
| }
|
|
|
| @keyframes glow {
|
| 0% { filter: drop-shadow(0 0 20px rgba(102, 126, 234, 0.3)); }
|
| 100% { filter: drop-shadow(0 0 30px rgba(118, 75, 162, 0.5)); }
|
| }
|
|
|
| #generate-btn {
|
| background: linear-gradient(135deg, #00f2fe 0%, #4facfe 100%) !important;
|
| border: 2px solid #4facfe !important;
|
| color: #ffffff !important;
|
| font-weight: bold !important;
|
| box-shadow: 0 0 12px rgba(0, 242, 254, 0.5) !important;
|
| transition: all 0.3s ease !important;
|
| margin-top: 8.5px !important;
|
| }
|
|
|
| #generate-btn:hover {
|
| background: linear-gradient(135deg, #4facfe 0%, #00f2fe 100%) !important;
|
| transform: scale(1.03) !important;
|
| box-shadow: 0 0 18px rgba(0, 242, 254, 0.7) !important;
|
| }
|
|
|
| .gr-textbox, .gr-dropdown {
|
| background: var(--glass-bg) !important;
|
| border: 2px solid transparent !important;
|
| border-radius: 12px !important;
|
| position: relative;
|
| transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1) !important;
|
| backdrop-filter: blur(10px) !important;
|
| }
|
|
|
| .gr-textbox textarea, .gr-textbox input, .gr-dropdown select {
|
| background: transparent !important;
|
| color: var(--text-primary) !important;
|
| border: none !important;
|
| font-size: 16px !important;
|
| font-weight: 400 !important;
|
| padding: 16px !important;
|
| }
|
|
|
| .gr-input-label, .gr-output-label {
|
| color: var(--text-primary) !important;
|
| font-weight: 600 !important;
|
| font-size: 14px !important;
|
| text-transform: uppercase;
|
| letter-spacing: 0.5px;
|
| margin-bottom: 12px !important;
|
| background: var(--accent-gradient);
|
| -webkit-background-clip: text;
|
| -webkit-text-fill-color: transparent;
|
| background-clip: text;
|
| }
|
|
|
| .gr-button {
|
| background: var(--primary-gradient) !important;
|
| border: none !important;
|
| color: white !important;
|
| font-weight: 600 !important;
|
| font-size: 16px !important;
|
| padding: 16px 32px !important;
|
| border-radius: 12px !important;
|
| transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1) !important;
|
| text-transform: uppercase;
|
| letter-spacing: 0.5px;
|
| box-shadow: 0 4px 20px rgba(102, 126, 234, 0.3) !important;
|
| margin-top: 20px !important;
|
| }
|
|
|
| .gr-button:hover {
|
| transform: translateY(-2px) !important;
|
| box-shadow: var(--shadow-hover) !important;
|
| filter: brightness(1.1);
|
| }
|
|
|
| .gr-audio {
|
| background: var(--glass-bg) !important;
|
| border: 1px solid var(--glass-border) !important;
|
| border-radius: 12px !important;
|
| padding: 20px !important;
|
| backdrop-filter: blur(10px) !important;
|
| transition: all 0.3s ease !important;
|
| }
|
|
|
| .info-box {
|
| background: rgba(0, 242, 254, 0.1) !important;
|
| border: 1px solid rgba(0, 242, 254, 0.3) !important;
|
| border-radius: 12px !important;
|
| padding: 20px !important;
|
| margin: 20px 0 !important;
|
| backdrop-filter: blur(10px) !important;
|
| }
|
|
|
| .info-box,
|
| .info-box * {
|
| color: white !important;
|
| }
|
|
|
| .warning-box,
|
| .warning-box * {
|
| color: white !important;
|
| }
|
|
|
| .no-api-box {
|
| background: rgba(46, 204, 113, 0.1) !important;
|
| border: 1px solid rgba(46, 204, 113, 0.3) !important;
|
| border-radius: 12px !important;
|
| padding: 20px !important;
|
| margin: 20px 0 !important;
|
| backdrop-filter: blur(10px) !important;
|
| }
|
|
|
| .no-api-box,
|
| .no-api-box * {
|
| color: white !important;
|
| }
|
|
|
| .warning-box {
|
| background: rgba(255, 193, 7, 0.1) !important;
|
| border: 1px solid rgba(255, 193, 7, 0.3) !important;
|
| border-radius: 12px !important;
|
| padding: 15px !important;
|
| margin: 15px 0 !important;
|
| backdrop-filter: blur(10px) !important;
|
| }
|
|
|
| .offline-box {
|
| background: rgba(255, 87, 34, 0.1) !important;
|
| border: 1px solid rgba(255, 87, 34, 0.3) !important;
|
| border-radius: 12px !important;
|
| padding: 20px !important;
|
| margin: 20px 0 !important;
|
| backdrop-filter: blur(10px) !important;
|
| }
|
|
|
| .offline-box,
|
| .offline-box * {
|
| color: white !important;
|
| }
|
|
|
| #voice-selector-header h3{
|
| text-align: center !important;
|
| font-size: 1.5rem !important;
|
| font-weight: 600 !important;
|
| margin-bottom: 20px !important;
|
| color: white !important;
|
| }
|
|
|
| """
|
|
|
| custom_html = """
|
| <div style="text-align: center; margin-bottom: 20px;">
|
| <div style="font-size: 3rem;">🎙️</div>
|
| <h1>Advanced Multi-Provider TTS Studio</h1>
|
| <p style="color: rgba(255, 255, 255, 0.7); font-size: 18px; margin: 0; font-weight: 300;">
|
| Transform your text into natural-sounding speech with multiple AI-powered voice providers
|
| </p>
|
|
|
| <div class="offline-box">
|
| <h3>📴 No Internet? No Problem!</h3>
|
| <p><strong>Select "Offline TTS" to use system TTS without any internet connection!</strong></p>
|
| <p>✅ Works completely offline but in local pc not in HF space env • ✅ No API keys needed • ✅ Always available as fallback • 🚫 10,000 char limit</p>
|
| </div>
|
|
|
| <div class="no-api-box">
|
| <h3>🆓 No API Key? Multiple Free Options!</h3>
|
| <p><strong>Select "Edge TTS (Free)" for online high-quality TTS with no character limit or "Offline TTS" for no internet!</strong></p>
|
| <p>✅ Edge TTS: High quality voices with internet, unlimited text and various language support • ✅ Offline TTS: Basic quality, works anywhere, 10,000 char limit</p>
|
| </div>
|
|
|
| <div class="info-box">
|
| <p><strong>🔄 Multiple Providers Available:</strong> Groq PlayAI, OpenAI TTS, Microsoft Edge TTS (Free), Offline TTS</p>
|
| <p><strong>🛡️ Smart Fallback System:</strong> If one provider fails, automatically tries the next available</p>
|
| <p><strong>💡 Recommended:</strong> Use "Auto (Try All)" for maximum reliability or specific providers based on your needs</p>
|
| <p><strong>📏 Text Limits:</strong> Edge TTS (Unlimited), Groq/OpenAI/Offline (10,000 chars)</p>
|
| </div>
|
| </div>
|
| """
|
|
|
|
|
| with gr.Blocks() as demo:
|
| gr.HTML(custom_html)
|
|
|
|
|
| gr.HTML("""
|
| <div class="warning-box">
|
| <p><strong>⚠️ Important:</strong> If you don't have API keys or internet, you have multiple options:</p>
|
| <ul>
|
| <li><strong>With Internet:</strong> Select "Edge TTS (Free)" - High quality, no API key needed, unlimited text</li>
|
| <li><strong>Without Internet:</strong> Select "Offline TTS" - Basic quality, works completely offline, 10,000 char limit</li>
|
| <li><strong>Best Experience:</strong> Use "Auto (Try All)" to automatically use the best available option</li>
|
| </ul>
|
| </div>
|
| """)
|
|
|
|
|
| with gr.Row():
|
| with gr.Column():
|
| groq_api_key = gr.Textbox(
|
| label="🔐 Groq API Key (Optional)",
|
| placeholder="Optional: Paste your Groq API key here for PlayAI voices...",
|
| type="password",
|
| lines=1
|
| )
|
| with gr.Column():
|
| openai_api_key = gr.Textbox(
|
| label="🔐 OpenAI API Key (Optional)",
|
| placeholder="Optional: OpenAI API key for premium TTS voices...",
|
| type="password",
|
| lines=1
|
| )
|
|
|
| with gr.Row():
|
| with gr.Column(scale=3):
|
| text_input = gr.Textbox(
|
| label="📝 Enter Your Text",
|
| placeholder="Type or paste your text here... (Edge TTS: Unlimited, Others: Max 10,000 characters)",
|
| lines=8,
|
| max_lines=12
|
| )
|
|
|
| with gr.Row():
|
| provider_dropdown = gr.Dropdown(
|
| choices=["Auto (Try All)", "Edge TTS (Free)", "Offline TTS", "Groq (PlayAI)", "OpenAI TTS"],
|
| label="🔧 TTS Provider",
|
| value="Auto (Try All)",
|
| scale=1
|
| )
|
| voice_dropdown = gr.Dropdown(
|
| choices=groq_voices,
|
| label="🎭 Select Voice",
|
| value="Fritz-PlayAI",
|
| scale=2
|
| )
|
| generate_button = gr.Button("🚀 Generate Speech", scale=1, elem_id="generate-btn")
|
|
|
| with gr.Column(scale=2):
|
| audio_output = gr.Audio(
|
| label="🔊 Generated Audio",
|
| type="filepath"
|
| )
|
| status_output = gr.Textbox(
|
| label="📊 Status & Progress",
|
| placeholder="Ready to generate speech... 'Auto' mode will use the best available provider!",
|
| interactive=False,
|
| lines=6
|
| )
|
|
|
| gr.Markdown("### Voice Selector by Country", elem_id="voice-selector-header")
|
| country_dropdown = gr.Dropdown(
|
| choices=sorted(voices_by_country.keys()),
|
| label="Select Country (Applicable for Edge TTS voices)",
|
| )
|
| voice_output = gr.Textbox(label="Available Voices", lines=10)
|
| country_dropdown.change(fn=display_voices, inputs=country_dropdown, outputs=voice_output)
|
|
|
|
|
| generate_button.click(
|
| fn=generate_speech,
|
| inputs=[groq_api_key, openai_api_key, text_input, provider_dropdown, voice_dropdown],
|
| outputs=[audio_output, status_output]
|
| )
|
|
|
|
|
| provider_dropdown.change(
|
| fn=update_voice_options,
|
| inputs=[provider_dropdown],
|
| outputs=[voice_dropdown]
|
| )
|
|
|
|
|
| def update_status_text(text):
|
| char_count = len(text) if text else 0
|
| base_msg = f"Characters: {char_count}"
|
|
|
| if char_count == 0:
|
| return base_msg + " • Ready to generate speech!"
|
| elif char_count > 10000:
|
| return base_msg + " • Use 'Edge TTS' for unlimited text length! Other providers limited to 10,000 chars."
|
| elif char_count > 3000:
|
| return base_msg + " • For long texts, 'Edge TTS' or 'Offline TTS' work best!"
|
| else:
|
| return base_msg + " • All providers available for this text length!"
|
|
|
| text_input.change(
|
| fn=update_status_text,
|
| inputs=[text_input],
|
| outputs=[status_output]
|
| )
|
|
|
|
|
| gr.HTML("""
|
| <div class="info-box" style="margin-top: 30px;">
|
| <h3>🎯 Usage Options:</h3>
|
| <div style="margin: 15px 0;">
|
| <p><strong>📴 Offline Option (Always Works):</strong></p>
|
| <ul>
|
| <li>Select <strong>"Offline TTS"</strong> - No internet or API key needed!</li>
|
| <li>Uses your system's built-in TTS engine</li>
|
| <li>Works on Windows, macOS, and Linux</li>
|
| <li>Basic quality but always reliable</li>
|
| <li>🚫 Limited to 10,000 characters</li>
|
| </ul>
|
| </div>
|
|
|
| <div style="margin: 15px 0;">
|
| <p><strong>🆓 Free Online Option (High Quality):</strong></p>
|
| <ul>
|
| <li>Select <strong>"Edge TTS (Free)"</strong> - No API key needed!</li>
|
| <li>High-quality Microsoft voices</li>
|
| <li>✅ Unlimited text length</li>
|
| <li>Multiple English voice options</li>
|
| <li>Requires internet connection</li>
|
| </ul>
|
| </div>
|
|
|
| <div style="margin: 15px 0;">
|
| <p><strong>🔑 Premium Options (Optional):</strong></p>
|
| <ul>
|
| <li><strong>Groq PlayAI:</strong> Get free API key at <a href="https://console.groq.com" target="_blank">console.groq.com</a> (10,000 char limit but usually works in short length text)</li>
|
| <li><strong>OpenAI TTS:</strong> Get API key at <a href="https://platform.openai.com" target="_blank">platform.openai.com</a> (10,000 char limit but usually works in short length text)</li>
|
| </ul>
|
| </div>
|
|
|
| <div style="margin: 15px 0;">
|
| <p><strong>🚀 Smart Auto Mode:</strong></p>
|
| <ul>
|
| <li>Select <strong>"Auto (Try All)"</strong> for maximum reliability</li>
|
| <li>Automatically detects internet connection</li>
|
| <li>Uses premium APIs if available, falls back to free options</li>
|
| <li>Always tries offline TTS as final fallback</li>
|
| </ul>
|
| </div>
|
|
|
| <div style="margin: 15px 0;">
|
| <p><strong>💡 Tips:</strong></p>
|
| <ul>
|
| <li>No internet? Use <strong>"Offline TTS"</strong> - it always works! (10,000 char limit but usually works in short length text)</li>
|
| <li>Want quality without API keys? Use <strong>"Edge TTS (Free)"</strong> - unlimited text</li>
|
| <li>For maximum reliability, use <strong>"Auto (Try All)"</strong></li>
|
| <li>App automatically detects your connection status</li>
|
| </ul>
|
| </div>
|
| <p style="margin-top: 15px;">Enjoy generating high-quality speech with ease! 🎤</p>
|
| </div>
|
| """)
|
|
|
|
|
| if __name__ == "__main__":
|
| demo.launch(share=True, css=custom_css, theme="ocean") |
