Update app.py

app.py

@@ -3,289 +3,447 @@ import asyncio
 import logging
 import tempfile
 import requests
-import re
-import math
+from datetime import datetime
 import edge_tts
 import gradio as gr
-from pydub import AudioSegment
+import torch
+from transformers import GPT2Tokenizer, GPT2LMHeadModel
+from keybert import KeyBERT
+from moviepy.editor import VideoFileClip, concatenate_videoclips, AudioFileClip, CompositeAudioClip
 import subprocess
+import re
+import math
+from pydub import AudioSegment
 
-# Configuración básica de logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
-# Clave API de Pexels (configurar en Secrets de Hugging Face)
-PEXELS_API_KEY = os.environ.get("PEXELS_API_KEY", "YOUR_API_KEY")
+PEXELS_API_KEY = os.environ.get("PEXELS_API_KEY") 
+
+MODEL_NAME = "gpt2" 
+try:
+    tokenizer = GPT2Tokenizer.from_pretrained(MODEL_NAME)
+    model = GPT2LMHeadModel.from_pretrained(MODEL_NAME).eval()
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+    logger.info(f"Modelo GPT-2 '{MODEL_NAME}' cargado exitosamente.")
+except Exception as e:
+    logger.error(f"Error al cargar el modelo GPT-2 '{MODEL_NAME}': {e}")
+    tokenizer = None
+    model = None
 
-# --- Funciones optimizadas y corregidas ---
+try:
+    kw_model = KeyBERT('multi-qa-MiniLM-L6-cos-v1') 
+    logger.info("Modelo KeyBERT cargado exitosamente.")
+except Exception as e:
+    logger.error(f"Error al cargar el modelo KeyBERT: {e}")
+    kw_model = None
 
-def extract_keywords(text, max_keywords=3):
-    """Extrae palabras clave usando un método mejorado"""
-    # Limpieza de texto y tokenización
-    text = re.sub(r'[^\w\s]', '', text.lower())
-    words = re.findall(r'\b\w+\b', text)
+def generate_script(prompt, max_length=250): 
+    if not tokenizer or not model:
+        logger.error("Modelo GPT-2 no disponible para generar guion.")
+        return "Lo siento, el generador de guiones no está disponible en este momento."
+
+    logger.info("Generando guion con GPT-2...")
+    try:
+        inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=512)
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        inputs = {k: v.to(device) for k, v in inputs.items()}
+        model.to(device)
+
+        with torch.no_grad():
+            outputs = model.generate(
+                **inputs,
+                max_length=max_length,
+                do_sample=True,
+                top_p=0.95,
+                top_k=60,
+                temperature=0.9,
+                pad_token_id=tokenizer.pad_token_id,
+                eos_token_id=tokenizer.eos_token_id
+            )
+        text = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        logger.info(f"Guion generado (longitud: {len(text)} caracteres): {text[:200]}...")
+        return text
+    except Exception as e:
+        logger.error(f"Error durante la generación del guion: {e}")
+        return "No se pudo generar el guion. Intenta con otro prompt o un guion propio."
+
+async def text_to_speech(text, voice="es-ES-ElviraNeural", output_path="voz.mp3"):
+    logger.info(f"Generando audio TTS para: '{text[:100]}...'")
+    try:
+        communicate = edge_tts.Communicate(text, voice)
+        await communicate.save(output_path)
+        logger.info(f"Audio TTS guardado en {output_path}")
+    except Exception as e:
+        logger.error(f"Error al generar audio TTS: {e}")
+        raise
+
+def download_video_file(url, temp_dir): 
+    if not url:
+        return None
     
-    # Palabras comunes a excluir (lista ampliada)
-    stop_words = {
-        "el", "la", "los", "las", "de", "en", "y", "a", "que", "es", "por", 
-        "un", "una", "con", "se", "del", "al", "lo", "como", "para", "su", "sus"
-    }
+    file_name = url.split('/')[-1].split('?')[0]
+    if not file_name.endswith('.mp4'): 
+        file_name = f"video_temp_{os.getpid()}_{datetime.now().strftime('%f')}.mp4"
     
-    # Frecuencia de palabras y filtrado
-    word_freq = {}
-    for word in words:
-        if len(word) > 3 and word not in stop_words:
-            word_freq[word] = word_freq.get(word, 0) + 1
+    output_path = os.path.join(temp_dir, file_name)
+    logger.info(f"Intentando descargar video de: {url} a {output_path}")
+    try:
+        response = requests.get(url, stream=True, timeout=30) 
+        response.raise_for_status()
+
+        with open(output_path, 'wb') as f:
+            for chunk in response.iter_content(chunk_size=8192):
+                if chunk:
+                    f.write(chunk)
+        logger.info(f"Video descargado a: {output_path}")
+        return output_path
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Error de red/HTTP al descargar el video {url}: {e}")
+        if os.path.exists(output_path):
+            os.remove(output_path)
+        return None
+    except Exception as e:
+        logger.error(f"Error inesperado al descargar video {url}: {e}")
+        if os.path.exists(output_path):
+            os.remove(output_path)
+        return None
+
+def loop_audio_to_length(audio_clip, target_duration):
+    if audio_clip.duration >= target_duration:
+        return audio_clip.subclip(0, target_duration)
     
-    # Ordenar por frecuencia y longitud
-    sorted_words = sorted(word_freq.items(), key=lambda x: (x[1], len(x[0])), reverse=True)
-    return [word for word, _ in sorted_words[:max_keywords]]
+    loops = int(target_duration / audio_clip.duration) + 1
+    audios = [audio_clip] * loops
+    concatenated = concatenate_videoclips(audios)
+    return concatenated.subclip(0, target_duration)
 
-def search_pexels_videos(keywords, per_query=2):
-    """Busca videos en Pexels con manejo de errores mejorado"""
-    if not PEXELS_API_KEY or not keywords:
-        return []
+def extract_visual_keywords_from_script(script_text, max_keywords_per_segment=2):
+    if not kw_model:
+        logger.warning("Modelo KeyBERT no disponible. La extracción de palabras clave será limitada.")
+        return [script_text.split('.')[0].strip().replace(" ", "+")] if script_text.strip() else []
+
+    logger.info("Extrayendo palabras clave visuales del guion.")
     
-    headers = {"Authorization": PEXELS_API_KEY}
-    video_urls = []
+    segments = [s.strip() for s in script_text.split('\n') if s.strip()]
+    if not segments: 
+        segments = [script_text]
+
+    all_keywords = set() 
     
-    for query in keywords:
+    for segment in segments:
+        if not segment: continue
         try:
-            logger.info(f"Buscando videos para: '{query}'")
+            keywords_with_scores = kw_model.extract_keywords(
+                segment,
+                keyphrase_ngram_range=(1, 2), 
+                stop_words='spanish', 
+                top_n=max_keywords_per_segment,
+                use_mmr=True, 
+                diversity=0.7 
+            )
+            for kw, score in keywords_with_scores:
+                all_keywords.add(kw.replace(" ", "+"))
+        except Exception as e:
+            logger.warning(f"Error al extraer palabras clave de un segmento: {e}")
+            all_keywords.add(segment.split(' ')[0].strip().replace(" ", "+"))
+
+    logger.info(f"Palabras clave visuales extraídas del guion: {list(all_keywords)}")
+    return list(all_keywords) 
+
+def search_pexels_videos(query_list, num_videos_per_query=5, min_duration_sec=7):
+    if not PEXELS_API_KEY:
+        logger.error("ERROR: PEXELS_API_KEY no está configurada. No se pueden buscar videos en Pexels.")
+        raise ValueError("PEXELS_API_KEY no está configurada. Por favor, configúrala como un secreto en Hugging Face Spaces.")
+
+    if not query_list:
+        logger.warning("Lista de queries para Pexels vacía. No se buscarán videos.")
+        return []
+
+    all_video_urls = set() 
+    
+    for query in query_list:
+        logger.info(f"Buscando {num_videos_per_query} videos en Pexels para la query: '{query}'")
+        try:
+            api_url = "https://api.pexels.com/videos/search"
+            headers = {"Authorization": PEXELS_API_KEY}
             params = {
                 "query": query,
-                "per_page": per_query,
+                "per_page": num_videos_per_query * 2,
                 "orientation": "landscape",
-                "size": "medium"
+                "min_duration": min_duration_sec
             }
             
-            response = requests.get(
-                "https://api.pexels.com/videos/search",
-                headers=headers,
-                params=params,
-                timeout=20
-            )
+            response = requests.get(api_url, headers=headers, params=params, timeout=15)
+            response.raise_for_status()
             
-            if response.status_code == 200:
-                data = response.json()
-                videos = data.get("videos", [])
+            data = response.json()
+            videos = data.get('videos', [])
+
+            if not videos:
+                logger.info(f"No se encontraron videos en Pexels para la query: '{query}'")
+                continue
+
+            for video in videos:
+                best_quality_url = None
+                video_files = sorted(video.get('video_files', []), key=lambda x: x.get('width', 0) * x.get('height', 0), reverse=True)
                 
-                for video in videos:
-                    video_files = video.get("video_files", [])
-                    if video_files:
-                        # Seleccionar el video con la mejor resolución disponible
-                        best_quality = max(
-                            video_files, 
-                            key=lambda x: x.get("width", 0) * x.get("height", 0)
-                        )
-                        video_urls.append(best_quality["link"])
-                        logger.info(f"Video encontrado: {best_quality['link']}")
-            else:
-                logger.warning(f"Respuesta Pexels: {response.status_code}")
+                for file in video_files:
+                    if file.get('link'):
+                        best_quality_url = file['link']
+                        break 
+
+                if best_quality_url:
+                    all_video_urls.add(best_quality_url)
+                else:
+                    logger.warning(f"No se encontró URL de descarga válida para el video Pexels ID: {video.get('id')}")
+
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Error de HTTP/red al buscar videos en Pexels para '{query}': {e}", exc_info=True)
         except Exception as e:
-            logger.error(f"Error buscando videos: {str(e)}")
-    
-    return video_urls
+            logger.error(f"Error inesperado al buscar videos en Pexels para '{query}': {e}", exc_info=True)
+            
+    final_urls = list(all_video_urls)
+    logger.info(f"Total de {len(final_urls)} URLs de video únicas obtenidas de Pexels.")
+    return final_urls
 
-async def generate_tts(text, output_path, voice="es-ES-ElviraNeural"):
-    """Genera audio TTS con manejo de errores"""
-    try:
-        communicate = edge_tts.Communicate(text, voice)
-        await communicate.save(output_path)
-        logger.info("Audio TTS generado exitosamente")
-        return True
-    except Exception as e:
-        logger.error(f"Error en TTS: {str(e)}")
-        return False
+def crear_video(prompt_type, input_text, musica_url=None):
+    logger.info(f"Iniciando creación de video. Tipo de prompt: {prompt_type}")
+    guion = ""
+    if prompt_type == "Generar Guion con IA":
+        guion = generate_script(input_text)
+        if not guion or guion == "No se pudo generar el guion. Intenta con otro prompt o un guion propio.":
+            raise ValueError(guion) 
+    else: 
+        guion = input_text
+        if not guion.strip():
+            raise ValueError("Por favor, introduce tu guion.")
+
+    if not guion.strip():
+        raise ValueError("El guion está vacío. No se puede proceder.")
+
+    temp_files = [] 
+    downloaded_clip_paths = [] 
+    final_clips = [] 
+
+    temp_video_dir = tempfile.mkdtemp()
+    temp_files.append(temp_video_dir) 
 
-def download_video(url, temp_dir):
-    """Descarga videos con manejo robusto de errores"""
     try:
-        logger.info(f"Descargando video: {url}")
-        response = requests.get(url, stream=True, timeout=40)
-        response.raise_for_status()
+        voz_archivo = os.path.join(tempfile.gettempdir(), f"voz_temp_{os.getpid()}.mp3")
+        temp_files.append(voz_archivo)
+        asyncio.run(text_to_speech(guion, output_path=voz_archivo))
+        audio_tts = AudioFileClip(voz_archivo)
+
+        search_queries_for_pexels = extract_visual_keywords_from_script(guion, max_keywords_per_segment=2)
+
+        if not search_queries_for_pexels:
+            raise ValueError("No se pudieron extraer palabras clave visuales del guion para buscar videos.")
+
+        pexels_video_urls_found = search_pexels_videos(search_queries_for_pexels, num_videos_per_query=5, min_duration_sec=7) 
+
+        if not pexels_video_urls_found:
+            logger.error("Pexels no devolvió ningún video para las palabras clave extraídas.")
+            raise ValueError(f"Pexels no encontró videos adecuados para el guion. Intenta con otro tema o guion más descriptivo. Palabras clave usadas: {search_queries_for_pexels}")
+
+        logger.info(f"Descargando {len(pexels_video_urls_found)} videos de Pexels...")
+        for url in pexels_video_urls_found:
+            video_path = download_video_file(url, temp_video_dir) 
+            if video_path:
+                downloaded_clip_paths.append(video_path)
+            else:
+                logger.warning(f"No se pudo descargar video de Pexels: {url}")
         
-        filename = f"video_{os.getpid()}_{datetime.now().strftime('%H%M%S%f')}.mp4"
-        filepath = os.path.join(temp_dir, filename)
+        if not downloaded_clip_paths:
+            logger.error("No se pudo descargar ningún video válido de Pexels.")
+            raise ValueError("No se pudo descargar ningún video válido de Pexels. Revisa la conexión o la calidad de las URLs.")
+
+        total_desired_video_duration = audio_tts.duration * 1.2 
+        current_video_clips_duration = 0
         
-        with open(filepath, 'wb') as f:
-            for chunk in response.iter_content(chunk_size=8192):
-                f.write(chunk)
+        for path in downloaded_clip_paths:
+            try:
+                clip = VideoFileClip(path)
+                clip_duration = min(clip.duration, 10) 
+                if clip_duration > 1: 
+                    final_clips.append(clip.subclip(0, clip_duration))
+                    current_video_clips_duration += clip_duration
+                    if current_video_clips_duration >= total_desired_video_duration:
+                        break 
+                else:
+                    logger.warning(f"Clip de video muy corto ({clip_duration:.2f}s) de {path}, omitiendo.")
+                    clip.close()
+            except Exception as e:
+                logger.warning(f"No se pudo cargar o procesar el clip de video {path}: {e}. Omitiendo.")
+                if 'clip' in locals() and clip: clip.close() 
         
-        logger.info(f"Video descargado: {filepath}")
-        return filepath
-    except Exception as e:
-        logger.error(f"Error descargando video: {str(e)}")
-        return None
+        if not final_clips:
+            logger.error("No se pudo obtener ningún clip de video usable después de la descarga y procesamiento.")
+            raise ValueError("No se pudieron procesar los videos descargados de Pexels.")
 
-def create_video(audio_path, video_paths, output_path):
-    """Crea el video final con FFmpeg - VERSIÓN CORREGIDA"""
-    try:
-        # 1. Crear archivo de lista para concatenación
-        list_file_path = os.path.join(os.path.dirname(video_paths[0]), "input.txt")
-        with open(list_file_path, "w") as f:
-            for path in video_paths:
-                f.write(f"file '{os.path.basename(path)}'\n")
-        
-        # 2. Preparar comando FFmpeg
-        cmd = [
-            "ffmpeg", "-y",
-            "-f", "concat",
-            "-safe", "0",
-            "-i", list_file_path,
-            "-i", audio_path,
-            "-c:v", "libx264",  # Codificar video en lugar de copiar
-            "-preset", "fast",
-            "-crf", "23",
-            "-c:a", "aac",
-            "-b:a", "192k",
-            "-shortest",
-            "-movflags", "+faststart",
-            output_path
-        ]
+        video_base = concatenate_videoclips(final_clips, method="compose")
+        logger.info(f"Video base concatenado, duración: {video_base.duration:.2f}s")
+
+        if video_base.duration < audio_tts.duration:
+            logger.info(f"Duración del video ({video_base.duration:.2f}s) es menor que la del audio TTS ({audio_tts.duration:.2f}s). Repitiendo video.")
+            num_repeats = int(audio_tts.duration / video_base.duration) + 1
+            repeated_clips = [video_base] * num_repeats
+            video_base = concatenate_videoclips(repeated_clips, method="compose") 
         
-        # 3. Ejecutar FFmpeg con logging detallado
-        logger.info("Ejecutando FFmpeg: " + " ".join(cmd))
-        result = subprocess.run(
-            cmd, 
-            cwd=os.path.dirname(video_paths[0]),
-            stdout=subprocess.PIPE, 
-            stderr=subprocess.PIPE,
-            text=True
-        )
+        final_video_duration = audio_tts.duration
+
+        mezcla_audio = audio_tts
+        if musica_url and musica_url.strip():
+            musica_path = download_video_file(musica_url, temp_video_dir) 
+            if musica_path:
+                temp_files.append(musica_path) 
+                try:
+                    musica_audio = AudioFileClip(musica_path)
+                    musica_loop = loop_audio_to_length(musica_audio, final_video_duration)
+                    mezcla_audio = CompositeAudioClip([musica_loop.volumex(0.3), audio_tts.set_duration(final_video_duration).volumex(1.0)])
+                    logger.info("Música de fondo añadida y mezclada.")
+                except Exception as e:
+                    logger.warning(f"No se pudo procesar la música de fondo de {musica_url}: {e}. Se usará solo la voz.")
+            else:
+                logger.warning(f"No se pudo descargar la música de {musica_url}. Se usará solo la voz.")
         
-        if result.returncode != 0:
-            logger.error(f"Error FFmpeg (code {result.returncode}): {result.stderr}")
-            return False
+        video_final = video_base.set_audio(mezcla_audio).subclip(0, final_video_duration)
+        logger.info(f"Video final configurado con audio. Duración final: {video_final.duration:.2f}s")
+
+        output_dir = "generated_videos"
+        os.makedirs(output_dir, exist_ok=True)
+        output_path = os.path.join(output_dir, f"video_output_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4")
+        logger.info(f"Escribiendo video final a: {output_path}")
         
-        logger.info("Video creado exitosamente")
-        return True
+        video_final.write_videofile(
+            output_path, 
+            fps=24, 
+            threads=4, 
+            logger=None, 
+            preset="medium", 
+            codec="libx264",
+            audio_codec="aac",
+            ffmpeg_params=["-movflags", "+faststart"]
+        )
+
+        logger.info(f"Video generado exitosamente en: {output_path}")
+        return output_path
+
     except Exception as e:
-        logger.error(f"Error creando video: {str(e)}")
-        return False
+        logger.error(f"Error general en la creación del video: {e}", exc_info=True)
+        raise e
     finally:
-        try:
-            if os.path.exists(list_file_path):
-                os.remove(list_file_path)
-        except:
-            pass
-
-async def generate_video(text, music_file=None):
-    """Función principal con manejo mejorado de errores"""
-    temp_dir = tempfile.mkdtemp()
-    logger.info(f"Directorio temporal creado: {temp_dir}")
-    
-    try:
-        # 1. Generar audio TTS
-        tts_path = os.path.join(temp_dir, "audio.mp3")
-        if not await generate_tts(text, tts_path):
-            return None, "❌ Error generando voz"
-        
-        # 2. Extraer palabras clave
-        keywords = extract_keywords(text)
-        if not keywords:
-            return None, "❌ No se pudieron extraer palabras clave del texto"
-        logger.info(f"Palabras clave identificadas: {keywords}")
-        
-        # 3. Buscar y descargar videos
-        video_urls = search_pexels_videos(keywords)
-        if not video_urls:
-            return None, "❌ No se encontraron videos para las palabras clave"
+        for f in temp_files:
+            if os.path.exists(f):
+                if os.path.isdir(f):
+                    import shutil
+                    shutil.rmtree(f)
+                    logger.info(f"Directorio temporal eliminado: {f}")
+                else:
+                    os.remove(f)
+                    logger.info(f"Archivo temporal eliminado: {f}")
         
-        video_paths = []
-        for url in video_urls:
-            path = download_video(url, temp_dir)
-            if path:
-                video_paths.append(path)
-        
-        if not video_paths:
-            return None, "❌ Error descargando videos"
-        
-        # 4. Crear video final
-        output_path = os.path.join(temp_dir, "final_video.mp4")
-        if not create_video(tts_path, video_paths, output_path):
-            return None, "❌ Error en la creación del video"
-        
-        return output_path, "✅ Video creado exitosamente"
-            
+        for clip in final_clips: 
+            if clip and hasattr(clip, 'close') and not clip.is_playing:
+                clip.close()
+        if 'audio_tts' in locals() and audio_tts and hasattr(audio_tts, 'close') and not audio_tts.is_playing:
+            audio_tts.close()
+        if 'musica_audio' in locals() and musica_audio and hasattr(musica_audio, 'close') and not musica_audio.is_playing:
+            musica_audio.close()
+        if 'video_final' in locals() and video_final and hasattr(video_final, 'close') and not video_final.is_playing:
+            video_final.close()
+        if 'video_base' in locals() and video_base and hasattr(video_base, 'close') and not video_base.is_playing:
+            video_base.close()
+
+
+def run_app(prompt_type, prompt_ia, prompt_manual, musica_url):
+    input_text = ""
+    if prompt_type == "Generar Guion con IA":
+        input_text = prompt_ia
+        if not input_text.strip():
+            raise gr.Error("Por favor, introduce un tema para generar el guion.")
+    else:
+        input_text = prompt_manual
+        if not input_text.strip():
+            raise gr.Error("Por favor, introduce tu guion.")
+
+    logger.info(f"Solicitud recibida: Tipo='{prompt_type}', Input='{input_text[:50]}...', Música='{musica_url}'")
+
+    try:
+        video_path = crear_video(prompt_type, input_text, musica_url if musica_url.strip() else None)
+        if video_path:
+            logger.info(f"Proceso completado. Video disponible en: {video_path}")
+            return video_path, gr.update(value="¡Video generado exitosamente!")
+        else:
+            raise gr.Error("Hubo un problema desconocido al generar el video. Revisa los logs.")
+    except ValueError as ve: 
+        logger.error(f"Error de validación o búsqueda de Pexels: {ve}")
+        return None, gr.update(value=f"Error: {ve}", text_color="red")
     except Exception as e:
-        logger.exception("Error inesperado")
-        return None, f"❌ Error crítico: {str(e)}"
-    finally:
-        # Espacios maneja la limpieza automática
-        pass
+        logger.error(f"Error inesperado al ejecutar la aplicación: {e}", exc_info=True)
+        return None, gr.update(value=f"Ocurrió un error grave: {e}. Por favor, inténtalo de nuevo.", text_color="red")
 
-# --- Interfaz de Gradio mejorada ---
-with gr.Blocks(title="Generador Automático de Videos", theme=gr.themes.Soft(), css=".gradio-container {max-width: 800px}") as demo:
+with gr.Blocks() as app:
     gr.Markdown("""
-    # 🎬 Generador Automático de Videos con IA
-    Transforma texto en videos usando contenido de Pexels y voz sintetizada
+    ### 🎬 Generador de Video Inteligente con Pexels 🚀
+    Crea videos con guiones generados por IA o propios, voz automática y **videos de stock relevantes de Pexels**.
     """)
     
-    with gr.Row():
-        with gr.Column(scale=2):
-            text_input = gr.Textbox(
-                label="Texto para el video",
-                placeholder="Ej: Un hermoso paisaje montañoso con ríos cristalinos...",
-                lines=5,
-                max_lines=10
+    with gr.Tab("Generar Video"):
+        with gr.Row():
+            prompt_type = gr.Radio(
+                ["Generar Guion con IA", "Usar Mi Guion"], 
+                label="Método de Guion", 
+                value="Generar Guion con IA"
             )
-            generate_btn = gr.Button("✨ Generar Video", variant="primary")
-            
-            with gr.Accordion("Configuración avanzada", open=False):
-                voice_select = gr.Dropdown(
-                    ["es-ES-ElviraNeural", "es-MX-DaliaNeural", "es-US-AlonsoNeural"],
-                    label="Voz",
-                    value="es-ES-ElviraNeural"
-                )
         
-        with gr.Column(scale=3):
-            video_output = gr.Video(
-                label="Video Generado", 
-                interactive=False,
-                height=400
+        with gr.Column(visible=True) as ia_guion_column:
+            prompt_ia = gr.Textbox(
+                label="Tema para Generar Guion (con IA)", 
+                lines=2, 
+                placeholder="Ej: Las maravillas del universo y las estrellas."
             )
-            status_output = gr.Textbox(
-                label="Estado",
-                interactive=False,
-                show_label=False,
-                container=False
+        
+        with gr.Column(visible=False) as manual_guion_column:
+            prompt_manual = gr.Textbox(
+                label="Introduce Tu Guion Propio", 
+                lines=5, 
+                placeholder="Ej: Hola a todos, hoy hablaremos de un tema fascinante..."
             )
-    
-    generate_btn.click(
-        fn=lambda: (None, "⏳ Procesando... Esto puede tomar 1-2 minutos"),
-        outputs=[video_output, status_output],
+        
+        musica_input = gr.Textbox(
+            label="URL de Música de Fondo (opcional, MP3 recomendado)", 
+            placeholder="Ej: https://www.soundhelix.com/examples/mp3/SoundHelix-Song-1.mp3"
+        )
+        
+        boton = gr.Button("✨ Generar Video")
+        
+        with gr.Column():
+            salida_video = gr.Video(label="Video Generado", interactive=False)
+            estado_mensaje = gr.Textbox(label="Estado del Proceso", interactive=False, value="")
+
+    prompt_type.change(
+        fn=lambda value: (gr.update(visible=value == "Generar Guion con IA"), 
+                          gr.update(visible=value == "Usar Mi Guion")),
+        inputs=prompt_type,
+        outputs=[ia_guion_column, manual_guion_column]
+    )
+
+    boton.click(
+        fn=lambda: (None, gr.update(value="Iniciando generación... Esto puede tardar varios minutos (descarga de videos).")),
+        outputs=[salida_video, estado_mensaje],
         queue=False
     ).then(
-        fn=generate_video,
-        inputs=[text_input],
-        outputs=[video_output, status_output]
-    )
-    
-    gr.Markdown("### Instrucciones:")
-    gr.Markdown("""
-    1. Describe el video que deseas crear (mínimo 20 palabras)
-    2. Haz clic en "Generar Video"
-    3. El sistema buscará videos relevantes en Pexels
-    4. Creará un video con narración automática
-    """)
-    
-    gr.Markdown("### Ejemplos:")
-    examples = gr.Examples(
-        examples=[
-            ["Un atardecer en la playa con palmeras y olas suaves"],
-            ["Un bosque otoñal con hojas de colores y senderos naturales"],
-            ["La ciudad de noche con rascacielos iluminados y tráfico"]
-        ],
-        inputs=[text_input],
-        label="Ejemplos para probar"
+        fn=run_app,
+        inputs=[prompt_type, prompt_ia, prompt_manual, musica_input],
+        outputs=[salida_video, estado_mensaje]
     )
 
-# Para Hugging Face Spaces
+    prompt_ia.change(fn=lambda: gr.update(value=""), outputs=estado_mensaje, queue=False)
+    prompt_manual.change(fn=lambda: gr.update(value=""), outputs=estado_mensaje, queue=False)
+    musica_input.change(fn=lambda: gr.update(value=""), outputs=estado_mensaje, queue=False)
+    
 if __name__ == "__main__":
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False,
-        show_error=True
-    )
+    logger.info("Iniciando aplicación Gradio para Hugging Face Spaces...")
+    app.launch(server_name="0.0.0.0", server_port=7860, share=False)