Update app.py

app.py

@@ -7,20 +7,24 @@ 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"
 EJEMPLO_VIDEO = "ejemplo.mp4"
 
+# Validar existencia de archivos
 for file in [INTRO_VIDEO, OUTRO_VIDEO, MUSIC_BG, EJEMPLO_VIDEO]:
     if not os.path.exists(file):
         logging.error(f"Falta archivo necesario: {file}")
         raise FileNotFoundError(f"Falta: {file}")
 
-SEGMENT_DURATION = 30
-TRANSITION_DURATION = 1.5
+# Configuración de chunks
+SEGMENT_DURATION = 30  # Duración exacta entre transiciones (sin overlap)
+TRANSITION_DURATION = 1.5  # Duración del efecto slide
 
 def eliminar_archivo_tiempo(ruta, delay=1800):
     def eliminar():
@@ -35,6 +39,66 @@ def eliminar_archivo_tiempo(ruta, delay=1800):
 
 async def generar_tts(texto, voz, duracion_total):
     try:
+        # Validar texto
+        if not texto.strip():
+            raise ValueError("El texto para TTS no puede estar vacío.")
+        if len(texto) > 1000:  # Límite aproximado de Edge TTS
+            texto = texto[:1000]  # Truncar texto si es demasiado largo
+        
+        # Validar voz
+        voces_validas = [
+            "es-ES-AlvaroNeural", "es-MX-BeatrizNeural", 
+            "es-ES-ElviraNeural", "es-MX-JavierNeural",
+            "es-AR-ElenaNeural", "es-AR-TomasNeural", 
+            "es-CL-CatalinaNeural", "es-CL-LorenzoNeural", 
+            "es-CO-SofiaNeural", "es-CO-GonzaloNeural", 
+            "es-PE-CamilaNeural", "es-PE-AlexNeural", 
+            "es-VE-MariaNeural", "es-VE-ManuelNeural", 
+            "es-US-AlonsoNeural", "es-US-PalomaNeural", 
+            "es-ES-AbrilNeural", "es-ES-DarioNeural", 
+            "es-ES-HelenaRUS", "es-ES-LauraNeural", 
+            "es-ES-PabloNeural", "es-ES-TriniNeural", 
+            "en-US-AriaNeural", "en-US-GuyNeural", 
+            "en-US-JennyNeural", "en-US-AmberNeural", 
+            "en-US-AnaNeural", "en-US-AshleyNeural", 
+            "en-US-BrandonNeural", "en-US-ChristopherNeural", 
+            "en-US-CoraNeural", "en-US-DavisNeural", 
+            "en-US-ElizabethNeural", "en-US-EricNeural", 
+            "en-US-GinaNeural", "en-US-JacobNeural", 
+            "en-US-JaneNeural", "en-US-JasonNeural", 
+            "en-US-MichelleNeural", "en-US-MonicaNeural", 
+            "en-US-SaraNeural", "en-US-SteffanNeural", 
+            "en-US-TonyNeural", "en-US-YaraNeural", 
+            "fr-FR-AlainNeural", "fr-FR-BrigitteNeural", 
+            "fr-FR-CelesteNeural", "fr-FR-ClaudeNeural", 
+            "fr-FR-CoralieNeural", "fr-FR-DeniseNeural", 
+            "fr-FR-EloiseNeural", "fr-FR-HenriNeural", 
+            "fr-FR-JacquelineNeural", "fr-FR-JeromeNeural", 
+            "fr-FR-JosephineNeural", "fr-FR-MauriceNeural", 
+            "fr-FR-YvesNeural", "fr-FR-YvetteNeural", 
+            "de-DE-AmalaNeural", "de-DE-BerndNeural", 
+            "de-DE-ChristophNeural", "de-DE-ConradNeural", 
+            "de-DE-ElkeNeural", "de-DE-GiselaNeural", 
+            "de-DE-KasperNeural", "de-DE-KatjaNeural", 
+            "de-DE-KillianNeural", "de-DE-KlarissaNeural", 
+            "de-DE-KlausNeural", "de-DE-LouisaNeural", 
+            "de-DE-MajaNeural", "de-DE-RalfNeural", 
+            "de-DE-TanjaNeural", "de-DE-ViktoriaNeural", 
+            "it-IT-BenignoNeural", "it-IT-CalimeroNeural", 
+            "it-IT-CataldoNeural", "it-IT-DiegoNeural", 
+            "it-IT-ElsaNeural", "it-IT-FabiolaNeural", 
+            "it-IT-GianniNeural", "it-IT-ImeldaNeural", 
+            "it-IT-IrmaNeural", "it-IT-IsabellaNeural", 
+            "it-IT-LisandroNeural", "it-IT-PalmiraNeural", 
+            "it-IT-PierinaNeural", "it-IT-RinaldoNeural", 
+            "ja-JP-AoiNeural", "ja-JP-DaichiNeural", 
+            "ja-JP-HarukaNeural", "ja-JP-KeitaNeural", 
+            "ja-JP-MayuNeural", "ja-JP-NanamiNeural", 
+            "ja-JP-NaokiNeural", "ja-JP-ShioriNeural"
+        ]
+        if voz not in voces_validas:
+            raise ValueError(f"La voz seleccionada '{voz}' no es válida.")
+        
         logging.info("Generando TTS")
         communicate = edge_tts.Communicate(texto, voz)
         with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_tts:
@@ -75,15 +139,21 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada):
         logging.info("Iniciando procesamiento")
         video_original = VideoFileClip(video_input, target_resolution=(720, 1280))
         duracion_video = video_original.duration
+        
+        if duracion_video <= 0:
+            raise ValueError("El video debe tener una duración mayor que cero.")
+        
         tts_audio, tts_path = await generar_tts(texto_tts, voz_seleccionada, duracion_video)
         bg_audio, bg_path = crear_musica_fondo(duracion_video)
         temp_files.extend([tts_path, bg_path])
+        
         audio_original = video_original.audio.volumex(0.7) if video_original.audio else None
         audios = [bg_audio.set_duration(duracion_video)]
         if audio_original:
             audios.append(audio_original)
         audios.append(tts_audio.set_start(0).volumex(0.85))
         audio_final = CompositeAudioClip(audios).set_duration(duracion_video)
+        
         video_final = video_original.copy()
         if duracion_video > SEGMENT_DURATION:
             clips = []
@@ -103,10 +173,12 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada):
                     clips.append(transition)
                     clips.append(segment)
             video_final = concatenate_videoclips(clips, method="compose")
+        
         video_final = video_final.set_audio(audio_final)
         intro = VideoFileClip(INTRO_VIDEO, target_resolution=(720, 1280))
         outro = VideoFileClip(OUTRO_VIDEO, target_resolution=(720, 1280))
         video_final = concatenate_videoclips([intro, video_final, outro], method="compose")
+        
         with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmp:
             video_final.write_videofile(
                 tmp.name,
@@ -145,6 +217,7 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada):
         except Exception as e:
             logging.warning(f"Error al cerrar recursos: {str(e)}")
 
+# Interfaz Gradio
 with gr.Blocks() as demo:
     gr.Markdown("# Editor de Video con IA")
     with gr.Tab("Principal"):
@@ -158,7 +231,7 @@ with gr.Blocks() as demo:
             label="Voz",
             choices=[
                 "es-ES-AlvaroNeural", "es-MX-BeatrizNeural", 
-                "es-ES-ElviraNeural", "es-MX-JavierNeural", 
+                "es-ES-ElviraNeural", "es-MX-JavierNeural",
                 "es-AR-ElenaNeural", "es-AR-TomasNeural", 
                 "es-CL-CatalinaNeural", "es-CL-LorenzoNeural", 
                 "es-CO-SofiaNeural", "es-CO-GonzaloNeural",