Update app.py

app.py

@@ -38,21 +38,50 @@ def eliminar_archivo_tiempo(ruta, delay=1800):
             logging.error(f"Error al eliminar {ruta}: {e}")
     Timer(delay, eliminar).start()
 
+def validar_texto(texto):
+    """Valida el texto de entrada para TTS"""
+    texto_limpio = texto.strip()
+    if len(texto_limpio) < 3:
+        raise gr.Error("El texto debe tener al menos 3 caracteres")
+    if any(c in texto_limpio for c in ["|", "\n", "\r"]):
+        raise gr.Error("Caracteres no permitidos en el texto")
+    return texto_limpio
+
 async def procesar_audio(texto, voz, duracion_total, duracion_intro):
-    """Genera TTS y mezcla con música"""
+    """Genera TTS y mezcla con música (versión segura)"""
     temp_files = []
     try:
+        # Validaciones críticas
+        if not texto.strip():
+            raise ValueError("Texto vacío")
+        if voz not in ["es-ES-AlvaroNeural", "es-MX-BeatrizNeural"]:
+            raise ValueError(f"Voz no soportada: {voz}")
+        
         # Generar TTS
         communicate = edge_tts.Communicate(texto, voz)
         with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp:
             await communicate.save(tmp.name)
             tts_audio = AudioFileClip(tmp.name)
+            
+            # Verificar audio válido
+            if tts_audio.duration < 0.5:
+                raise RuntimeError(f"Audio TTS inválido ({tts_audio.duration}s)")
+            
             temp_files.append(tmp.name)
         
-        # Preparar música de fondo en loop
-        bg_music = AudioSegment.from_mp3(MUSIC_BG)
-        bg_music = bg_music * (duracion_total // len(bg_music) + 1)
-        bg_music = bg_music[:duracion_total * 1000].fade_out(5000)
+        # Procesar música de fondo
+        try:
+            bg_music = AudioSegment.from_mp3(MUSIC_BG)
+        except Exception as e:
+            raise ValueError(f"Error en música de fondo: {str(e)}")
+        
+        if len(bg_music) == 0:
+            raise ValueError("Música de fondo vacía")
+        
+        # Ajustar duración
+        needed_ms = duracion_total * 1000
+        bg_music = bg_music * (needed_ms // len(bg_music) + 1)
+        bg_music = bg_music[:needed_ms].fade_out(5000)
         
         with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp:
             bg_music.export(tmp.name, format="mp3")
@@ -64,31 +93,35 @@ async def procesar_audio(texto, voz, duracion_total, duracion_intro):
             bg_audio,
             tts_audio.volumex(0.85).set_start(duracion_intro)
         ])
+        
         return audio_final
+    except Exception as e:
+        logging.error(f" fallo en audio: {str(e)}")
+        raise
     finally:
+        # Limpiar archivos
         for file in temp_files:
             try:
                 os.remove(file)
-            except: pass
+            except Exception as e:
+                logging.warning(f"Error limpiando {file}: {e}")
 
 def agregar_transiciones(clips):
-    """Transiciones suaves cada 40 segundos"""
+    """Transiciones profesionales cada 40s"""
     try:
-        transicion_fx = AudioFileClip(FX_SOUND).subclip(0, 0.5)
+        fx_audio = AudioFileClip(FX_SOUND).subclip(0, 0.5)
         watermark = (ImageClip(WATERMARK)
                     .set_duration(0.5)
                     .resize(height=50)
-                    .margin(right=10, bottom=10, opacity=0)
                     .set_pos(("right", "bottom")))
         
         clips_finales = []
         for i, clip in enumerate(clips):
-            # Añadir watermark al clip principal
             clip_watermarked = CompositeVideoClip([clip, watermark])
             
-            # Agregar transición cada 40 segundos
+            # Agregar transición cada 40s
             if i > 0 and i % 40 == 0:
-                transicion = CompositeVideoClip([watermark.set_duration(0.5)]).set_audio(transicion_fx)
+                transicion = CompositeVideoClip([watermark.set_duration(0.5)]).set_audio(fx_audio)
                 clips_finales.append(transicion)
             
             clips_finales.append(clip_watermarked)
@@ -100,17 +133,16 @@ def agregar_transiciones(clips):
 
 async def procesar_video(video_input, texto_tts, voz_seleccionada, metodo_corte, duracion_corte):
     try:
-        # Cargar video original con su audio
+        # Cargar video con audio original
         video_original = VideoFileClip(video_input)
-        audio_original = video_original.audio.volumex(0.7)  # Conservar audio original al 70%
+        audio_original = video_original.audio.volumex(0.7) if video_original.audio else None
         
-        # Cortar video según método
+        # Cortar video
         clips = []
         if metodo_corte == "manual":
             for i in range(math.ceil(video_original.duration / duracion_corte)):
                 clips.append(video_original.subclip(i*duracion_corte, (i+1)*duracion_corte))
         else:
-            # Cortes automáticos cada 40 segundos para transiciones
             clips = [video_original.subclip(i, i+40) for i in range(0, math.ceil(video_original.duration), 40)]
         
         # Procesar transiciones
@@ -121,15 +153,16 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada, metodo_corte,
         outro = VideoFileClip(OUTRO_VIDEO)
         video_final = concatenate_videoclips([intro, video_editado, outro])
         
-        # Procesar audio completo
+        # Calcular duraciones
         duracion_total = video_final.duration
         audio_tts_bg = await procesar_audio(texto_tts, voz_seleccionada, duracion_total, intro.duration)
         
-        # Combinar TODOS los audios
-        audio_final = CompositeAudioClip([
-            audio_original.set_duration(video_final.duration),
-            audio_tts_bg
-        ])
+        # Combinar todos los audios
+        audios = [audio_tts_bg]
+        if audio_original:
+            audios.append(audio_original.set_duration(video_final.duration))
+        
+        audio_final = CompositeAudioClip(audios)
         
         # Renderizar video final
         with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmp:
@@ -143,7 +176,7 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada, metodo_corte,
             eliminar_archivo_tiempo(tmp.name)
             return tmp.name
     except Exception as e:
-        logging.error(f"Error procesando video: {e}")
+        logging.error(f" fallo general: {str(e)}")
         raise
 
 # Interfaz Gradio
@@ -178,7 +211,13 @@ with gr.Blocks() as demo:
 
     procesar_btn.click(
         procesar_video,
-        inputs=[video_input, texto_tts, voz_seleccionada, metodo_corte, duracion_corte],
+        inputs=[
+            video_input,
+            texto_tts.validate(validar_texto),  # <-- Validación activada
+            voz_seleccionada,
+            metodo_corte,
+            duracion_corte
+        ],
         outputs=video_output
     )