Update app.py

app.py

@@ -10,10 +10,8 @@ import edge_tts
 import gradio as gr
 from pydub import AudioSegment
 
-# Configuración de Logs
 logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
 
-# CONSTANTES DE ARCHIVOS
 INTRO_VIDEO = "introvideo.mp4"
 OUTRO_VIDEO = "outrovideo.mp4"
 MUSIC_BG = "musicafondo.mp3"
@@ -21,14 +19,12 @@ FX_SOUND = "fxsound.mp3"
 WATERMARK = "watermark.png"
 EJEMPLO_VIDEO = "ejemplo.mp4"
 
-# Validar existencia de archivos
 for file in [INTRO_VIDEO, OUTRO_VIDEO, MUSIC_BG, FX_SOUND, WATERMARK, EJEMPLO_VIDEO]:
     if not os.path.exists(file):
         logging.error(f"Falta archivo necesario: {file}")
         raise FileNotFoundError(f"Falta: {file}")
 
 def eliminar_archivo_tiempo(ruta, delay=1800):
-    """Elimina archivos después de 30 minutos"""
     def eliminar():
         try:
             if os.path.exists(ruta):
@@ -39,7 +35,6 @@ def eliminar_archivo_tiempo(ruta, delay=1800):
     Timer(delay, eliminar).start()
 
 def validar_texto(texto):
-    """Validación de texto para TTS"""
     texto_limpio = texto.strip()
     if len(texto_limpio) < 3:
         raise gr.Error("⚠️ El texto debe tener al menos 3 caracteres")
@@ -47,28 +42,23 @@ def validar_texto(texto):
         raise gr.Error("⚠️ Caracteres no permitidos detectados")
 
 async def procesar_audio(texto, voz, duracion_total, duracion_intro):
-    """Genera TTS y mezcla con música (versión corregida)"""
     temp_files = []
     try:
-        # Validar texto
         validar_texto(texto)
-        
-        # 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)
             temp_files.append(tmp.name)
             
-            # Verificar audio válido
             if tts_audio.duration < 0.5:
                 raise RuntimeError(f"Audio TTS inválido ({tts_audio.duration}s)")
 
-        # Procesar música de fondo
         bg_music = AudioSegment.from_mp3(MUSIC_BG)
-        needed_ms = int(duracion_total * 1000)  # <-- Convertir a entero
+        needed_ms = int(duracion_total * 1000)
         repeticiones = needed_ms // len(bg_music) + 1
-        bg_music = bg_music * repeticiones  # <-- Ahora es multiplicación entera
+        bg_music = bg_music * repeticiones
         bg_music = bg_music[:needed_ms].fade_out(5000)
         
         with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp:
@@ -76,18 +66,18 @@ async def procesar_audio(texto, voz, duracion_total, duracion_intro):
             bg_audio = AudioFileClip(tmp.name).volumex(0.15)
             temp_files.append(tmp.name)
 
-        # Combinar audios
         audio_final = CompositeAudioClip([
-            bg_audio,
+            bg_audio.set_duration(duracion_total),
             tts_audio.volumex(0.85).set_start(duracion_intro)
+                      .set_duration(duracion_total - 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)
@@ -95,7 +85,6 @@ async def procesar_audio(texto, voz, duracion_total, duracion_intro):
                 logging.warning(f"Error limpiando {file}: {e}")
 
 def agregar_transiciones(clips):
-    """Transiciones profesionales cada 40s"""
     try:
         fx_audio = AudioFileClip(FX_SOUND).subclip(0, 0.5)
         watermark = (ImageClip(WATERMARK)
@@ -107,7 +96,6 @@ def agregar_transiciones(clips):
         for i, clip in enumerate(clips):
             clip_watermarked = CompositeVideoClip([clip, watermark])
             
-            # Agregar transición cada 40s
             if i > 0 and i % 40 == 0:
                 transicion = CompositeVideoClip([watermark.set_duration(0.5)]).set_audio(fx_audio)
                 clips_finales.append(transicion)
@@ -121,45 +109,41 @@ def agregar_transiciones(clips):
 
 async def procesar_video(video_input, texto_tts, voz_seleccionada, metodo_corte, duracion_corte):
     try:
-        # Cargar video con audio original
         video_original = VideoFileClip(video_input)
         audio_original = video_original.audio.volumex(0.7) if video_original.audio else None
         
-        # 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:
-            clips = [video_original.subclip(i, i+40) for i in range(0, math.ceil(video_original.duration), 40)]
+            clips = [video_original.subclip(i, min(i+40, video_original.duration)) 
+                    for i in range(0, math.ceil(video_original.duration), 40)]
         
-        # Procesar transiciones
         video_editado = agregar_transiciones(clips)
-        
-        # Combinar con intro/outro
         intro = VideoFileClip(INTRO_VIDEO)
         outro = VideoFileClip(OUTRO_VIDEO)
         video_final = concatenate_videoclips([intro, video_editado, outro])
         
-        # Calcular duraciones
         duracion_total = video_final.duration
-        audio_tts_bg = await procesar_audio(texto_tts, voz_seleccionada, duracion_total, intro.duration)
+        duracion_intro = intro.duration
+        
+        audio_tts_bg = await procesar_audio(texto_tts, voz_seleccionada, duracion_total, duracion_intro)
         
-        # Combinar todos los audios
         audios = [audio_tts_bg]
         if audio_original:
             audios.append(audio_original.set_duration(video_final.duration))
         
-        audio_final = CompositeAudioClip(audios)
+        audio_final = CompositeAudioClip(audios).set_duration(video_final.duration)
         
-        # Renderizar video final
         with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmp:
             video_final.set_audio(audio_final).write_videofile(
                 tmp.name,
                 codec="libx264",
                 audio_codec="aac",
                 fps=24,
-                threads=4
+                threads=4,
+                verbose=False
             )
             eliminar_archivo_tiempo(tmp.name)
             return tmp.name
@@ -167,7 +151,6 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada, metodo_corte,
         logging.error(f" fallo general: {str(e)}")
         raise
 
-# Interfaz Gradio
 with gr.Blocks() as demo:
     gr.Markdown("# Editor de Video con IA")
     
@@ -197,25 +180,16 @@ with gr.Blocks() as demo:
             label="Segundos por corte (manual)"
         )
 
-    # Ejemplos en footer
     with gr.Accordion("Ejemplos de Uso", open=False):
         gr.Examples(
-            examples=[
-                [EJEMPLO_VIDEO, "¡Hola! Esto es una prueba. Suscríbete al canal y activa la campanita."],
-            ],
+            examples=[[EJEMPLO_VIDEO, "¡Hola! Esto es una prueba. Suscríbete al canal y activa la campanita."]],
             inputs=[video_input, texto_tts],
             label="Ejemplos"
         )
 
     procesar_btn.click(
         procesar_video,
-        inputs=[
-            video_input,
-            texto_tts,
-            voz_seleccionada,
-            metodo_corte,
-            duracion_corte
-        ],
+        inputs=[video_input, texto_tts, voz_seleccionada, metodo_corte, duracion_corte],
         outputs=video_output
     )