Update app.py

app.py

@@ -5,6 +5,7 @@ import tempfile
 import requests
 from datetime import datetime
 import edge_tts
+from gtts import gTTS
 import gradio as gr
 import torch
 from transformers import GPT2Tokenizer, GPT2LMHeadModel
@@ -104,15 +105,15 @@ def get_voice_choices():
 
 # Obtener las voces al inicio del script
 AVAILABLE_VOICES = get_voice_choices()
-DEFAULT_VOICE_ID = "es-ES-JuanNeural"
+DEFAULT_VOICE_ID = "es-MX-DaliaNeural"  # Cambiado a una voz más estable
 DEFAULT_VOICE_NAME = DEFAULT_VOICE_ID
 for text, voice_id in AVAILABLE_VOICES:
     if voice_id == DEFAULT_VOICE_ID:
         DEFAULT_VOICE_NAME = text
         break
 if DEFAULT_VOICE_ID not in [v[1] for v in AVAILABLE_VOICES]:
-    DEFAULT_VOICE_ID = AVAILABLE_VOICES[0][1] if AVAILABLE_VOICES else "en-US-AriaNeural"
-    DEFAULT_VOICE_NAME = AVAILABLE_VOICES[0][0] if AVAILABLE_VOICES else "Aria (United States) - Female"
+    DEFAULT_VOICE_ID = AVAILABLE_VOICES[0][1] if AVAILABLE_VOICES else "es-MX-DaliaNeural"
+    DEFAULT_VOICE_NAME = AVAILABLE_VOICES[0][0] if AVAILABLE_VOICES else "Dalia (México) - Femenino"
 logger.info(f"Voz por defecto seleccionada (ID): {DEFAULT_VOICE_ID}")
 
 # Clave API de Pexels
@@ -243,12 +244,22 @@ async def text_to_speech(text, output_path, voice):
         communicate = edge_tts.Communicate(text, voice)
         await communicate.save(output_path)
         if os.path.exists(output_path) and os.path.getsize(output_path) > 100:
-            logger.info(f"Audio guardado exitosamente en: {output_path}")
+            logger.info(f"Audio guardado exitosamente con edge_tts en: {output_path}")
             return True
-        logger.error(f"TTS guardó un archivo pequeño o vacío en: {output_path}")
+        logger.warning(f"edge_tts falló, intentando gTTS...")
+    except Exception as e:
+        logger.error(f"Error en edge_tts con voz '{voice}': {str(e)}")
+
+    try:
+        tts = gTTS(text=text, lang='es')
+        tts.save(output_path)
+        if os.path.exists(output_path) and os.path.getsize(output_path) > 100:
+            logger.info(f"Audio guardado exitosamente con gTTS en: {output_path}")
+            return True
+        logger.error(f"gTTS falló o archivo vacío en: {output_path}")
         return False
     except Exception as e:
-        logger.error(f"Error en TTS con voz '{voice}': {str(e)}")
+        logger.error(f"Error en gTTS: {str(e)}")
         return False
 
 def download_video_file(url, temp_dir):
@@ -364,22 +375,41 @@ async def crear_video_async(prompt_type, input_text, selected_voice, musica_file
 
         # 2. Generar audio de voz
         voz_path = os.path.join(temp_dir_intermediate, "voz.mp3")
-        tts_voices_to_try = [selected_voice, "es-MX-DaliaNeural"]  # Cambié fallback a una voz más estable
+        tts_voices_to_try = [selected_voice, "es-MX-DaliaNeural"]
         tts_success = False
+        max_chunk_length = 1000
+        text_chunks = [guion[i:i + max_chunk_length] for i in range(0, len(guion), max_chunk_length)]
+        logger.info(f"Texto dividido en {len(text_chunks)} fragmentos para TTS")
 
         for current_voice in tts_voices_to_try:
             logger.info(f"Intentando TTS con voz: {current_voice}")
             try:
-                tts_success = await text_to_speech(guion, voz_path, current_voice)
-                if tts_success and os.path.exists(voz_path) and os.path.getsize(voz_path) > 100:
-                    logger.info(f"TTS exitoso con voz: {current_voice}")
-                    break
-                logger.warning(f"TTS falló o archivo inválido con voz: {current_voice}")
+                temp_audio_files = []
+                for i, chunk in enumerate(text_chunks):
+                    temp_path = os.path.join(temp_dir_intermediate, f"voz_chunk_{i}.mp3")
+                    tts_success = await text_to_speech(chunk, temp_path, current_voice)
+                    if tts_success and os.path.exists(temp_path) and os.path.getsize(temp_path) > 100:
+                        temp_audio_files.append(temp_path)
+                    else:
+                        logger.warning(f"TTS falló para fragmento {i} con voz: {current_voice}")
+                        break
+                if len(temp_audio_files) == len(text_chunks):
+                    audio_clips = [AudioFileClip(f) for f in temp_audio_files]
+                    concatenated_audio = concatenate_audioclips(audio_clips)
+                    concatenated_audio.write_audiofile(voz_path, codec='mp3')
+                    concatenated_audio.close()
+                    for clip in audio_clips:
+                        clip.close()
+                    tts_success = os.path.exists(voz_path) and os.path.getsize(voz_path) > 100
+                    temp_intermediate_files.extend(temp_audio_files)
+                    if tts_success:
+                        logger.info(f"TTS exitoso con voz: {current_voice}")
+                        break
             except Exception as e:
                 logger.error(f"Error en TTS con voz '{current_voice}': {str(e)}")
 
         if not tts_success or not os.path.exists(voz_path) or os.path.getsize(voz_path) <= 100:
-            raise ValueError(f"Error generando voz. Intentos con {tts_voices_to_try} fallaron.")
+            raise ValueError(f"Error generando voz. Intentos con {tts_voices_to_try} y gTTS fallaron.")
 
         temp_intermediate_files.append(voz_path)
         audio_tts_original = AudioFileClip(voz_path)
@@ -477,7 +507,7 @@ async def crear_video_async(prompt_type, input_text, selected_voice, musica_file
         if musica_file:
             try:
                 music_path = os.path.join(temp_dir_intermediate, "musica_bg.mp3")
-                shutil.copyfile(musica_file, music_path)
+                shutil.copyfile(musica_file.name if hasattr(musica_file, 'name') else musica_file, music_path)
                 temp_intermediate_files.append(music_path)
                 musica_audio_original = AudioFileClip(music_path)
                 if musica_audio_original.duration > 0:
@@ -497,7 +527,9 @@ async def crear_video_async(prompt_type, input_text, selected_voice, musica_file
         video_final = video_base.set_audio(final_audio)
         output_filename = f"video_{int(datetime.now().timestamp())}.mp4"
         output_path = os.path.join(temp_dir_intermediate, output_filename)
-        permanent_path = f"/tmp/{output_filename}"
+        persistent_dir = "/data"
+        os.makedirs(persistent_dir, exist_ok=True)
+        persistent_path = os.path.join(persistent_dir, output_filename)
 
         video_final.write_videofile(
             output_path,
@@ -510,11 +542,13 @@ async def crear_video_async(prompt_type, input_text, selected_voice, musica_file
             logger='bar'
         )
 
-        shutil.copy(output_path, permanent_path)
-        logger.info(f"Video guardado en: {permanent_path}")
+        shutil.move(output_path, persistent_path)
+        download_url = f"https://gnosticdev-invideo-basic.hf.space/file={persistent_path}"
+        logger.info(f"Video guardado en: {persistent_path}")
+        logger.info(f"URL de descarga: {download_url}")
         total_time = (datetime.now() - start_time).total_seconds()
         logger.info(f"Video generado en {total_time:.2f}s")
-        return permanent_path
+        return persistent_path, download_url
 
     except ValueError as ve:
         logger.error(f"Error controlado: {str(ve)}")
@@ -554,11 +588,16 @@ async def crear_video_async(prompt_type, input_text, selected_voice, musica_file
             except:
                 pass
         for path in temp_intermediate_files:
-            if os.path.isfile(path) and path != permanent_path:
+            if os.path.isfile(path) and path != persistent_path:
                 try:
                     os.remove(path)
                 except:
                     logger.warning(f"No se pudo eliminar {path}")
+        try:
+            if os.path.exists(temp_dir_intermediate):
+                shutil.rmtree(temp_dir_intermediate)
+        except:
+            logger.warning(f"No se pudo eliminar directorio temporal {temp_dir_intermediate}")
 
 async def run_app_async(prompt_type, prompt_ia, prompt_manual, musica_file, selected_voice):
     logger.info("="*80)
@@ -579,12 +618,12 @@ async def run_app_async(prompt_type, prompt_ia, prompt_manual, musica_file, sele
 
     try:
         logger.info("Iniciando generación de video...")
-        video_path = await crear_video_async(prompt_type, input_text, selected_voice, musica_file)
+        video_path, download_url = await crear_video_async(prompt_type, input_text, selected_voice, musica_file)
         if video_path and os.path.exists(video_path):
             output_video = video_path
             output_file = video_path
-            status_msg = gr.update(value=f"✅ Video generado exitosamente. Descarga disponible en {video_path}")
-            logger.info(f"Retornando video_path: {video_path}")
+            status_msg = gr.update(value=f"✅ Video generado exitosamente. Descarga: {download_url}")
+            logger.info(f"Retornando video_path: {video_path}, URL: {download_url}")
         else:
             status_msg = gr.update(value="❌ Error: Falló la generación del video.")
             logger.error("No se generó video_path válido.")
@@ -658,22 +697,21 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft()) as ap
             )
 
     prompt_type.change(
-        lambda x: (gr.update(visible=x == "Generar Guion con IA"), gr.update(visible=x == "Usar Mi Guion")),
+        fn=lambda x: (gr.update(visible=x == "Generar Guion con IA"), gr.update(visible=x == "Usar Mi Guion")),
         inputs=prompt_type,
         outputs=[ia_guion_column, manual_guion_column]
     )
 
     generate_btn.click(
-        lambda: (None, None, gr.update(value="⏳ Procesando... Esto puede tomar hasta 1 hora.")),
+        fn=lambda: (None, None, gr.update(value="⏳ Procesando... Esto puede tomar hasta 1 hora.")),
         outputs=[video_output, file_output, status_output]
     ).then(
-        run_app,
+        fn=run_app,
         inputs=[prompt_type, prompt_ia, prompt_manual, musica_input, voice_dropdown],
         outputs=[video_output, file_output, status_output],
-        queue=True,
-        _js="() => { setTimeout(() => window.location.reload(), 3600000); }"
+        queue=True
     ).then(
-        lambda video_path, file_output, status_msg: gr.update(visible=file_output.value is not None),
+        fn=lambda video_path, file_output, status_msg: gr.update(visible=file_output.value is not None),
         inputs=[video_output, file_output, status_output],
         outputs=[file_output]
     )
@@ -685,7 +723,7 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft()) as ap
     3. Sube música (opcional).
     4. Selecciona la voz.
     5. Haz clic en "✨ Generar Video".
-    6. Revisa el estado. Si el video se genera, estará disponible en /tmp.
+    6. Revisa el estado. Si el video se genera, estará disponible en /data.
     7. Consulta `video_generator_full.log` para detalles.
     """)