Update app.py

app.py

@@ -842,42 +842,31 @@ def run_app(prompt_type, prompt_ia, prompt_manual, musica_file):
     logger.info("SOLICITUD RECIBIDA EN INTERFAZ")
     input_text = prompt_ia if prompt_type == "Generar Guion con IA" else prompt_manual
     output_video = None
-    output_file = gr.update(value=None, visible=False)  # Inicialmente oculto
+    output_file = gr.update(value=None, visible=False)
     status_msg = gr.update(value="⏳ Procesando...", interactive=False)
-    
     if not input_text or not input_text.strip():
         logger.warning("Texto de entrada vacío.")
         status_msg = gr.update(value="⚠️ Por favor, ingresa texto para el guion o el tema.", interactive=False)
         return output_video, output_file, status_msg
-        
     logger.info(f"Tipo de entrada: {prompt_type}")
     logger.debug(f"Texto de entrada: '{input_text[:100]}...'")
-    
     if musica_file:
         logger.info(f"Archivo de música recibido: {musica_file}")
     else:
         logger.info("No se proporcionó archivo de música.")
-        
     try:
         logger.info("Llamando a crear_video...")
         video_path = crear_video(prompt_type, input_text, musica_file)
-        
         if video_path and os.path.exists(video_path):
             logger.info(f"crear_video retornó path: {video_path}")
             logger.info(f"Tamaño del archivo de video retornado: {os.path.getsize(video_path)} bytes")
-            
-            # ASIGNACIÓN CORRECTA - HACER VISIBLE EL BOTÓN DE DESCARGA
             output_video = video_path
-            output_file = gr.update(value=video_path, visible=True)  # CAMBIAR A TRUE
+            output_file = gr.update(value=video_path, visible=True)
             status_msg = gr.update(value="✅ Video generado exitosamente.", interactive=False)
-            
-            # IMPRIMIR LINK DIRECTO EN CONSOLA
             print(f"\n\nLINK DE DESCARGA DIRECTO: file://{video_path}\n\n")
-            
         else:
             logger.error(f"crear_video no retornó un path válido o el archivo no existe: {video_path}")
             status_msg = gr.update(value="❌ Error: La generación del video falló o el archivo no se creó correctamente.", interactive=False)
-            
     except ValueError as ve:
         logger.warning(f"Error de validación durante la creación del video: {str(ve)}")
         status_msg = gr.update(value=f"⚠️ Error de validación: {str(ve)}", interactive=False)
@@ -886,4 +875,492 @@ def run_app(prompt_type, prompt_ia, prompt_manual, musica_file):
         status_msg = gr.update(value=f"❌ Error inesperado: {str(e)}", interactive=False)
     finally:
         logger.info("Fin del handler run_app.")
-        return output_video, output_file, status_msg
+        return output_video, output_file, status_msg
+
+def schedule_directory_deletion(directory_path, delay_hours=3):
+    import threading
+    import time
+    import shutil
+    def delete_directory():
+        time.sleep(delay_hours * 3600)
+        try:
+            if os.path.exists(directory_path):
+                shutil.rmtree(directory_path)
+                logger.info(f"Directorio temporal autoeliminado: {directory_path}")
+        except Exception as e:
+            logger.warning(f"No se pudo eliminar directorio {directory_path}: {str(e)}")
+    thread = threading.Thread(target=delete_directory)
+    thread.daemon = True
+    thread.start()
+
+def crear_video(prompt_type, input_text, musica_file=None):
+    logger.info("="*80)
+    logger.info(f"INICIANDO CREACIÓN DE VIDEO | Tipo: {prompt_type}")
+    logger.debug(f"Input: '{input_text[:100]}...'")
+    start_time = datetime.now()
+    temp_dir_intermediate = None
+    audio_tts_original = None
+    musica_audio_original = None
+    audio_tts = None
+    musica_audio = None
+    video_base = None
+    video_final = None
+    source_clips = []
+    clips_to_concatenate = []
+    try:
+        if prompt_type == "Generar Guion con IA":
+            guion = generate_script(input_text)
+        else:
+            guion = input_text.strip()
+        logger.info(f"Guion final ({len(guion)} chars): '{guion[:100]}...'")
+        if not guion.strip():
+            logger.error("El guion resultante está vacío o solo contiene espacios.")
+            raise ValueError("El guion está vacío.")
+        guion = guion.replace("na hora", "A la hora")
+        temp_dir_intermediate = tempfile.mkdtemp(prefix="video_gen_intermediate_")
+        logger.info(f"Directorio temporal intermedio creado: {temp_dir_intermediate}")
+        logger.info("Generando audio de voz...")
+        voz_path = os.path.join(temp_dir_intermediate, "voz.mp3")
+        tts_success = text_to_speech(guion, voz_path)
+        if not tts_success or not os.path.exists(voz_path) or os.path.getsize(voz_path) <= 1000:
+            logger.error(f"Fallo en la generación de voz. Archivo de audio no creado o es muy pequeño: {voz_path}")
+            raise ValueError("Error generando voz a partir del guion (fallo de TTS).")
+        audio_tts_original = AudioFileClip(voz_path)
+        if audio_tts_original.reader is None or audio_tts_original.duration is None or audio_tts_original.duration <= 0:
+            logger.critical("Clip de audio TTS inicial es inválido (reader is None o duración <= 0) *después* de crear AudioFileClip.")
+            try: audio_tts_original.close()
+            except: pass
+            audio_tts_original = None
+            raise ValueError("Audio de voz generado es inválido después de procesamiento inicial.")
+        audio_tts = audio_tts_original
+        audio_duration = audio_tts_original.duration
+        logger.info(f"Duración audio voz: {audio_duration:.2f} segundos")
+        if audio_duration < 1.0:
+             logger.error(f"Duración audio voz ({audio_duration:.2f}s) es muy corta.")
+             raise ValueError("Generated voice audio is too short (min 1 second required).")
+        logger.info("Extrayendo palabras clave...")
+        try:
+            keywords = extract_visual_keywords_from_script(guion)
+            logger.info(f"Palabras clave identificadas: {keywords}")
+        except Exception as e:
+            logger.error(f"Error extrayendo keywords: {str(e)}", exc_info=True)
+            keywords = ["naturaleza", "paisaje"]
+        if not keywords:
+             keywords = ["video", "background"]
+        logger.info("Buscando videos en Pexels...")
+        videos_data = []
+        total_desired_videos = 10
+        per_page_per_keyword = max(1, total_desired_videos // len(keywords))
+        for keyword in keywords:
+            if len(videos_data) >= total_desired_videos: break
+            try:
+                videos = buscar_videos_pexels(keyword, PEXELS_API_KEY, per_page=per_page_per_keyword)
+                if videos:
+                    videos_data.extend(videos)
+                    logger.info(f"Encontrados {len(videos)} videos para '{keyword}'. Total data: {len(videos_data)}")
+            except Exception as e:
+                logger.warning(f"Error buscando videos para '{keyword}': {str(e)}")
+        if len(videos_data) < total_desired_videos / 2:
+            logger.warning(f"Pocos videos encontrados ({len(videos_data)}). Intentando con palabras clave genéricas.")
+            generic_keywords = ["nature", "city", "background", "abstract"]
+            for keyword in generic_keywords:
+                 if len(videos_data) >= total_desired_videos: break
+                 try:
+                    videos = buscar_videos_pexels(keyword, PEXELS_API_KEY, per_page=2)
+                    if videos:
+                        videos_data.extend(videos)
+                        logger.info(f"Encontrados {len(videos)} videos para '{keyword}' (genérico). Total data: {len(videos_data)}")
+                 except Exception as e:
+                    logger.warning(f"Error buscando videos genéricos para '{keyword}': {str(e)}")
+        if not videos_data:
+            logger.error("No se encontraron videos en Pexels para ninguna palabra clave.")
+            raise ValueError("No se encontraron videos adecuados en Pexels.")
+        video_paths = []
+        logger.info(f"Intentando descargar {len(videos_data)} videos encontrados...")
+        for video in videos_data:
+            if 'video_files' not in video or not video['video_files']:
+                logger.debug(f"Saltando video sin archivos de video: {video.get('id')}")
+                continue
+            try:
+                best_quality = None
+                for vf in sorted(video['video_files'], key=lambda x: x.get('width', 0) * x.get('height', 0), reverse=True):
+                    if 'link' in vf:
+                        best_quality = vf
+                        break
+                if best_quality and 'link' in best_quality:
+                    path = download_video_file(best_quality['link'], temp_dir_intermediate)
+                    if path:
+                        video_paths.append(path)
+                        logger.info(f"Video descargado OK desde {best_quality['link'][:50]}...")
+                    else:
+                         logger.warning(f"No se pudo descargar video desde {best_quality['link'][:50]}...")
+                else:
+                    logger.warning(f"No se encontró enlace de descarga válido para video {video.get('id')}.")
+            except Exception as e:
+                logger.warning(f"Error procesando/descargando video {video.get('id')}: {str(e)}")
+        logger.info(f"Descargados {len(video_paths)} archivos de video utilizables.")
+        if not video_paths:
+            logger.error("No se pudo descargar ningún archivo de video utilizable.")
+            raise ValueError("No se pudo descargar ningún video utilizable de Pexels.")
+        logger.info("Procesando y concatenando videos descargados...")
+        current_duration = 0
+        min_clip_duration = 0.5
+        max_clip_segment = 10.0
+        for i, path in enumerate(video_paths):
+            if current_duration >= audio_duration + max_clip_segment:
+                logger.debug(f"Video base suficiente ({current_duration:.1f}s >= {audio_duration:.1f}s + {max_clip_segment:.1f}s buffer). Dejando de procesar clips fuente restantes.")
+                break
+            clip = None
+            try:
+                logger.debug(f"[{i+1}/{len(video_paths)}] Abriendo clip: {path}")
+                clip = VideoFileClip(path)
+                source_clips.append(clip)
+                if clip.reader is None or clip.duration is None or clip.duration <= 0:
+                    logger.warning(f"[{i+1}/{len(video_paths)}] Clip fuente {path} parece inválido (reader is None o duración <= 0). Saltando.")
+                    continue
+                remaining_needed = audio_duration - current_duration
+                potential_use_duration = min(clip.duration, max_clip_segment)
+                if remaining_needed > 0:
+                     segment_duration = min(potential_use_duration, remaining_needed + min_clip_duration)
+                     segment_duration = max(min_clip_duration, segment_duration)
+                     segment_duration = min(segment_duration, clip.duration)
+                     if segment_duration >= min_clip_duration:
+                          try:
+                               sub = clip.subclip(0, segment_duration)
+                               if sub.reader is None or sub.duration is None or sub.duration <= 0:
+                                    logger.warning(f"[{i+1}/{len(video_paths)}] Subclip generado de {path} es inválido. Saltando.")
+                                    try: sub.close()
+                                    except: pass
+                                    continue
+                               clips_to_concatenate.append(sub)
+                               current_duration += sub.duration
+                               logger.debug(f"[{i+1}/{len(video_paths)}] Segmento añadido: {sub.duration:.1f}s (total video: {current_duration:.1f}/{audio_duration:.1f}s)")
+                          except Exception as sub_e:
+                               logger.warning(f"[{i+1}/{len(video_paths)}] Error creando subclip de {path} ({segment_duration:.1f}s): {str(sub_e)}")
+                               continue
+                     else:
+                          logger.debug(f"[{i+1}/{len(video_paths)}] Clip {path} ({clip.duration:.1f}s) no contribuye un segmento suficiente ({segment_duration:.1f}s necesario). Saltando.")
+                else:
+                    logger.debug(f"[{i+1}/{len(video_paths)}] Duración de video base ya alcanzada. Saltando clip.")
+            except Exception as e:
+                logger.warning(f"[{i+1}/{len(video_paths)}] Error procesando video {path}: {str(e)}", exc_info=True)
+                continue
+        logger.info(f"Procesamiento de clips fuente finalizado. Se obtuvieron {len(clips_to_concatenate)} segmentos válidos.")
+        if not clips_to_concatenate:
+            logger.error("No hay segmentos de video válidos disponibles para crear la secuencia.")
+            raise ValueError("No hay segmentos de video válidos disponibles para crear el video.")
+        logger.info(f"Concatenando {len(clips_to_concatenate)} segmentos de video.")
+        concatenated_base = None
+        try:
+            concatenated_base = concatenate_videoclips(clips_to_concatenate, method="chain")
+            logger.info(f"Duración video base después de concatenación inicial: {concatenated_base.duration:.2f}s")
+            if concatenated_base is None or concatenated_base.duration is None or concatenated_base.duration <= 0:
+                 logger.critical("Video base concatenado es inválido después de la primera concatenación (None o duración cero).")
+                 raise ValueError("Fallo al crear video base válido a partir de segmentos.")
+        except Exception as e:
+             logger.critical(f"Error durante la concatenación inicial: {str(e)}", exc_info=True)
+             raise ValueError("Fallo durante la concatenación de video inicial.")
+        finally:
+             for clip_segment in clips_to_concatenate:
+                  try: clip_segment.close()
+                  except: pass
+             clips_to_concatenate = []
+        video_base = concatenated_base
+        final_video_base = video_base
+        if final_video_base.duration < audio_duration:
+            logger.info(f"Video base ({final_video_base.duration:.2f}s) es más corto que el audio ({audio_duration:.2f}s). Repitiendo...")
+            num_full_repeats = int(audio_duration // final_video_base.duration)
+            remaining_duration = audio_duration % final_video_base.duration
+            repeated_clips_list = [final_video_base] * num_full_repeats
+            if remaining_duration > 0:
+                try:
+                    remaining_clip = final_video_base.subclip(0, remaining_duration)
+                    if remaining_clip is None or remaining_clip.duration is None or remaining_clip.duration <= 0:
+                        logger.warning(f"Subclip generado para duración restante {remaining_duration:.2f}s es inválido. Saltando.")
+                        try: remaining_clip.close()
+                        except: pass
+                    else:
+                         repeated_clips_list.append(remaining_clip)
+                         logger.debug(f"Añadiendo segmento restante: {remaining_duration:.2f}s")
+                except Exception as e:
+                     logger.warning(f"Error creando subclip para duración restante {remaining_duration:.2f}s: {str(e)}")
+            if repeated_clips_list:
+                 logger.info(f"Concatenando {len(repeated_clips_list)} partes para repetición.")
+                 video_base_repeated = None
+                 try:
+                    video_base_repeated = concatenate_videoclips(repeated_clips_list, method="chain")
+                    logger.info(f"Duración del video base repetido: {video_base_repeated.duration:.2f}s")
+                    if video_base_repeated is None or video_base_repeated.duration is None or video_base_repeated.duration <= 0:
+                         logger.critical("Video base repetido concatenado es inválido.")
+                         raise ValueError("Fallo al crear video base repetido válido.")
+                    if final_video_base is not video_base_repeated:
+                        try: final_video_base.close()
+                        except: pass
+                    final_video_base = video_base_repeated
+                 except Exception as e:
+                    logger.critical(f"Error durante la concatenación de repetición: {str(e)}", exc_info=True)
+                    raise ValueError("Fallo durante la repetición de video.")
+                 finally:
+                     for clip in repeated_clips_list:
+                              if clip is not final_video_base:
+                                   try: clip.close()
+                                   except: pass
+        if final_video_base.duration > audio_duration:
+             logger.info(f"Recortando video base ({final_video_base.duration:.2f}s) para que coincida con la duración del audio ({audio_duration:.2f}s).")
+             trimmed_video_base = None
+             try:
+                trimmed_video_base = final_video_base.subclip(0, audio_duration)
+                if trimmed_video_base is None or trimmed_video_base.duration is None or trimmed_video_base.duration <= 0:
+                     logger.critical("Video base recortado es inválido.")
+                     raise ValueError("Fallo al crear video base recortado válido.")
+                if final_video_base is not trimmed_video_base:
+                     try: final_video_base.close()
+                     except: pass
+                final_video_base = trimmed_video_base
+             except Exception as e:
+                logger.critical(f"Error durante el recorte: {str(e)}", exc_info=True)
+                raise ValueError("Fallo durante el recorte de video.")
+        if final_video_base is None or final_video_base.duration is None or final_video_base.duration <= 0:
+             logger.critical("Video base final es inválido antes de audio/escritura (None o duración cero).")
+             raise ValueError("Video base final es inválido.")
+        if final_video_base.size is None or final_video_base.size[0] <= 0 or final_video_base.size[1] <= 0:
+             logger.critical(f"Video base final tiene tamaño inválido: {final_video_base.size}. No se puede escribir video.")
+             raise ValueError("Video base final tiene tamaño inválido antes de escribir.")
+        video_base = final_video_base
+        logger.info("Procesando audio...")
+        final_audio = audio_tts_original
+        musica_audio_looped = None
+        if musica_file:
+            musica_audio_original = None
+            try:
+                music_path = os.path.join(temp_dir_intermediate, "musica_bg.mp3")
+                shutil.copyfile(musica_file, music_path)
+                logger.info(f"Música de fondo copiada a: {music_path}")
+                musica_audio_original = AudioFileClip(music_path)
+                if musica_audio_original.reader is None or musica_audio_original.duration is None or musica_audio_original.duration <= 0:
+                     logger.warning("Clip de música de fondo parece inválido o tiene duración cero. Saltando música.")
+                     try: musica_audio_original.close()
+                     except: pass
+                     musica_audio_original = None
+                else:
+                     musica_audio_looped = loop_audio_to_length(musica_audio_original, video_base.duration)
+                     logger.debug(f"Música ajustada a duración del video: {musica_audio_looped.duration:.2f}s")
+                     if musica_audio_looped is None or musica_audio_looped.duration is None or musica_audio_looped.duration <= 0:
+                          logger.warning("Clip de música de fondo loopeado es inválido. Saltando música.")
+                          try: musica_audio_looped.close()
+                          except: pass
+                          musica_audio_looped = None
+                if musica_audio_looped:
+                    composite_audio = CompositeAudioClip([
+                        musica_audio_looped.volumex(0.2),
+                        audio_tts_original.volumex(1.0)
+                    ])
+                    if composite_audio.duration is None or composite_audio.duration <= 0:
+                        logger.warning("Clip de audio compuesto es inválido (None o duración cero). Usando solo audio de voz.")
+                        try: composite_audio.close()
+                        except: pass
+                        final_audio = audio_tts_original
+                    else:
+                         logger.info("Mezcla de audio completada (voz + música).")
+                         final_audio = composite_audio
+                         musica_audio = musica_audio_looped
+            except Exception as e:
+                logger.warning(f"Error procesando música de fondo: {str(e)}", exc_info=True)
+                final_audio = audio_tts_original
+                musica_audio = None
+                logger.warning("Usando solo audio de voz debido a un error con la música.")
+        if final_audio.duration is not None and abs(final_audio.duration - video_base.duration) > 0.2:
+            logger.warning(f"Duración del audio final ({final_audio.duration:.2f}s) difiere significativamente del video base ({video_base.duration:.2f}s). Intentando recorte.")
+            try:
+                 if final_audio.duration > video_base.duration:
+                      trimmed_final_audio = final_audio.subclip(0, video_base.duration)
+                      if trimmed_final_audio is None or trimmed_final_audio.duration <= 0:
+                           logger.warning("Audio final recortado es inválido. Usando audio final original.")
+                           try: trimmed_final_audio.close()
+                           except: pass
+                      else:
+                           if final_audio is not trimmed_final_audio:
+                               try: final_audio.close()
+                               except: pass
+                           final_audio = trimmed_final_audio
+                           logger.warning("Audio final recortado para que coincida con la duración del video.")
+            except Exception as e:
+                 logger.warning(f"Error ajustando duración del audio final: {str(e)}")
+        logger.info("Renderizando video final...")
+        video_final = video_base.set_audio(final_audio)
+        if video_final is None or video_final.duration is None or video_final.duration <= 0:
+             logger.critical("Clip de video final (con audio) es inválido antes de escribir (None o duración cero).")
+             raise ValueError("Clip de video final es inválido antes de escribir.")
+        output_filename = "final_video.mp4"
+        output_path = os.path.join(temp_dir_intermediate, output_filename)
+        logger.info(f"Escribiendo video final a: {output_path}")
+        if not output_path or not isinstance(output_path, str):
+            logger.critical(f"output_path no es válido: {output_path}")
+            raise ValueError("El nombre del archivo de salida no es válido.")
+        try:
+            video_final.write_videofile(
+                filename=output_path,
+                fps=24,
+                threads=4,
+                codec="libx264",
+                audio_codec="aac",
+                preset="medium",
+                logger='bar'
+            )
+        except Exception as e:
+            logger.critical(f"Error al escribir el video final: {str(e)}", exc_info=True)
+            raise ValueError(f"Fallo al escribir el video final: {str(e)}")
+        total_time = (datetime.now() - start_time).total_seconds()
+        logger.info(f"PROCESO DE VIDEO FINALIZADO | Output: {output_path} | Tiempo total: {total_time:.2f}s")
+        schedule_directory_deletion(temp_dir_intermediate)
+        return output_path
+    except ValueError as ve:
+         logger.error(f"ERROR CONTROLADO en crear_video: {str(ve)}")
+         raise ve
+    except Exception as e:
+        logger.critical(f"ERROR CRÍTICO NO CONTROLADO en crear_video: {str(e)}", exc_info=True)
+        raise e
+    finally:
+        logger.info("Iniciando limpieza de clips y archivos temporales intermedios...")
+        for clip in source_clips:
+            try:
+                clip.close()
+            except Exception as e:
+                logger.warning(f"Error cerrando clip de video fuente en finally: {str(e)}")
+        for clip_segment in clips_to_concatenate:
+             try:
+                 clip_segment.close()
+             except Exception as e:
+                 logger.warning(f"Error cerrando segmento de video en finally: {str(e)}")
+        if musica_audio is not None:
+            try:
+                musica_audio.close()
+            except Exception as e:
+                logger.warning(f"Error cerrando musica_audio (procesada) en finally: {str(e)}")
+        if musica_audio_original is not None and musica_audio_original is not musica_audio:
+             try:
+                 musica_audio_original.close()
+             except Exception as e:
+                 logger.warning(f"Error cerrando musica_audio_original en finally: {str(e)}")
+        if audio_tts is not None and audio_tts is not audio_tts_original:
+             try:
+                 audio_tts.close()
+             except Exception as e:
+                 logger.warning(f"Error cerrando audio_tts (procesada) en finally: {str(e)}")
+        if audio_tts_original is not None:
+             try:
+                 audio_tts_original.close()
+             except Exception as e:
+                 logger.warning(f"Error cerrando audio_tts_original en finally: {str(e)}")
+        if video_final is not None:
+            try:
+                video_final.close()
+            except Exception as e:
+                logger.warning(f"Error cerrando video_final en finally: {str(e)}")
+        elif video_base is not None and video_base is not video_final:
+             try:
+                 video_base.close()
+             except Exception as e:
+                 logger.warning(f"Error cerrando video_base en finally: {str(e)}")
+        if temp_dir_intermediate and os.path.exists(temp_dir_intermediate):
+            schedule_directory_deletion(temp_dir_intermediate)
+            logger.info(f"Directorio temporal {temp_dir_intermediate} programado para eliminación en 3 horas.")
+
+with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="""
+    .gradio-container {max-width: 800px; margin: auto;}
+    h1 {text-align: center;}
+    """) as app:
+    gr.Markdown("# 🎬 Generador Automático de Videos con IA")
+    gr.Markdown("Genera videos cortos a partir de un tema o guion, usando imágenes de archivo de Pexels y voz generada.")
+    with gr.Row():
+        with gr.Column():
+            prompt_type = gr.Radio(
+                ["Generar Guion con IA", "Usar Mi Guion"],
+                label="Método de Entrada",
+                value="Generar Guion con IA"
+            )
+            with gr.Column(visible=True) as ia_guion_column:
+                prompt_ia = gr.Textbox(
+                    label="Tema para IA",
+                    lines=2,
+                    placeholder="Ej: Un paisaje natural con montañas y ríos al amanecer, mostrando la belleza de la naturaleza...",
+                    max_lines=4,
+                    value=""
+                )
+            with gr.Column(visible=False) as manual_guion_column:
+                prompt_manual = gr.Textbox(
+                    label="Tu Guion Completo",
+                    lines=5,
+                    placeholder="Ej: En este video exploraremos los misterios del océano. Veremos la vida marina fascinante y los arrecifes de coral vibrantes. ¡Acompáñanos en esta aventura subacuática!",
+                    max_lines=10,
+                    value=""
+                )
+            musica_input = gr.Audio(
+                label="Música de fondo (opcional)",
+                type="filepath",
+                interactive=True,
+                value=None
+            )
+            generate_btn = gr.Button("✨ Generar Video", variant="primary")
+        with gr.Column():
+            video_output = gr.Video(
+                label="Previsualización del Video Generado",
+                interactive=False,
+                height=400
+            )
+            file_output = gr.File(
+                label="Descargar Archivo de Video",
+                interactive=False,
+                visible=False
+            )
+            status_output = gr.Textbox(
+                label="Estado",
+                interactive=False,
+                show_label=False,
+                placeholder="Esperando acción...",
+                value="Esperando entrada..."
+            )
+    prompt_type.change(
+        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 varios minutos.", interactive=False)),
+        outputs=[video_output, file_output, status_output],
+        queue=True,
+    ).then(
+        run_app,
+        inputs=[prompt_type, prompt_ia, prompt_manual, musica_input],
+        outputs=[video_output, file_output, status_output]
+    )
+    gr.Markdown("### Instrucciones:")
+    gr.Markdown("""
+    1.  **Clave API de Pexels:** Asegúrate de haber configurado la variable de entorno `PEXELS_API_KEY` con tu clave.
+    """)
+    gr.Markdown("---")
+    gr.Markdown("Desarrollado por [Tu Nombre/Empresa/Alias - Opcional]")
+
+if __name__ == "__main__":
+    logger.info("Verificando dependencias críticas...")
+    try:
+        from moviepy.editor import ColorClip
+        try:
+            temp_clip = ColorClip((100,100), color=(255,0,0), duration=0.1)
+            temp_clip.close()
+            logger.info("Clips base de MoviePy (como ColorClip) creados y cerrados exitosamente. FFmpeg parece accesible.")
+        except Exception as e:
+            logger.critical(f"Fallo al crear clip base de MoviePy. A menudo indica problemas con FFmpeg/ImageMagick. Error: {e}", exc_info=True)
+    except Exception as e:
+         logger.critical(f"Fallo al importar MoviePy. Asegúrate de que está instalado. Error: {e}", exc_info=True)
+    logger.info("Iniciando aplicación Gradio...")
+    try:
+        app.queue(concurrency_count=1, max_size=1, api_open=False).launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=False
+        )
+    except Exception as e:
+        logger.critical(f"No se pudo iniciar la app: {str(e)}", exc_info=True)
+        raise