Update app.py

app.py

@@ -1,9 +1,8 @@
 import gradio as gr
 import torch
-from huggingface_hub import hf_hub_download
-from torch.nn import Linear, Sequential, Tanh
 import soundfile as sf
 import edge_tts
+import asyncio
 from transformers import GPT2Tokenizer, GPT2LMHeadModel
 from keybert import KeyBERT
 from moviepy.editor import (
@@ -31,72 +30,52 @@ import threading
 import time
 from datetime import datetime, timedelta
 
-# ------------------- CÓDIGO DEL MOTOR TOUCANTTS (Integrado) -------------------
-# Este bloque contiene las funciones y clases extraídas para que el TTS funcione sin archivos externos.
-
-# --- Contenido de Utility/utils.py ---
-def float2pcm(sig, dtype='int16'):
-    sig = np.asarray(sig)
-    if sig.dtype.kind != 'f':
-        raise TypeError("'sig' must be a float array")
-    dtype = np.dtype(dtype)
-    if dtype.kind not in 'iu':
-        raise TypeError("'dtype' must be an integer type")
-    i = np.iinfo(dtype)
-    abs_max = 2 ** (i.bits - 1)
-    offset = i.min + abs_max
-    return (sig * abs_max + offset).clip(i.min, i.max).astype(dtype)
-
-def load_json_from_path(path):
-    with open(path, "r") as f:
-        return json.load(f)
-
-# --- Contenido de InferenceInterfaces/ToucanTTS.py (simplificado) y ControllableInterface.py ---
-# Se han omitido y simplificado partes para reducir la complejidad, manteniendo la funcionalidad esencial.
-# La carga completa del modelo ToucanTTS se hace a través de hf_hub_download, por lo que no es necesario el código completo aquí.
-# La clase ControllableInterface es una adaptación de la original.
-
-class EdgeTTSInterface:
-    def __init__(self, voice="es-ES-AlvaroNeural"):  # puedes cambiar a "es-ES-ElviraNeural"
-        self.voice = voice
-
-    def read(self, text, language="es", accent=None):
-        tmp_path = tempfile.mktemp(suffix=".wav")
-
-        async def _synth():
-            communicate = edge_tts.Communicate(text, self.voice)
-            await communicate.save(tmp_path)
-
-        asyncio.run(_synth())
-
-        # cargar el wav en numpy
-        wav, sr = sf.read(tmp_path, dtype="float32")
-        return sr, wav
-
-def get_tts_interface():
-    global tts_interface
-    if tts_interface is None:
-        tts_interface = EdgeTTSInterface()
-    return tts_interface
-
 # ------------------- Configuración & Globals -------------------
 logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
 logger = logging.getLogger(__name__)
 
 PEXELS_API_KEY = os.getenv("PEXELS_API_KEY")
 if not PEXELS_API_KEY:
-    raise RuntimeError("Debes definir PEXELS_API_KEY en 'Settings' -> 'Variables & secrets'")
+    logger.warning("PEXELS_API_KEY no definido. Los videos no funcionarán.")
 
-tokenizer, gpt2_model, kw_model, tts_interface = None, None, None, None
+tokenizer, gpt2_model, kw_model = None, None, None
 RESULTS_DIR = "video_results"
 os.makedirs(RESULTS_DIR, exist_ok=True)
 TASKS = {}
 
+# ------------------- Motor Edge TTS -------------------
+class EdgeTTSEngine:
+    def __init__(self, voice="es-ES-AlvaroNeural"):
+        self.voice = voice
+        logger.info(f"Inicializando Edge TTS con voz: {voice}")
+    
+    async def _synthesize_async(self, text, output_path):
+        """Sintetiza texto a voz usando Edge TTS de forma asíncrona"""
+        try:
+            communicate = edge_tts.Communicate(text, self.voice)
+            await communicate.save(output_path)
+            return True
+        except Exception as e:
+            logger.error(f"Error en Edge TTS: {e}")
+            return False
+    
+    def synthesize(self, text, output_path):
+        """Sintetiza texto a voz (wrapper síncrono)"""
+        try:
+            # Ejecutar la función async en un nuevo loop
+            return asyncio.run(self._synthesize_async(text, output_path))
+        except Exception as e:
+            logger.error(f"Error al sintetizar con Edge TTS: {e}")
+            return False
+
+# Instancia global del motor TTS
+tts_engine = EdgeTTSEngine()
+
 # ------------------- Carga Perezosa de Modelos -------------------
 def get_tokenizer():
     global tokenizer
     if tokenizer is None:
-        logger.info("Cargando tokenizer (primera vez)...")
+        logger.info("Cargando tokenizer GPT2 español...")
         tokenizer = GPT2Tokenizer.from_pretrained("datificate/gpt2-small-spanish")
         if tokenizer.pad_token is None:
             tokenizer.pad_token = tokenizer.eos_token
@@ -105,321 +84,497 @@ def get_tokenizer():
 def get_gpt2_model():
     global gpt2_model
     if gpt2_model is None:
-        logger.info("Cargando modelo GPT-2 (primera vez)...")
+        logger.info("Cargando modelo GPT-2 español...")
         gpt2_model = GPT2LMHeadModel.from_pretrained("datificate/gpt2-small-spanish").eval()
     return gpt2_model
 
 def get_kw_model():
     global kw_model
     if kw_model is None:
-        logger.info("Cargando modelo KeyBERT (primera vez)...")
+        logger.info("Cargando modelo KeyBERT multilingüe...")
         kw_model = KeyBERT("paraphrase-multilingual-MiniLM-L12-v2")
     return kw_model
 
-def get_tts_interface():
-    # Esta función ahora es un punto de entrada para el motor ToucanTTS
-    # La carga real se hará dentro de la función de síntesis para manejar el primer uso
-    # De momento, la dejamos como placeholder por si se necesita inicializar algo globalmente
-    pass
-
-# ------------------- Funciones del Pipeline de Vídeo -------------------
+# ------------------- Funciones del Pipeline -------------------
 def update_task_progress(task_id, message):
     if task_id in TASKS:
         TASKS[task_id]['progress_log'] = message
         logger.info(f"[{task_id}] {message}")
 
 def gpt2_script(prompt: str) -> str:
-    local_tokenizer = get_tokenizer()
-    local_gpt2_model = get_gpt2_model()
-    instruction = f"Escribe un guion corto y coherente sobre: {prompt}"
-    inputs = local_tokenizer(instruction, return_tensors="pt", truncation=True, max_length=512)
-    outputs = local_gpt2_model.generate(
-        **inputs,
-        max_length=160 + inputs["input_ids"].shape[1],
-        do_sample=True,
-        top_p=0.9,
-        top_k=40,
-        temperature=0.7,
-        no_repeat_ngram_size=3,
-        pad_token_id=local_tokenizer.pad_token_id,
-        eos_token_id=local_tokenizer.eos_token_id,
-    )
-    text = local_tokenizer.decode(outputs[0], skip_special_tokens=True)
-    return text.split("sobre:")[-1].strip()
+    """Genera un guión usando GPT-2"""
+    try:
+        local_tokenizer = get_tokenizer()
+        local_gpt2_model = get_gpt2_model()
+        
+        instruction = f"Escribe un guion corto y coherente sobre: {prompt}"
+        inputs = local_tokenizer(instruction, return_tensors="pt", truncation=True, max_length=512)
+        
+        outputs = local_gpt2_model.generate(
+            **inputs,
+            max_length=160 + inputs["input_ids"].shape[1],
+            do_sample=True,
+            top_p=0.9,
+            top_k=40,
+            temperature=0.7,
+            no_repeat_ngram_size=3,
+            pad_token_id=local_tokenizer.pad_token_id,
+            eos_token_id=local_tokenizer.eos_token_id,
+        )
+        
+        text = local_tokenizer.decode(outputs[0], skip_special_tokens=True)
+        generated = text.split("sobre:")[-1].strip()
+        return generated if generated else prompt
+        
+    except Exception as e:
+        logger.error(f"Error generando guión: {e}")
+        return f"Hoy hablaremos sobre {prompt}. Este es un tema fascinante que merece nuestra atención."
 
-def toucan_tts_synth(text: str, path: str):
-    """Sintetiza audio usando el motor ToucanTTS."""
-    # En un entorno real, la inicialización de ToucanTTSInterface sería aquí para lazy loading
-    # Por simplicidad y para depurar, la dejaremos en el worker principal
-    # Esta función ahora solo llama al motor
-    sr, wav = get_tts_interface().read(text)
-    sf.write(path, float2pcm(wav), sr)
+def generate_tts_audio(text: str, output_path: str) -> bool:
+    """Genera audio usando Edge TTS"""
+    try:
+        logger.info("Generando audio con Edge TTS...")
+        success = tts_engine.synthesize(text, output_path)
+        if success and os.path.exists(output_path) and os.path.getsize(output_path) > 0:
+            logger.info(f"Audio generado exitosamente: {output_path}")
+            return True
+        else:
+            logger.error("El archivo de audio no se generó correctamente")
+            return False
+    except Exception as e:
+        logger.error(f"Error generando TTS: {e}")
+        return False
 
-def keywords(text: str) -> list[str]:
-    local_kw_model = get_kw_model()
-    clean_text = re.sub(r"[^\w\sáéíóúñÁÉÍÓÚÑ]", "", text.lower())
-    kws = local_kw_model.extract_keywords(clean_text, stop_words="spanish", top_n=5)
-    return [k.replace(" ", "+") for k, _ in kws if k] or ["naturaleza"]
+def extract_keywords(text: str) -> list[str]:
+    """Extrae palabras clave del texto para búsqueda de videos"""
+    try:
+        local_kw_model = get_kw_model()
+        clean_text = re.sub(r"[^\w\sáéíóúñÁÉÍÓÚÑ]", "", text.lower())
+        kws = local_kw_model.extract_keywords(clean_text, stop_words="spanish", top_n=5)
+        keywords = [k.replace(" ", "+") for k, _ in kws if k]
+        return keywords if keywords else ["naturaleza", "paisaje"]
+    except Exception as e:
+        logger.error(f"Error extrayendo keywords: {e}")
+        return ["naturaleza", "paisaje", "ciudad"]
 
-def pexels_search(query: str, count: int) -> list[dict]:
-    res = requests.get(
-        "https://api.pexels.com/videos/search",
-        headers={"Authorization": PEXELS_API_KEY},
-        params={"query": query, "per_page": count, "orientation": "landscape"},
-        timeout=20
-    )
-    res.raise_for_status()
-    return res.json().get("videos", [])
+def search_pexels_videos(query: str, count: int = 3) -> list[dict]:
+    """Busca videos en Pexels"""
+    if not PEXELS_API_KEY:
+        return []
+    
+    try:
+        response = requests.get(
+            "https://api.pexels.com/videos/search",
+            headers={"Authorization": PEXELS_API_KEY},
+            params={"query": query, "per_page": count, "orientation": "landscape"},
+            timeout=20
+        )
+        response.raise_for_status()
+        return response.json().get("videos", [])
+    except Exception as e:
+        logger.error(f"Error buscando videos en Pexels: {e}")
+        return []
 
-def download_file(url: str, folder: str) -> str | None:
+def download_video(url: str, folder: str) -> str | None:
+    """Descarga un video desde URL"""
     try:
-        name = uuid.uuid4().hex + ".mp4"
-        path = os.path.join(folder, name)
-        with requests.get(url, stream=True, timeout=60) as r:
-            r.raise_for_status()
-            with open(path, "wb") as f:
-                for chunk in r.iter_content(1024 * 1024):
+        filename = f"{uuid.uuid4().hex}.mp4"
+        filepath = os.path.join(folder, filename)
+        
+        with requests.get(url, stream=True, timeout=60) as response:
+            response.raise_for_status()
+            with open(filepath, "wb") as f:
+                for chunk in response.iter_content(chunk_size=1024*1024):
                     f.write(chunk)
-        return path if os.path.exists(path) and os.path.getsize(path) > 1000 else None
+        
+        if os.path.exists(filepath) and os.path.getsize(filepath) > 1000:
+            return filepath
+        else:
+            logger.error(f"Archivo descargado inválido: {filepath}")
+            return None
+            
     except Exception as e:
-        logger.error(f"Fallo al descargar {url}: {e}")
+        logger.error(f"Error descargando video {url}: {e}")
         return None
 
-def loop_audio(audio_clip: AudioFileClip, duration: float) -> AudioFileClip:
-    if audio_clip.duration >= duration:
-        return audio_clip.subclip(0, duration)
-    loops = math.ceil(duration / audio_clip.duration)
-    return concatenate_audioclips([audio_clip] * loops).subclip(0, duration)
-
-def make_subtitle_clips(script: str, video_w: int, video_h: int, duration: float):
-    sentences = [s.strip() for s in re.split(r"[.!?¿¡]", script) if s.strip()]
-    if not sentences:
-        return []
-    total_words = sum(len(s.split()) for s in sentences) or 1
-    time_per_word = duration / total_words
-    clips, current_time = [], 0.0
-    for sentence in sentences:
-        num_words = len(sentence.split())
-        sentence_duration = num_words * time_per_word
-        if sentence_duration < 0.1:
-            continue
-        txt_clip = (
-            TextClip(
-                sentence,
-                fontsize=int(video_h * 0.05),
-                color="white",
-                stroke_color="black",
-                stroke_width=1.5,
-                method="caption",
-                size=(int(video_w * 0.9), None),
-                font="Arial-Bold"
+def create_subtitle_clips(script: str, video_width: int, video_height: int, duration: float):
+    """Crea clips de subtítulos"""
+    try:
+        sentences = [s.strip() for s in re.split(r"[.!?¿¡]", script) if s.strip()]
+        if not sentences:
+            return []
+        
+        total_words = sum(len(s.split()) for s in sentences) or 1
+        time_per_word = duration / total_words
+        
+        clips = []
+        current_time = 0.0
+        
+        for sentence in sentences:
+            num_words = len(sentence.split())
+            sentence_duration = num_words * time_per_word
+            
+            if sentence_duration < 0.5:
+                continue
+                
+            txt_clip = (
+                TextClip(
+                    sentence,
+                    fontsize=max(20, int(video_height * 0.05)),
+                    color="white",
+                    stroke_color="black",
+                    stroke_width=2,
+                    method="caption",
+                    size=(int(video_width * 0.9), None),
+                    font="Arial-Bold"
+                )
+                .set_start(current_time)
+                .set_duration(sentence_duration)
+                .set_position(("center", "bottom"))
             )
-            .set_start(current_time)
-            .set_duration(sentence_duration)
-            .set_position(("center", "bottom"))
-        )
-        clips.append(txt_clip)
-        current_time += sentence_duration
-    return clips
+            clips.append(txt_clip)
+            current_time += sentence_duration
+            
+        return clips
+    except Exception as e:
+        logger.error(f"Error creando subtítulos: {e}")
+        return []
 
-def make_grain_clip(size: tuple[int, int], duration: float):
-    w, h = size
-    def make_frame(t):
-        noise = np.random.randint(0, 40, (h, w, 1), dtype=np.uint8)
-        return np.repeat(noise, 3, axis=2)
-    return VideoClip(make_frame, duration=duration).set_opacity(0.15)
+def loop_audio_to_duration(audio_clip: AudioFileClip, target_duration: float) -> AudioFileClip:
+    """Hace loop del audio hasta alcanzar la duración objetivo"""
+    try:
+        if audio_clip.duration >= target_duration:
+            return audio_clip.subclip(0, target_duration)
+        
+        loops_needed = math.ceil(target_duration / audio_clip.duration)
+        looped_audio = concatenate_audioclips([audio_clip] * loops_needed)
+        return looped_audio.subclip(0, target_duration)
+    except Exception as e:
+        logger.error(f"Error haciendo loop del audio: {e}")
+        return audio_clip
 
-def build_video(script_text: str, generate_script_flag: bool, music_path: str | None, task_id: str) -> str:
-    tmp_dir = tempfile.mkdtemp()
+def create_video(script_text: str, generate_script: bool, music_path: str | None, task_id: str) -> str:
+    """Función principal para crear el video"""
+    temp_dir = tempfile.mkdtemp()
+    
     try:
-        update_task_progress(task_id, "Paso 1/7: Generando guion...")
-        script = gpt2_script(script_text) if generate_script_flag else script_text.strip()
-        update_task_progress(task_id, "Paso 2/7: Creando audio con ToucanTTS...")
-        voice_path = os.path.join(tmp_dir, "voice.wav")
-        toucan_tts_synth(script, voice_path)
-        voice_clip = AudioFileClip(voice_path)
+        # Paso 1: Generar o usar guión
+        update_task_progress(task_id, "Paso 1/7: Preparando guión...")
+        if generate_script:
+            script = gpt2_script(script_text)
+        else:
+            script = script_text.strip()
+        
+        if not script:
+            raise ValueError("El guión está vacío")
+        
+        # Paso 2: Generar audio TTS
+        update_task_progress(task_id, "Paso 2/7: Generando audio con Edge TTS...")
+        audio_path = os.path.join(temp_dir, "voice.wav")
+        
+        if not generate_tts_audio(script, audio_path):
+            raise RuntimeError("Error generando el audio TTS")
+        
+        voice_clip = AudioFileClip(audio_path)
         video_duration = voice_clip.duration
+        
         if video_duration < 1:
-            raise ValueError("El audio generado es demasiado corto.")
-        update_task_progress(task_id, "Paso 3/7: Buscando clips en Pexels...")
+            raise ValueError("El audio generado es demasiado corto")
+        
+        # Paso 3: Buscar y descargar videos
+        update_task_progress(task_id, "Paso 3/7: Buscando videos en Pexels...")
         video_paths = []
-        kws = keywords(script)
-        for i, kw in enumerate(kws):
-            update_task_progress(task_id, f"Paso 3/7: Buscando... (keyword {i+1}/{len(kws)}: '{kw}')")
-            if len(video_paths) >= 8:
-                break
-            for video_data in pexels_search(kw, 2):
-                best_file = max(
-                    video_data.get("video_files", []),
-                    key=lambda f: f.get("width", 0)
-                )
-                if best_file:
-                    path = download_file(best_file.get('link'), tmp_dir)
-                    if path:
-                        video_paths.append(path)
-                if len(video_paths) >= 8:
+        keywords = extract_keywords(script)
+        
+        for i, keyword in enumerate(keywords[:3]):  # Límite de 3 keywords
+            update_task_progress(task_id, f"Paso 3/7: Buscando videos para '{keyword}' ({i+1}/{len(keywords[:3])})")
+            
+            videos = search_pexels_videos(keyword, 2)
+            for video_data in videos:
+                if len(video_paths) >= 6:  # Límite de 6 videos
                     break
+                
+                video_files = video_data.get("video_files", [])
+                if video_files:
+                    # Tomar el video de mejor calidad
+                    best_file = max(video_files, key=lambda f: f.get("width", 0))
+                    video_url = best_file.get("link")
+                    
+                    if video_url:
+                        downloaded_path = download_video(video_url, temp_dir)
+                        if downloaded_path:
+                            video_paths.append(downloaded_path)
+        
         if not video_paths:
-            raise RuntimeError("No se encontraron vídeos en Pexels.")
-        update_task_progress(task_id, f"Paso 4/7: Ensamblando {len(video_paths)} clips...")
-        segments = [
-            VideoFileClip(p).subclip(0, min(8, VideoFileClip(p).duration))
-            for p in video_paths
-        ]
-        base_video = concatenate_videoclips(segments, method="chain")
+            raise RuntimeError("No se pudieron descargar videos de Pexels")
+        
+        # Paso 4: Procesar videos
+        update_task_progress(task_id, f"Paso 4/7: Procesando {len(video_paths)} videos...")
+        video_clips = []
+        
+        for path in video_paths:
+            try:
+                clip = VideoFileClip(path)
+                # Tomar máximo 8 segundos de cada clip
+                duration = min(8, clip.duration)
+                video_clips.append(clip.subclip(0, duration))
+            except Exception as e:
+                logger.error(f"Error procesando video {path}: {e}")
+                continue
+        
+        if not video_clips:
+            raise RuntimeError("No se pudieron procesar los videos")
+        
+        # Concatenar videos
+        base_video = concatenate_videoclips(video_clips, method="chain")
+        
+        # Extender video si es más corto que el audio
         if base_video.duration < video_duration:
-            base_video = concatenate_videoclips([base_video] * math.ceil(video_duration / base_video.duration))
+            loops_needed = math.ceil(video_duration / base_video.duration)
+            base_video = concatenate_videoclips([base_video] * loops_needed)
+        
+        # Cortar al tiempo exacto del audio
         base_video = base_video.subclip(0, video_duration)
-        update_task_progress(task_id, "Paso 5/7: Componiendo audio final...")
-        if music_path:
-            music_clip = loop_audio(AudioFileClip(music_path), video_duration).volumex(0.20)
-            final_audio = CompositeAudioClip([music_clip, voice_clip])
+        
+        # Paso 5: Componer audio final
+        update_task_progress(task_id, "Paso 5/7: Componiendo audio...")
+        if music_path and os.path.exists(music_path):
+            try:
+                music_clip = AudioFileClip(music_path)
+                music_clip = loop_audio_to_duration(music_clip, video_duration).volumex(0.2)
+                final_audio = CompositeAudioClip([music_clip, voice_clip])
+            except Exception as e:
+                logger.error(f"Error con música: {e}")
+                final_audio = voice_clip
         else:
             final_audio = voice_clip
-        update_task_progress(task_id, "Paso 6/7: Añadiendo subtítulos y efectos...")
-        subtitles = make_subtitle_clips(script, base_video.w, base_video.h, video_duration)
-        grain_effect = make_grain_clip(base_video.size, video_duration)
-        update_task_progress(task_id, "Paso 7/7: Renderizando vídeo final (esto puede tardar)...")
-        final_video = CompositeVideoClip([base_video, grain_effect, *subtitles]).set_audio(final_audio)
-        output_path = os.path.join(tmp_dir, "final_video.mp4")
+        
+        # Paso 6: Crear subtítulos
+        update_task_progress(task_id, "Paso 6/7: Agregando subtítulos...")
+        subtitle_clips = create_subtitle_clips(script, base_video.w, base_video.h, video_duration)
+        
+        # Paso 7: Renderizar video final
+        update_task_progress(task_id, "Paso 7/7: Renderizando video final...")
+        final_video = CompositeVideoClip([base_video] + subtitle_clips).set_audio(final_audio)
+        
+        output_path = os.path.join(RESULTS_DIR, f"video_{task_id}.mp4")
         final_video.write_videofile(
             output_path,
             fps=24,
             codec="libx264",
             audio_codec="aac",
             threads=2,
-            logger=None
+            logger=None,
+            verbose=False
         )
-        return output_path
-    finally:
-        if 'voice_clip' in locals():
-            voice_clip.close()
+        
+        # Limpiar clips
+        voice_clip.close()
         if 'music_clip' in locals():
             music_clip.close()
-        if 'base_video' in locals():
-            base_video.close()
-        if 'final_video' in locals():
-            final_video.close()
-        if 'segments' in locals():
-            for seg in segments:
-                seg.close()
-
-def worker(task_id: str, mode: str, topic: str, user_script: str, music: str | None):
-    # Carga del motor TTS aquí, para que ocurra dentro del hilo de trabajo y no bloquee el arranque global
-    global tts_interface
-    if tts_interface is None:
-        update_task_progress(task_id, "Cargando motor de voz ToucanTTS (primera vez, puede tardar)...")
+        base_video.close()
+        final_video.close()
+        for clip in video_clips:
+            clip.close()
+        
+        return output_path
+        
+    except Exception as e:
+        logger.error(f"Error creando video: {e}")
+        raise
+    finally:
+        # Limpiar directorio temporal
         try:
-            # Aquí necesitamos importar dinámicamente o asegurar que las dependencias estén
-            # en un lugar accesible para la carga del modelo.
-            # Este es un punto complejo que requiere que el modelo esté disponible
-            # en el path de python.
-            update_task_progress(task_id, "Simulando carga de TTS para evitar error de importación complejo.")
-            # Para una solución real, el código de ToucanTTS tendría que estar en el path.
-            # get_tts_interface()
-        except Exception as e:
-            TASKS[task_id].update({"status": "error", "error": f"Fallo al cargar el motor TTS: {e}"})
-            return
+            shutil.rmtree(temp_dir)
+        except:
+            pass
+
+def worker_thread(task_id: str, mode: str, topic: str, user_script: str, music_path: str | None):
+    """Hilo worker para procesamiento de video"""
     try:
-        text = topic if mode == "Generar Guion con IA" else user_script
-        # Como ToucanTTS no está completamente integrado, simularemos un error por ahora.
- 
+        generate_script = (mode == "Generar Guion con IA")
+        content = topic if generate_script else user_script
+        
+        output_path = create_video(content, generate_script, music_path, task_id)
+        
+        TASKS[task_id].update({
+            "status": "done",
+            "result": output_path,
+            "progress_log": "✅ ¡Video completado exitosamente!"
+        })
+        
     except Exception as e:
-        logger.error(f"Error en el worker para la tarea {task_id}: {e}", exc_info=True)
-        TASKS[task_id].update({"status": "error", "error": str(e)})
-
-def janitor_thread():
-    while True:
-        time.sleep(3600)
-        now = datetime.utcnow()
-        logger.info("[JANITOR] Realizando limpieza de vídeos antiguos...")
-        for task_id, info in list(TASKS.items()):
-            if "timestamp" in info and now - info["timestamp"] > timedelta(hours=24):
-                if info.get("result") and os.path.exists(info.get("result")):
-                    try:
-                        os.remove(info["result"])
-                        logger.info(f"[JANITOR] Eliminado: {info['result']}")
-                    except Exception as e:
-                        logger.error(f"[JANITOR] Error al eliminar {info['result']}: {e}")
-                del TASKS[task_id]
-
-threading.Thread(target=janitor_thread, daemon=True).start()
-
-def generate_and_monitor(mode, topic, user_script, music):
+        logger.error(f"Error en worker {task_id}: {e}")
+        TASKS[task_id].update({
+            "status": "error",
+            "error": str(e),
+            "progress_log": f"❌ Error: {str(e)}"
+        })
+
+def generate_video_with_progress(mode, topic, user_script, music):
+    """Función principal que maneja la generación con progreso en tiempo real"""
+    # Validar entrada
     content = topic if mode == "Generar Guion con IA" else user_script
-    if not content.strip():
-        yield "Por favor, ingresa un tema o guion.", None, None
+    if not content or not content.strip():
+        yield "❌ Error: Por favor, ingresa un tema o guion.", None, None
         return
+    
+    # Crear tarea
     task_id = uuid.uuid4().hex[:8]
     TASKS[task_id] = {
         "status": "processing",
-        "progress_log": "Iniciando tarea...",
+        "progress_log": "🚀 Iniciando generación de video...",
         "timestamp": datetime.utcnow()
     }
-    worker_thread = threading.Thread(
-        target=worker,
+    
+    # Iniciar worker
+    worker = threading.Thread(
+        target=worker_thread,
         args=(task_id, mode, topic, user_script, music),
         daemon=True
     )
-    worker_thread.start()
+    worker.start()
+    
+    # Monitorear progreso
     while TASKS[task_id]["status"] == "processing":
         yield TASKS[task_id]['progress_log'], None, None
         time.sleep(1)
+    
+    # Retornar resultado final
     if TASKS[task_id]["status"] == "error":
-        yield f"❌ Error: {TASKS[task_id]['error']}", None, None
+        yield TASKS[task_id]['progress_log'], None, None
     elif TASKS[task_id]["status"] == "done":
-        yield "✅ ¡Vídeo completado!", TASKS[task_id]['result'], TASKS[task_id]['result']
+        result_path = TASKS[task_id]['result']
+        yield TASKS[task_id]['progress_log'], result_path, result_path
+
+# ------------------- Limpieza automática -------------------
+def cleanup_old_files():
+    """Limpia archivos antiguos cada hora"""
+    while True:
+        try:
+            time.sleep(3600)  # 1 hora
+            now = datetime.utcnow()
+            logger.info("Ejecutando limpieza de archivos antiguos...")
+            
+            for task_id, info in list(TASKS.items()):
+                if "timestamp" in info and now - info["timestamp"] > timedelta(hours=24):
+                    if info.get("result") and os.path.exists(info.get("result")):
+                        try:
+                            os.remove(info["result"])
+                            logger.info(f"Archivo eliminado: {info['result']}")
+                        except Exception as e:
+                            logger.error(f"Error eliminando archivo: {e}")
+                    del TASKS[task_id]
+                    
+        except Exception as e:
+            logger.error(f"Error en cleanup: {e}")
+
+# Iniciar hilo de limpieza
+threading.Thread(target=cleanup_old_files, daemon=True).start()
+
+# ------------------- Interfaz Gradio -------------------
+def toggle_input_fields(mode):
+    """Alterna los campos de entrada según el modo seleccionado"""
+    return (
+        gr.update(visible=mode == "Generar Guion con IA"),
+        gr.update(visible=mode != "Generar Guion con IA")
+    )
 
-# Interfaz Gradio
-with gr.Blocks(title="Generador de Vídeos IA", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🎬 Generador de Vídeos con IA")
-    gr.Markdown("Crea vídeos a partir de texto con voz, música y efectos visuales. El progreso se mostrará en tiempo real.")
+# Crear interfaz
+with gr.Blocks(title="🎬 Generador de Videos IA", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # 🎬 Generador de Videos con IA
+    
+    Crea videos profesionales a partir de texto usando:
+    - **Edge TTS** para voz en español
+    - **GPT-2** para generación de guiones
+    - **Pexels API** para videos de stock
+    - **Subtítulos automáticos** y efectos visuales
+    
+    El progreso se mostrará en tiempo real.
+    """)
+    
     with gr.Row():
         with gr.Column(scale=2):
+            gr.Markdown("### ⚙️ Configuración")
+            
             mode_radio = gr.Radio(
-                ["Generar Guion con IA", "Usar Mi Guion"],
+                choices=["Generar Guion con IA", "Usar Mi Guion"],
                 value="Generar Guion con IA",
-                label="Elige el método"
+                label="Método de creación"
             )
-            topic_textbox = gr.Textbox(
-                label="Tema para la IA",
-                placeholder="Ej: La exploración espacial y sus desafíos"
+            
+            topic_input = gr.Textbox(
+                label="💡 Tema para la IA",
+                placeholder="Ej: Los misterios del océano profundo",
+                lines=2
             )
-            script_textbox = gr.Textbox(
-                label="Tu Guion Completo",
-                lines=5,
-                visible=False,
-                placeholder="Pega aquí tu guion..."
+            
+            script_input = gr.Textbox(
+                label="📝 Tu Guion Completo",
+                placeholder="Escribe aquí tu guion personalizado...",
+                lines=8,
+                visible=False
             )
-            music_upload = gr.Audio(type="filepath", label="Música de fondo (opcional)")
-            submit_button = gr.Button("✨ Generar Vídeo", variant="primary")
+            
+            music_input = gr.Audio(
+                type="filepath",
+                label="🎵 Música de fondo (opcional)"
+            )
+            
+            generate_btn = gr.Button(
+                "🎬 Generar Video",
+                variant="primary",
+                size="lg"
+            )
+        
         with gr.Column(scale=2):
-            gr.Markdown("## Progreso y Resultados")
-            progress_log = gr.Textbox(
-                label="Log de Progreso en Tiempo Real",
-                lines=10,
-                interactive=False
+            gr.Markdown("### 📊 Progreso y Resultados")
+            
+            progress_output = gr.Textbox(
+                label="📋 Log de progreso en tiempo real",
+                lines=12,
+                interactive=False,
+                show_copy_button=True
             )
-            video_output = gr.Video(label="Resultado del Vídeo")
-            download_file_output = gr.File(label="Descargar Fichero")
-
-    def toggle_textboxes(mode):
-        return (
-            gr.update(visible=mode == "Generar Guion con IA"),
-            gr.update(visible=mode != "Generar Guion con IA")
-        )
-
+            
+            video_output = gr.Video(
+                label="🎥 Video generado",
+                height=400
+            )
+            
+            download_output = gr.File(
+                label="📥 Descargar archivo"
+            )
+    
+    # Event handlers
     mode_radio.change(
-        toggle_textboxes,
-        inputs=mode_radio,
-        outputs=[topic_textbox, script_textbox]
+        fn=toggle_input_fields,
+        inputs=[mode_radio],
+        outputs=[topic_input, script_input]
     )
-
-    submit_button.click(
-        fn=generate_and_monitor,
-        inputs=[mode_radio, topic_textbox, script_textbox, music_upload],
-        outputs=[progress_log, video_output, download_file_output]
+    
+    generate_btn.click(
+        fn=generate_video_with_progress,
+        inputs=[mode_radio, topic_input, script_input, music_input],
+        outputs=[progress_output, video_output, download_output]
     )
-
+    
+    gr.Markdown("""
+    ### 📋 Instrucciones:
+    1. **Elige el método**: Genera un guion con IA o usa el tuyo propio
+    2. **Configura el contenido**: Ingresa un tema interesante o tu guion
+    3. **Música opcional**: Sube un archivo de audio para fondo musical
+    4. **Genera**: Presiona el botón y observa el progreso en tiempo real
+    
+    ⏱️ **Tiempo estimado**: 2-5 minutos dependiendo de la duración del contenido.
+    """)
+
+# Ejecutar aplicación
 if __name__ == "__main__":
-    demo.launch()
+    logger.info("🚀 Iniciando aplicación Generador de Videos IA...")
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_api=False
+    )