Update app.py

app.py

@@ -31,6 +31,77 @@ logger.info("="*80)
 logger.info("INICIO DE EJECUCIÓN - GENERADOR DE VIDEOS")
 logger.info("="*80)
 
+# Diccionario de voces TTS disponibles organizadas por idioma
+VOCES_DISPONIBLES = {
+    "Español (España)": {
+        "es-ES-JuanNeural": "Juan (España) - Masculino",
+        "es-ES-ElviraNeural": "Elvira (España) - Femenino",
+        "es-ES-AlvaroNeural": "Álvaro (España) - Masculino",
+        "es-ES-AbrilNeural": "Abril (España) - Femenino",
+        "es-ES-ArnauNeural": "Arnau (España) - Masculino",
+        "es-ES-DarioNeural": "Darío (España) - Masculino",
+        "es-ES-EliasNeural": "Elías (España) - Masculino",
+        "es-ES-EstrellaNeural": "Estrella (España) - Femenino",
+        "es-ES-IreneNeural": "Irene (España) - Femenino",
+        "es-ES-LaiaNeural": "Laia (España) - Femenino",
+        "es-ES-LiaNeural": "Lía (España) - Femenino",
+        "es-ES-NilNeural": "Nil (España) - Masculino",
+        "es-ES-SaulNeural": "Saúl (España) - Masculino",
+        "es-ES-TeoNeural": "Teo (España) - Masculino",
+        "es-ES-TrianaNeural": "Triana (España) - Femenino",
+        "es-ES-VeraNeural": "Vera (España) - Femenino"
+    },
+    "Español (México)": {
+        "es-MX-JorgeNeural": "Jorge (México) - Masculino",
+        "es-MX-DaliaNeural": "Dalia (México) - Femenino",
+        "es-MX-BeatrizNeural": "Beatriz (México) - Femenino",
+        "es-MX-CandelaNeural": "Candela (México) - Femenino",
+        "es-MX-CarlotaNeural": "Carlota (México) - Femenino",
+        "es-MX-CecilioNeural": "Cecilio (México) - Masculino",
+        "es-MX-GerardoNeural": "Gerardo (México) - Masculino",
+        "es-MX-LarissaNeural": "Larissa (México) - Femenino",
+        "es-MX-LibertoNeural": "Liberto (México) - Masculino",
+        "es-MX-LucianoNeural": "Luciano (México) - Masculino",
+        "es-MX-MarinaNeural": "Marina (México) - Femenino",
+        "es-MX-NuriaNeural": "Nuria (México) - Femenino",
+        "es-MX-PelayoNeural": "Pelayo (México) - Masculino",
+        "es-MX-RenataNeural": "Renata (México) - Femenino",
+        "es-MX-YagoNeural": "Yago (México) - Masculino"
+    },
+    "Español (Argentina)": {
+        "es-AR-TomasNeural": "Tomás (Argentina) - Masculino",
+        "es-AR-ElenaNeural": "Elena (Argentina) - Femenino"
+    },
+    "Español (Colombia)": {
+        "es-CO-GonzaloNeural": "Gonzalo (Colombia) - Masculino",
+        "es-CO-SalomeNeural": "Salomé (Colombia) - Femenino"
+    },
+    "Español (Chile)": {
+        "es-CL-LorenzoNeural": "Lorenzo (Chile) - Masculino",
+        "es-CL-CatalinaNeural": "Catalina (Chile) - Femenino"
+    },
+    "Español (Perú)": {
+        "es-PE-AlexNeural": "Alex (Perú) - Masculino",
+        "es-PE-CamilaNeural": "Camila (Perú) - Femenino"
+    },
+    "Español (Venezuela)": {
+        "es-VE-PaolaNeural": "Paola (Venezuela) - Femenino",
+        "es-VE-SebastianNeural": "Sebastián (Venezuela) - Masculino"
+    },
+    "Español (Estados Unidos)": {
+        "es-US-AlonsoNeural": "Alonso (Estados Unidos) - Masculino",
+        "es-US-PalomaNeural": "Paloma (Estados Unidos) - Femenino"
+    }
+}
+
+# Función para obtener lista plana de voces para el dropdown
+def get_voice_choices():
+    choices = []
+    for region, voices in VOCES_DISPONIBLES.items():
+        for voice_id, voice_name in voices.items():
+            choices.append((voice_name, voice_id))
+    return choices
+
 # Clave API de Pexels
 PEXELS_API_KEY = os.environ.get("PEXELS_API_KEY")
 if not PEXELS_API_KEY:
@@ -61,36 +132,6 @@ except Exception as e:
     logger.error(f"FALLA al cargar KeyBERT: {str(e)}", exc_info=True)
     kw_model = None
 
-# --- Obtener voces de Edge TTS al inicio ---
-async def get_available_voices():
-    logger.info("Obteniendo lista de voces disponibles de Edge TTS...")
-    try:
-        voices = await edge_tts.VoicesManager.create()
-        # Retornar solo voces en español si prefieres, o dejar todas
-        es_voices = [voice.Name for voice in voices.Voices if voice.Locale.startswith('es-')]
-        if es_voices:
-            logger.info(f"Encontradas {len(es_voices)} voces en español.")
-            return es_voices
-        else:
-            # Si no hay español, retornar todas las voces
-            all_voices = [voice.Name for voice in voices.Voices]
-            logger.warning(f"No se encontraron voces en español. Retornando {len(all_voices)} voces en todos los idiomas.")
-            return all_voices if all_voices else ["en-US-AriaNeural"] # Fallback si no hay ninguna
-
-    except Exception as e:
-        logger.error(f"Error obteniendo voces de Edge TTS: {str(e)}", exc_info=True)
-        # Retornar una lista de voces por defecto si falla la API de Edge TTS
-        logger.warning("No se pudieron obtener voces de Edge TTS. Usando lista de voces por defecto.")
-        return ["es-ES-JuanNeural", "es-ES-ElviraNeural", "en-US-AriaNeural"]
-
-# Obtener las voces al inicio del script (esto puede tardar un poco)
-logger.info("Inicializando lista de voces disponibles...")
-AVAILABLE_VOICES = asyncio.run(get_available_voices())
-# Establecer una voz por defecto inicial
-DEFAULT_VOICE = "es-ES-JuanNeural" if "es-ES-JuanNeural" in AVAILABLE_VOICES else (AVAILABLE_VOICES[0] if AVAILABLE_VOICES else "en-US-AriaNeural")
-logger.info(f"Voz por defecto seleccionada: {DEFAULT_VOICE}")
-
-
 def buscar_videos_pexels(query, api_key, per_page=5):
     if not api_key:
         logger.warning("No se puede buscar en Pexels: API Key no configurada.")
@@ -159,63 +200,53 @@ def generate_script(prompt, max_length=150):
         text = tokenizer.decode(outputs[0], skip_special_tokens=True)
 
         cleaned_text = text.strip()
-        # Limpieza mejorada de la frase de instrucción
         try:
-            # Buscar el índice de inicio del prompt original dentro del texto generado
-            prompt_in_output_idx = text.lower().find(prompt.lower())
-            if prompt_in_output_idx != -1:
-                # Tomar todo el texto DESPUÉS del prompt original
-                cleaned_text = text[prompt_in_output_idx + len(prompt):].strip()
-                logger.debug("Texto limpiado tomando parte después del prompt original.")
+            instruction_end_idx = text.find(instruction_phrase)
+            if instruction_end_idx != -1:
+                cleaned_text = text[instruction_end_idx + len(instruction_phrase):].strip()
+                logger.debug("Instrucción inicial encontrada y eliminada del guión generado.")
             else:
-                 # Fallback si el prompt original no está exacto en la salida: buscar la frase de instrucción base
                  instruction_start_idx = text.find(instruction_phrase_start)
                  if instruction_start_idx != -1:
-                      # Tomar texto después de la frase base (puede incluir el prompt)
-                      cleaned_text = text[instruction_start_idx + len(instruction_phrase_start):].strip()
-                      logger.debug("Texto limpiado tomando parte después de la frase de instrucción base.")
-                 else:
-                      # Si ni la frase de instrucción ni el prompt se encuentran, usar el texto original
-                      logger.warning("No se pudo identificar el inicio del guión generado. Usando texto generado completo.")
-                      cleaned_text = text.strip() # Limpieza básica
-
+                     prompt_in_output_idx = text.find(prompt, instruction_start_idx)
+                     if prompt_in_output_idx != -1:
+                          cleaned_text = text[prompt_in_output_idx + len(prompt):].strip()
+                          logger.debug("Instrucción base y prompt encontrados y eliminados del guión generado.")
+                     else:
+                          cleaned_text = text[instruction_start_idx + len(instruction_phrase_start):].strip()
+                          logger.debug("Instrucción base encontrada, eliminada del guión generado (sin prompt detectado).")
 
         except Exception as e:
              logger.warning(f"Error durante la limpieza heurística del guión de IA: {e}. Usando texto generado sin limpieza adicional.")
-             cleaned_text = re.sub(r'<[^>]+>', '', text).strip() # Limpieza básica como fallback
+             cleaned_text = re.sub(r'<[^>]+>', '', text).strip()
 
-        # Asegurarse de que el texto resultante no sea solo la instrucción o vacío
-        if not cleaned_text or len(cleaned_text) < 10: # Umbral de longitud mínima
-             logger.warning("El guión generado parece muy corto o vacío después de la limpieza heurística. Usando el texto generado original (sin limpieza adicional).")
-             cleaned_text = re.sub(r'<[^>]+>', '', text).strip() # Fallback al texto original limpio
+        if not cleaned_text or len(cleaned_text) < 10:
+             logger.warning("El guión generado parece muy corto o vacío después de la limpieza. Usando el texto generado original (sin limpieza heurística).")
+             cleaned_text = re.sub(r'<[^>]+>', '', text).strip()
 
-        # Limpieza final de caracteres especiales y espacios sobrantes
         cleaned_text = re.sub(r'<[^>]+>', '', cleaned_text).strip()
-        cleaned_text = cleaned_text.lstrip(':').strip() # Quitar posibles ':' al inicio
-        cleaned_text = cleaned_text.lstrip('.').strip() # Quitar posibles '.' al inicio
-
+        cleaned_text = cleaned_text.lstrip(':').strip()
+        cleaned_text = cleaned_text.lstrip('.').strip()
 
-        # Intentar obtener al menos una oración completa si es posible para un inicio más limpio
         sentences = cleaned_text.split('.')
         if sentences and sentences[0].strip():
             final_text = sentences[0].strip() + '.'
-            # Añadir la segunda oración si existe y es razonable
-            if len(sentences) > 1 and sentences[1].strip() and len(final_text.split()) < max_length * 0.7: # Usar un 70% de max_length como umbral
+            if len(sentences) > 1 and sentences[1].strip() and len(final_text.split()) < max_length * 0.7:
                  final_text += " " + sentences[1].strip() + "."
-                 final_text = final_text.replace("..", ".") # Limpiar doble punto
+                 final_text = final_text.replace("..", ".")
 
             logger.info(f"Guion generado final (Truncado a 100 chars): '{final_text[:100]}...'")
             return final_text.strip()
 
         logger.info(f"Guion generado final (sin oraciones completas detectadas - Truncado): '{cleaned_text[:100]}...'")
-        return cleaned_text.strip() # Si no se puede formar una oración, devolver el texto limpio tal cual
+        return cleaned_text.strip()
 
     except Exception as e:
         logger.error(f"Error generando guion con GPT-2 (fuera del bloque de limpieza): {str(e)}", exc_info=True)
         logger.warning("Usando prompt original como guion debido al error de generación.")
         return prompt.strip()
 
-# Función TTS ahora recibe la voz a usar
+# Función TTS con voz especificada
 async def text_to_speech(text, output_path, voice):
     logger.info(f"Convirtiendo texto a voz | Caracteres: {len(text)} | Voz: {voice} | Salida: {output_path}")
     if not text or not text.strip():
@@ -386,12 +417,11 @@ def extract_visual_keywords_from_script(script_text):
     logger.info(f"Palabras clave finales: {top_keywords}")
     return top_keywords
 
-# crear_video ahora recibe la voz seleccionada
 def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
     logger.info("="*80)
     logger.info(f"INICIANDO CREACIÓN DE VIDEO | Tipo: {prompt_type}")
     logger.debug(f"Input: '{input_text[:100]}...'")
-    logger.info(f"Voz seleccionada para TTS: {selected_voice}")
+    logger.info(f"Voz seleccionada: {selected_voice}")
 
     start_time = datetime.now()
     temp_dir_intermediate = None
@@ -422,39 +452,35 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
         logger.info(f"Directorio temporal intermedio creado: {temp_dir_intermediate}")
         temp_intermediate_files = []
 
-        # 2. Generar audio de voz usando la voz seleccionada, con reintentos si falla
+        # 2. Generar audio de voz con reintentos y voz de respaldo
         logger.info("Generando audio de voz...")
         voz_path = os.path.join(temp_dir_intermediate, "voz.mp3")
 
-        tts_voices_to_try = [selected_voice] # Intentar primero la voz seleccionada
-        # Añadir voces de respaldo si no están ya en la lista y son diferentes a la seleccionada
-        if "es-ES-JuanNeural" not in tts_voices_to_try: tts_voices_to_try.append("es-ES-JuanNeural")
-        if "es-ES-ElviraNeural" not in tts_voices_to_try: tts_voices_to_try.append("es-ES-ElviraNeural")
-        # Si la lista de voces disponibles es fiable, podrías usar un subconjunto ordenado para reintentos más amplios
-        # Ejemplo: for voice_id in [selected_voice] + sorted([v for v in AVAILABLE_VOICES if v.startswith('es-') and v != selected_voice]) + sorted([v for v in AVAILABLE_VOICES if not v.startswith('es-') and v != selected_voice]):
-
-
+        primary_voice = selected_voice
+        fallback_voice = "es-ES-ElviraNeural" if selected_voice != "es-ES-ElviraNeural" else "es-ES-JuanNeural"
         tts_success = False
-        tried_voices = set() # Usar un set para rastrear voces intentadas de forma eficiente
-
-        for current_voice in tts_voices_to_try:
-            if current_voice in tried_voices: continue # Evitar intentar la misma voz dos veces
-            tried_voices.add(current_voice)
+        retries = 3
 
-            logger.info(f"Intentando TTS con voz: {current_voice}...")
+        for attempt in range(retries):
+            current_voice = primary_voice if attempt == 0 else fallback_voice
+            if attempt > 0: logger.warning(f"Reintentando TTS ({attempt+1}/{retries})...")
+            logger.info(f"Intentando TTS con voz: {current_voice}")
             try:
                 tts_success = asyncio.run(text_to_speech(guion, voz_path, voice=current_voice))
                 if tts_success:
-                    logger.info(f"TTS exitoso con voz '{current_voice}'.")
-                    break # Salir del bucle de reintentos si tiene éxito
+                    logger.info(f"TTS exitoso en intento {attempt + 1} con voz {current_voice}.")
+                    break
             except Exception as e:
-                 logger.warning(f"Fallo al generar TTS con voz '{current_voice}': {str(e)}", exc_info=True)
-                 pass # Continuar al siguiente intento
+                 pass
+
+            if not tts_success and attempt == 0 and primary_voice != fallback_voice:
+                 logger.warning(f"Fallo con voz {primary_voice}, intentando voz de respaldo: {fallback_voice}")
+            elif not tts_success and attempt < retries - 1:
+                 logger.warning(f"Fallo con voz {current_voice}, reintentando...")
 
 
-        # Verificar si el archivo fue creado después de todos los intentos
         if not tts_success or not os.path.exists(voz_path) or os.path.getsize(voz_path) <= 100:
-             logger.error("Fallo en la generación de voz después de todos los intentos. Archivo de audio no creado o es muy pequeño.")
+             logger.error(f"Fallo en la generación de voz después de {retries} intentos. Archivo de audio no creado o es muy pequeño.")
              raise ValueError("Error generando voz a partir del guion (fallo de TTS).")
 
         temp_intermediate_files.append(voz_path)
@@ -504,6 +530,19 @@ def crear_video(prompt_type, input_text, selected_voice, musica_file=None):
             except Exception as e:
                 logger.warning(f"Error buscando videos para '{keyword}': {str(e)}")
 
+        if len(videos_data) < total_desired_videos / 2:
+            logger.warning(f"Pocos videos encontrados ({len(videos_data)}). Intentando con palabras clave genéricas.")
+            generic_keywords = ["nature", "city", "background", "abstract"]
+            for keyword in generic_keywords:
+                 if len(videos_data) >= total_desired_videos: break
+                 try:
+                    videos = buscar_videos_pexels(keyword, PEXELS_API_KEY, per_page=2)
+                    if videos:
+                        videos_data.extend(videos)
+                        logger.info(f"Encontrados {len(videos)} videos para '{keyword}' (genérico). Total data: {len {len(videos)} videos para '{keyword}'. Total data: {len(videos_data)}")
+            except Exception as e:
+                logger.warning(f"Error buscando videos para '{keyword}': {str(e)}")
+
         if len(videos_data) < total_desired_videos / 2:
             logger.warning(f"Pocos videos encontrados ({len(videos_data)}). Intentando con palabras clave genéricas.")
             generic_keywords = ["nature", "city", "background", "abstract"]