Upload app.py

app.py

@@ -170,41 +170,95 @@ def get_yourvoic_voice_for_language(language, selected_voice):
 # Cache for API-fetched voices
 _yourvoic_voice_cache = {}
 
-def _fetch_yourvoic_voice(yourvoic_lang):
-    """Query YourVoic /v1/voices endpoint to get a valid voice for a language."""
-    if yourvoic_lang in _yourvoic_voice_cache:
-        return _yourvoic_voice_cache[yourvoic_lang]
+def _fetch_yourvoic_voice(yourvoic_lang, model="aura-prime"):
+    """Query YourVoic /v1/voices endpoint to get valid voices for a language + model."""
+    cache_key = f"{yourvoic_lang}:{model}"
+    if cache_key in _yourvoic_voice_cache:
+        return _yourvoic_voice_cache[cache_key]
 
     yv_key = os.environ.get("YOURVOIC_API_KEY", "")
     if not yv_key:
         return None
 
-    try:
-        resp = http_requests.get(
-            f"{YOURVOIC_VOICES_URL}?language={yourvoic_lang}",
-            headers={"X-API-Key": yv_key},
-            timeout=15,
-        )
-        print(f"[YourVoic] Voices API for {yourvoic_lang}: status={resp.status_code}")
-        print(f"[YourVoic] Voices response: {resp.text[:500]}")
-        if resp.status_code == 200:
-            data = resp.json()
-            # Handle different response formats
-            voices = data if isinstance(data, list) else data.get("voices", data.get("data", []))
-            if voices:
-                if isinstance(voices[0], dict):
-                    voice_name = voices[0].get("name", voices[0].get("voice_id", voices[0].get("voice", None)))
-                else:
-                    voice_name = str(voices[0])
-                if voice_name:
-                    print(f"[YourVoic] Found voice for {yourvoic_lang}: {voice_name}")
-                    _yourvoic_voice_cache[yourvoic_lang] = voice_name
-                    return voice_name
-    except Exception as e:
-        print(f"[YourVoic] Voice lookup failed for {yourvoic_lang}: {e}")
+    # Try with model parameter first, then without
+    for url_params in [
+        f"?language={yourvoic_lang}&model={model}",
+        f"?language={yourvoic_lang}",
+    ]:
+        try:
+            resp = http_requests.get(
+                f"{YOURVOIC_VOICES_URL}{url_params}",
+                headers={"X-API-Key": yv_key},
+                timeout=15,
+            )
+            print(f"[YourVoic] Voices API {url_params}: status={resp.status_code}")
+            if resp.status_code == 200:
+                data = resp.json()
+                voices = data if isinstance(data, list) else data.get("voices", data.get("data", []))
+                if voices and isinstance(voices[0], dict):
+                    # Return all voice names for trying
+                    all_names = []
+                    for v in voices[:10]:  # first 10
+                        for field in ["id", "name", "voice_id", "voice"]:
+                            if field in v and v[field]:
+                                all_names.append(str(v[field]))
+                                break
+                    if all_names:
+                        # Deduplicate preserving order
+                        seen = set()
+                        unique = [x for x in all_names if not (x in seen or seen.add(x))]
+                        print(f"[YourVoic] Available voices for {yourvoic_lang}: {unique[:5]}")
+                        _yourvoic_voice_cache[cache_key] = unique
+                        return unique
+        except Exception as e:
+            print(f"[YourVoic] Voice lookup failed for {yourvoic_lang}: {e}")
 
     return None
 
+
+def generate_speech_yourvoic_with_retry(client, text, voice, yv_model, emotion, language, lang_config,
+                                         translate, api_key, chunk_index, output_dir):
+    """Wrapper that tries multiple voice names if the first one fails."""
+    yourvoic_lang = lang_config.get("yourvoic", "en-US")
+
+    # Get list of candidate voices
+    candidates = []
+
+    # 1. Try user-selected voice
+    user_voice = get_voice_name(voice)
+    candidates.append(user_voice)
+
+    # 2. Try hardcoded voices
+    hardcoded = YOURVOIC_VOICE_MAP.get(language, [])
+    candidates.extend(hardcoded)
+
+    # 3. Try API-fetched voices
+    api_voices = _fetch_yourvoic_voice(yourvoic_lang, yv_model)
+    if api_voices:
+        candidates.extend(api_voices)
+
+    # Deduplicate preserving order
+    seen = set()
+    candidates = [x for x in candidates if not (x in seen or seen.add(x))]
+
+    # Try each candidate until one works
+    for i, candidate_voice in enumerate(candidates[:5]):  # try up to 5
+        print(f"[YourVoic] Trying voice '{candidate_voice}' for {language} (attempt {i+1})")
+        wav_path, transcript, error = generate_speech_yourvoic(
+            client, text, candidate_voice, yv_model, emotion, language, lang_config,
+            translate, api_key, chunk_index, output_dir,
+        )
+        if wav_path:
+            # Cache this working voice for future chunks
+            if language not in YOURVOIC_VOICE_MAP or not YOURVOIC_VOICE_MAP.get(language):
+                YOURVOIC_VOICE_MAP[language] = [candidate_voice]
+            return wav_path, transcript, None
+        if error and "Invalid voice name" not in str(error):
+            # Non-voice error (credits, etc) - don't try more voices
+            return None, transcript, error
+
+    return None, text, f"No valid voice found for {language}. Tried: {candidates[:5]}"
+
 YOURVOIC_MODELS = [
     "aura-prime -- Balanced quality and speed (recommended)",
     "aura-lite -- Fast, good for previews",
@@ -483,14 +537,13 @@ def generate_speech_yourvoic(client, text, voice, yv_model, emotion, language, l
         except Exception as e:
             print(f"[YourVoic] Translation failed, using English: {e}")
 
-    # Build request - auto-map voice to language
+    # Build request - voice is passed directly (already resolved by caller)
     yourvoic_lang = lang_config.get("yourvoic", "en-US")
-    valid_voice = get_yourvoic_voice_for_language(language, voice)
-    print(f"[YourVoic] Language: {language}, requested voice: {voice}, using: {valid_voice}")
+    print(f"[YourVoic] Language: {language}, voice: {voice}")
 
     payload = {
         "text": final_text,
-        "voice": valid_voice,
+        "voice": voice,
         "language": yourvoic_lang,
         "model": yv_model,
         "speed": 0.9,
@@ -621,9 +674,9 @@ def generate_audiobook(text_input, file_input, target_language, voice_mode,
             wav_path, transcript, error = None, None, None
 
             if use_yourvoic:
-                yv_voice = get_voice_name(yourvoic_voice_label)
+                yv_voice = yourvoic_voice_label
                 yv_model = get_yourvoic_model(yourvoic_model_label)
-                wav_path, transcript, error = generate_speech_yourvoic(
+                wav_path, transcript, error = generate_speech_yourvoic_with_retry(
                     client, chunk, yv_voice, yv_model, yourvoic_emotion,
                     target_language, lang_config, translate,
                     yv_key, i, tmp_dir,