Update app.py

app.py

@@ -1,12 +1,9 @@
+import os
 import math
 import tempfile
 import logging
 from PIL import Image
-import os
-
-# PATCH PARA PILLOW 10+ (crítico)
-Image.ANTIALIAS = Image.Resampling.LANCZOS  # Parche antes de importar MoviePy
-
+from pydub import AudioSegment
 from moviepy.editor import (
     VideoFileClip, AudioFileClip, ImageClip,
     concatenate_videoclips, CompositeVideoClip, CompositeAudioClip
@@ -14,85 +11,84 @@ from moviepy.editor import (
 import edge_tts
 import gradio as gr
 import asyncio
-from pydub import AudioSegment
 
-# Configuración de Logs
-logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+# PATCH PARA PILLOW 10+
+Image.ANTIALIAS = Image.Resampling.LANCZOS
 
-# CONSTANTES DE ARCHIVOS
+# CONFIGURACIÓN
 INTRO_VIDEO = "introvideo.mp4"
 OUTRO_VIDEO = "outrovideo.mp4"
 MUSIC_BG = "musicafondo.mp3"
 FX_SOUND = "fxsound.mp3"
 WATERMARK = "watermark.png"
 
-# Validar existencia de archivos obligatorios
+# Validar archivos
 for file in [INTRO_VIDEO, OUTRO_VIDEO, MUSIC_BG, FX_SOUND, WATERMARK]:
     if not os.path.exists(file):
-        logging.error(f"Falta archivo necesario: {file}")
-        raise FileNotFoundError(f"Falta archivo necesario: {file}")
+        raise FileNotFoundError(f"Falta: {file}")
+
+async def procesar_audio(texto, voz):
+    try:
+        communicate = edge_tts.Communicate(texto, voz)
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp:
+            await communicate.save(tmp.name)
+            return tmp.name  # Retorna solo el TTS sin procesar
+    except Exception as e:
+        logging.error(f"TTS fallido: {e}")
+        raise
+
+def mezclar_audio(tts_path, duracion_total):
+    try:
+        # Cargar TTS
+        tts = AudioSegment.from_mp3(tts_path)
+        
+        # Preparar música de fondo en loop
+        bg = AudioSegment.from_mp3(MUSIC_BG)
+        bg = bg - 10  # 10% volumen (ajusta según necesidad)
+        
+        # Calcular repeticiones necesarias
+        repeticiones = math.ceil(duracion_total * 1000 / len(bg))
+        bg_loop = bg * repeticiones
+        
+        # Recortar a duración exacta
+        bg_final = bg_loop[:duracion_total*1000].fade_out(3000)
+        
+        # Combinar TTS y música
+        audio_final = bg_final.overlay(tts, position=0)
+        
+        # Guardar temporal
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp:
+            audio_final.export(tmp.name, format="mp3")
+            return tmp.name
+    except Exception as e:
+        logging.error(f"Error mezclando audio: {e}")
+        raise
 
 def cortar_video(video_path, metodo="inteligente", duracion=10):
     try:
-        logging.info("Iniciando corte de video...")
         video = VideoFileClip(video_path)
         if metodo == "manual":
-            clips = [video.subclip(i * duracion, (i + 1) * duracion)
-                     for i in range(math.ceil(video.duration / duracion))]
-            logging.info(f"Video cortado en {len(clips)} clips manuales.")
-            return clips
+            return [
+                video.subclip(i*duracion, (i+1)*duracion)
+                for i in range(math.ceil(video.duration/duracion))
+            ]
         
-        # Simulación básica de cortes automáticos (puedes mejorar esto con VAD)
+        # Simulación de cortes automáticos
         clips = []
         ultimo_corte = 0
         for i in range(1, math.ceil(video.duration)):
             if i % 5 == 0:  # Simulación de pausas
                 clips.append(video.subclip(ultimo_corte, i))
                 ultimo_corte = i
-        logging.info(f"Video cortado en {len(clips)} clips automáticos.")
-        return clips
-    except Exception as e:
-        logging.error(f"Error al cortar video: {e}")
-        raise
-
-async def procesar_audio(texto, voz, clips_duracion):
-    try:
-        logging.info("Generando TTS y mezclando audio...")
-        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)
-        
-        # Ajustar TTS a duración de clips
-        if tts_audio.duration < clips_duracion:
-            tts_audio = tts_audio.loop(duration=clips_duracion)
-        else:
-            tts_audio = tts_audio.subclip(0, clips_duracion)
-        
-        # Mezclar con música de fondo
-        bg_music = AudioSegment.from_mp3(MUSIC_BG)
-        if len(bg_music) < clips_duracion * 1000:
-            bg_music = bg_music * math.ceil(clips_duracion * 1000 / len(bg_music))
-        bg_music = bg_music[:clips_duracion * 1000].fade_out(3000)
-        
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp:
-            bg_music.export(tmp.name, format="mp3")
-            bg_audio = AudioFileClip(tmp.name).volumex(0.10)
-        
-        logging.info("Audio procesado correctamente.")
-        return CompositeAudioClip([bg_audio, tts_audio.volumex(0.9)])
+        return clips if clips else [video]
     except Exception as e:
-        logging.error(f"Error al procesar audio: {e}")
+        logging.error(f"Error cortando video: {e}")
         raise
 
 def agregar_transiciones(clips):
     try:
-        logging.info("Agregando transiciones...")
         fx_audio = AudioFileClip(FX_SOUND).set_duration(2.5)
-        transicion = ImageClip(WATERMARK).set_duration(2.5)
-        
-        # Redimensionar la transición (ahora compatible)
-        transicion = transicion.resize(height=clips[0].h).set_position(("center", 0.1))
+        transicion = ImageClip(WATERMARK).set_duration(2.5).resize(height=clips[0].h).set_position(("center", 0.1))
         
         clips_con_fx = []
         for i, clip in enumerate(clips):
@@ -100,15 +96,15 @@ def agregar_transiciones(clips):
             clip_watermarked = CompositeVideoClip([clip, transicion])
             clips_con_fx.append(clip_watermarked)
             
-            if i < len(clips) - 1:
+            # Agregar transición entre clips
+            if i < len(clips)-1:
                 clips_con_fx.append(
                     CompositeVideoClip([transicion.set_position("center")])
                     .set_audio(fx_audio)
                 )
-        logging.info("Transiciones agregadas correctamente.")
         return concatenate_videoclips(clips_con_fx)
     except Exception as e:
-        logging.error(f"Error al agregar transiciones: {e}")
+        logging.error(f"Error en transiciones: {e}")
         raise
 
 async def procesar_video(
@@ -120,8 +116,7 @@ async def procesar_video(
 ):
     temp_files = []
     try:
-        logging.info("Iniciando procesamiento de video...")
-        # Procesar video principal
+        # Procesar video
         clips = cortar_video(video_input, metodo_corte, duracion_corte)
         video_editado = agregar_transiciones(clips)
         
@@ -130,29 +125,34 @@ async def procesar_video(
         outro = VideoFileClip(OUTRO_VIDEO)
         video_final = concatenate_videoclips([intro, video_editado, outro])
         
-        # Procesar audio
-        audio_final = await procesar_audio(texto_tts, voz_seleccionada, video_editado.duration)
+        # Generar TTS
+        tts_path = await procesar_audio(texto_tts, voz_seleccionada)
+        duracion_tts = AudioFileClip(tts_path).duration
+        
+        # Calcular duración total (intro + contenido + outro)
+        duracion_total = intro.duration + video_editado.duration + outro.duration
         
-        # Combinar y renderizar
-        video_final = video_final.set_audio(audio_final)
+        # Mezclar audio
+        audio_mix_path = mezclar_audio(tts_path, duracion_total)
         
+        # Combinar video y audio
+        video_final = video_final.set_audio(AudioFileClip(audio_mix_path))
+        
+        # Guardar resultado final
         with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as tmp:
             video_final.write_videofile(tmp.name, codec="libx264", fps=24)
-            logging.info("Video procesado y guardado temporalmente.")
             temp_files.append(tmp.name)
             return tmp.name
     except Exception as e:
-        logging.error(f"Error durante el procesamiento: {e}")
+        logging.error(f"Error general: {e}")
         raise
     finally:
-        # Eliminar archivos temporales
-        for file in temp_files:
+        # Eliminar temporales
+        for file in temp_files + [tts_path, audio_mix_path]:
             try:
-                if os.path.exists(file):
-                    os.remove(file)
-                    logging.info(f"Archivo temporal eliminado: {file}")
-            except Exception as e:
-                logging.warning(f"No se pudo eliminar el archivo temporal {file}: {e}")
+                os.remove(file)
+            except:
+                pass
 
 # Interfaz Gradio
 with gr.Blocks() as demo:
@@ -162,35 +162,25 @@ with gr.Blocks() as demo:
         video_input = gr.Video(label="Subir video")
         texto_tts = gr.Textbox(label="Texto para TTS", lines=3)
         voz_seleccionada = gr.Dropdown(
-            label="Seleccionar voz",
+            label="Voz",
             choices=["es-ES-AlvaroNeural", "es-MX-BeatrizNeural"]
         )
-        procesar_btn = gr.Button("Generar Video")
+        procesar_btn = gr.Button("Generar")
         video_output = gr.Video(label="Resultado")
     
     with gr.Tab("Ajustes"):
         metodo_corte = gr.Radio(
             ["inteligente", "manual"],
-            label="Método de cortes",
+            label="Método de corte",
             value="inteligente"
         )
-        duracion_corte = gr.Slider(
-            1, 60, 10,
-            label="Segundos por corte (solo manual)"
-        )
+        duracion_corte = gr.Slider(1, 60, 10, label="Duración por corte (solo manual)")
 
     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
     )
 
 if __name__ == "__main__":
-    logging.info("Iniciando aplicación Gradio...")
     demo.queue().launch()