Update app.py

app.py

@@ -1,245 +1,228 @@
 import os
 import re
 import random
-import requests
-import gradio as gr
-from moviepy.editor import VideoFileClip, concatenate_videoclips, AudioFileClip, CompositeAudioClip
-from moviepy.audio.fx.all import audio_loop
-import edge_tts
-import asyncio
+import time
+import logging
+from typing import Optional, List
 from datetime import datetime
 from pathlib import Path
-from transformers import pipeline
-from sentence_transformers import SentenceTransformer
-from sklearn.metrics.pairwise import cosine_similarity
-import numpy as np
-import logging
-from typing import List, Optional, Tuple
 
-# Configure logging
+# Configuración inicial para HF Spaces
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+os.environ["GRADIO_ANALYTICS_ENABLED"] = "false"
+os.environ["HF_HUB_DISABLE_PROGRESS_BARS"] = "1"
+
+# Configuración de logging
 logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
 logger = logging.getLogger(__name__)
 
-# Configuración de modelos de IA
-PEXELS_API_KEY = os.getenv("PEXELS_API_KEY")
-if not PEXELS_API_KEY:
-    logger.error("PEXELS_API_KEY no encontrada en variables de entorno")
-
-# Cargamos modelos de IA para análisis semántico
-logger.info("Cargando modelos de IA...")
 try:
-    # Modelo para generación de texto
-    text_generator = pipeline("text-generation", model="facebook/mbart-large-50", device="cpu")
-    
-    # Modelo para embeddings semánticos (para matching de videos)
-    semantic_model = SentenceTransformer('sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2')
-    logger.info("Modelos de IA cargados exitosamente")
-except Exception as e:
-    logger.error(f"Error cargando modelos de IA: {e}")
+    import requests
+    from moviepy.editor import VideoFileClip, concatenate_videoclips, AudioFileClip, CompositeAudioClip
+    from moviepy.audio.fx.all import audio_loop
+    import edge_tts
+    import gradio as gr
+    import numpy as np
+    from transformers import pipeline
+    import backoff
+except ImportError as e:
+    logger.error(f"Error importing dependencies: {e}")
     raise
 
-# Sistema mejorado de búsqueda semántica
-def fetch_semantic_videos(query: str, script: str, num_videos: int = 5) -> List[Tuple[str, float]]:
-    """Busca videos en Pexels usando matching semántico con el script"""
-    logger.info(f"Buscando videos semánticos para: '{query}'")
-    
-    # Generar embedding del script completo
-    script_embedding = semantic_model.encode(script, convert_to_tensor=True)
-    
-    headers = {"Authorization": PEXELS_API_KEY}
-    url = f"https://api.pexels.com/videos/search?query={query}&per_page={num_videos*2}"  # Buscamos más para filtrar
-    
+# Constantes configurables
+MAX_VIDEOS = 3  # Reducir para evitar rate limiting
+VIDEO_SEGMENT_DURATION = 5  # Duración de cada segmento en segundos
+MAX_RETRIES = 3  # Máximo de reintentos para descargas
+REQUEST_TIMEOUT = 15  # Timeout para requests
+
+# Configuración de modelos
+MODEL_NAME = "facebook/mbart-large-50"
+PEXELS_API_KEY = os.getenv("PEXELS_API_KEY", "")
+
+@backoff.on_exception(backoff.expo,
+                    (requests.exceptions.RequestException, 
+                     requests.exceptions.HTTPError),
+                    max_tries=MAX_RETRIES,
+                    max_time=30)
+def safe_download(url: str, timeout: int = REQUEST_TIMEOUT) -> Optional[str]:
+    """Descarga segura con reintentos y manejo de rate limiting"""
     try:
-        response = requests.get(url, headers=headers, timeout=15)
+        response = requests.get(url, stream=True, timeout=timeout)
         response.raise_for_status()
         
-        videos_data = []
-        for video in response.json().get("videos", []):
-            # Filtramos por calidad mínima
-            video_files = [vf for vf in video.get("video_files", []) 
-                         if vf.get("width", 0) >= 1280 and vf.get("duration", 0) >= 5]
-            
-            if video_files:
-                best_file = max(video_files, key=lambda x: x.get("width", 0))
-                video_title = video.get("alt", "") or video.get("url", "")
-                
-                # Calculamos similitud semántica
-                title_embedding = semantic_model.encode(video_title, convert_to_tensor=True)
-                similarity = cosine_similarity(
-                    script_embedding.cpu().numpy().reshape(1, -1),
-                    title_embedding.cpu().numpy().reshape(1, -1)
-                )[0][0]
-                
-                videos_data.append((best_file["link"], similarity, video_title))
-        
-        # Ordenamos por relevancia semántica
-        videos_data.sort(key=lambda x: x[1], reverse=True)
-        
-        # Filtramos los más relevantes
-        selected_videos = videos_data[:num_videos]
-        
-        logger.info(f"Videos encontrados (relevancia):")
-        for idx, (url, score, title) in enumerate(selected_videos, 1):
-            logger.info(f"{idx}. {title} (score: {score:.2f})")
-        
-        return [url for url, _, _ in selected_videos]
-    
-    except Exception as e:
-        logger.error(f"Error en búsqueda semántica: {e}")
-        return []
-
-# Generación de script con contexto mejorado
-def generate_script(prompt: str, custom_text: Optional[str] = None) -> str:
-    """Genera un script contextualizado con IA"""
-    if custom_text and custom_text.strip():
-        return custom_text.strip()
-    
-    if not prompt or not prompt.strip():
-        return "Error: Proporciona un tema o guion"
-    
-    try:
-        # Prompt mejorado para generación contextual
-        context_prompt = f"""
-        Genera un guion detallado para un video sobre '{prompt}'. 
-        El formato debe ser:
-        1. [Concepto 1]: Descripción breve (15-25 palabras)
-        2. [Concepto 2]: Descripción breve
-        ...
-        Incluye detalles visuales entre [] para ayudar a seleccionar imágenes.
-        Ejemplo: [playa con palmeras] o [ciudad moderna con rascacielos]
-        """
+        filename = f"temp_{random.randint(1000,9999)}.mp4"
         
-        generated = text_generator(
-            context_prompt,
-            max_length=400,
-            num_return_sequences=1,
-            do_sample=True,
-            temperature=0.7,
-            top_k=50,
-            top_p=0.9
-        )[0]['generated_text']
+        with open(filename, 'wb') as f:
+            for chunk in response.iter_content(chunk_size=8192):
+                f.write(chunk)
+                
+        return filename
         
-        # Post-procesamiento para limpiar el texto
-        cleaned = re.sub(r"<.*?>", "", generated)  # Remove HTML tags
-        cleaned = re.sub(r"\n+", "\n", cleaned)    # Remove extra newlines
-        return cleaned.strip()
-    
+    except requests.exceptions.HTTPError as e:
+        if e.response.status_code == 429:
+            retry_after = int(e.response.headers.get('Retry-After', 5))
+            logger.warning(f"Rate limited. Waiting {retry_after} seconds...")
+            time.sleep(retry_after)
+        logger.error(f"Download failed: {str(e)}")
+        return None
     except Exception as e:
-        logger.error(f"Error generando script: {e}")
-        return f"Top 10 sobre {prompt}: [ejemplo 1] Descripción breve..."
+        logger.error(f"Unexpected download error: {str(e)}")
+        return None
 
-# Sistema mejorado de descarga de videos
 def download_video_segment(url: str, duration: float, output_path: str) -> bool:
-    """Descarga y procesa segmentos de video con manejo robusto"""
-    temp_path = f"temp_{random.randint(1000,9999)}.mp4"
-    
+    """Descarga y procesa un segmento de video"""
+    temp_path = None
     try:
-        # Descarga con verificación
-        with requests.get(url, stream=True, timeout=20) as r:
-            r.raise_for_status()
-            with open(temp_path, 'wb') as f:
-                for chunk in r.iter_content(chunk_size=1024*1024):
-                    if chunk:
-                        f.write(chunk)
-        
-        # Procesamiento con controles
-        with VideoFileClip(temp_path) as clip:
-            if clip.duration < 2:
-                raise ValueError("Video demasiado corto")
+        temp_path = safe_download(url)
+        if not temp_path:
+            return False
             
+        with VideoFileClip(temp_path) as clip:
+            if clip.duration < 1:
+                logger.error("Video demasiado corto")
+                return False
+                
             end_time = min(duration, clip.duration - 0.1)
             subclip = clip.subclip(0, end_time)
             
-            # Configuración optimizada
+            # Configuración optimizada para HF Spaces
             subclip.write_videofile(
                 output_path,
                 codec="libx264",
                 audio_codec="aac",
-                fps=24,
-                threads=4,
-                preset='fast',
+                threads=2,
+                preset='ultrafast',
+                verbose=False,
                 ffmpeg_params=[
                     '-max_muxing_queue_size', '1024',
-                    '-crf', '23',
                     '-movflags', '+faststart'
                 ]
             )
-        
         return True
-    
+        
     except Exception as e:
-        logger.error(f"Error procesando video: {e}")
+        logger.error(f"Video processing error: {str(e)}")
         return False
     finally:
-        if os.path.exists(temp_path):
+        if temp_path and os.path.exists(temp_path):
             os.remove(temp_path)
 
-# Función principal mejorada
-def create_contextual_video(prompt: str, custom_text: Optional[str] = None, music_file: Optional[str] = None) -> str:
-    """Crea un video con matching semántico entre texto e imágenes"""
-    # 1. Generación del script
-    script = generate_script(prompt, custom_text)
-    logger.info(f"Script generado:\n{script}")
-    
-    # 2. Búsqueda semántica de videos
-    search_query = " ".join(extract_keywords(script)) or prompt
-    video_urls = fetch_semantic_videos(search_query, script)
-    
-    if not video_urls:
-        return "Error: No se encontraron videos relevantes. Intenta con otro tema."
-    
-    # 3. Generación de voz
-    voice_file = f"voice_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp3"
-    if not run_async(generate_voice(script, voice_file)):
-        return "Error: No se pudo generar la narración."
+def fetch_pexels_videos(query: str) -> List[str]:
+    """Busca videos en Pexels con manejo de errores"""
+    if not PEXELS_API_KEY:
+        logger.error("PEXELS_API_KEY no configurada")
+        return []
+        
+    headers = {"Authorization": PEXELS_API_KEY}
+    url = f"https://api.pexels.com/videos/search?query={query}&per_page={MAX_VIDEOS}"
     
-    # 4. Procesamiento de videos
-    output_dir = "output_videos"
-    os.makedirs(output_dir, exist_ok=True)
-    output_path = f"{output_dir}/video_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
+    try:
+        response = requests.get(url, headers=headers, timeout=REQUEST_TIMEOUT)
+        response.raise_for_status()
+        
+        videos = []
+        for video in response.json().get("videos", [])[:MAX_VIDEOS]:
+            video_files = [vf for vf in video.get("video_files", []) 
+                         if vf.get("width", 0) >= 720]  # Calidad mínima
+            if video_files:
+                best_file = max(video_files, key=lambda x: x.get("width", 0))
+                videos.append(best_file["link"])
+        
+        return videos
     
+    except Exception as e:
+        logger.error(f"Error fetching Pexels videos: {str(e)}")
+        return []
+
+def generate_script(prompt: str) -> str:
+    """Genera un script usando IA local con fallback"""
     try:
-        # Descargar y preparar segmentos
+        generator = pipeline("text-generation", model=MODEL_NAME)
+        result = generator(
+            f"Genera un guion breve sobre {prompt} en español con {MAX_VIDEOS} puntos:",
+            max_length=200,
+            num_return_sequences=1
+        )[0]['generated_text']
+        return result
+    except Exception as e:
+        logger.error(f"Error generating script: {str(e)}")
+        return f"1. Punto uno sobre {prompt}\n2. Punto dos\n3. Punto tres"
+
+async def generate_voice(text: str, output_file: str = "voice.mp3") -> bool:
+    """Genera narración de voz con manejo de errores"""
+    try:
+        communicate = edge_tts.Communicate(text, voice="es-MX-DaliaNeural")
+        await communicate.save(output_file)
+        return True
+    except Exception as e:
+        logger.error(f"Voice generation failed: {str(e)}")
+        return False
+
+def run_async(coro):
+    """Ejecuta corrutinas asíncronas desde código síncrono"""
+    import asyncio
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    try:
+        return loop.run_until_complete(coro)
+    finally:
+        loop.close()
+
+def create_video(prompt: str) -> Optional[str]:
+    """Función principal para crear el video"""
+    try:
+        # 1. Generar contenido
+        script = generate_script(prompt)
+        logger.info(f"Script generado: {script[:100]}...")
+        
+        # 2. Buscar videos
+        video_urls = fetch_pexels_videos(prompt)
+        if not video_urls:
+            logger.error("No se encontraron videos")
+            return None
+            
+        # 3. Generar voz
+        voice_file = "voice.mp3"
+        if not run_async(generate_voice(script, voice_file)):
+            logger.error("No se pudo generar voz")
+            return None
+            
+        # 4. Procesar videos
+        output_dir = "output"
+        os.makedirs(output_dir, exist_ok=True)
+        output_path = os.path.join(output_dir, f"video_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4")
+        
         clips = []
-        segment_duration = AudioFileClip(voice_file).duration / len(video_urls)
+        segment_duration = VIDEO_SEGMENT_DURATION
         
-        for idx, url in enumerate(video_urls):
-            clip_path = f"segment_{idx}.mp4"
+        for i, url in enumerate(video_urls):
+            clip_path = f"segment_{i}.mp4"
             if download_video_segment(url, segment_duration, clip_path):
                 clips.append(VideoFileClip(clip_path))
         
         if not clips:
-            return "Error: No se pudieron procesar los videos."
-        
-        # 5. Ensamblaje final
+            logger.error("No se pudieron procesar los videos")
+            return None
+            
+        # 5. Ensamblar video final
         final_video = concatenate_videoclips(clips, method="compose")
         audio_clip = AudioFileClip(voice_file)
+        final_video = final_video.set_audio(audio_clip)
         
-        # Añadir música de fondo si existe
-        if music_file and os.path.exists(music_file.name):
-            music = audio_loop(AudioFileClip(music_file.name), duration=audio_clip.duration)
-            final_audio = CompositeAudioClip([audio_clip, music.volumex(0.2)])
-        else:
-            final_audio = audio_clip
-        
-        final_video = final_video.set_audio(final_audio)
-        
-        # Renderizado final optimizado
         final_video.write_videofile(
             output_path,
             codec="libx264",
             audio_codec="aac",
-            fps=24,
-            threads=6,
-            preset='fast',
-            bitrate="5000k"
+            threads=2,
+            preset='ultrafast',
+            verbose=False
         )
         
         return output_path
-    
+        
     except Exception as e:
-        logger.error(f"Error crítico al crear video: {e}")
-        return f"Error: Fallo en la creación del video - {str(e)}"
+        logger.error(f"Error creating video: {str(e)}")
+        return None
     finally:
         # Limpieza
         for clip in clips:
@@ -250,72 +233,28 @@ def create_contextual_video(prompt: str, custom_text: Optional[str] = None, musi
             if os.path.exists(f"segment_{i}.mp4"):
                 os.remove(f"segment_{i}.mp4")
 
-# Interfaz mejorada
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("""
-    # 🎬 Generador de Videos con IA Semántica
-    **Crea videos donde las imágenes coinciden perfectamente con tu texto**
-    """)
+# Interfaz Gradio optimizada
+with gr.Blocks(title="Generador de Videos HF", theme=gr.themes.Soft()) as app:
+    gr.Markdown("# 🎥 Generador Automático de Videos")
     
     with gr.Row():
-        with gr.Column(scale=1):
-            gr.Image("https://i.imgur.com/7X8P5R8.png", label="Ejemplo Visual")
-            
-            with gr.Accordion("📌 Consejos para mejores resultados", open=False):
-                gr.Markdown("""
-                - **Describe tu tema con detalles**: "Playas del Caribe con arena blanca" en vez de solo "playas"
-                - **Usa sustantivos concretos**: "Animales de la selva amazónica" > "naturaleza"
-                - **Sé específico**: "Tecnología 2024" > "Avances en inteligencia artificial 2024"
-                """)
-            
-            gr.Examples(
-                examples=[
-                    ["Lugares históricos de Europa con arquitectura medieval"],
-                    ["Tecnologías emergentes en inteligencia artificial para 2024"],
-                    ["Recetas tradicionales mexicanas con ingredientes autóctonos"]
-                ],
-                inputs=[prompt],
-                label="Ejemplos de prompts efectivos"
-            )
-        
-        with gr.Column(scale=2):
-            prompt = gr.Textbox(
-                label="Tema principal del video",
-                placeholder="Ej: 'Top 5 innovaciones tecnológicas de 2024'",
+        with gr.Column():
+            prompt_input = gr.Textbox(
+                label="Tema del video",
+                placeholder="Ej: Paisajes naturales de Chile",
                 max_lines=2
             )
+            generate_btn = gr.Button("Generar Video", variant="primary")
             
-            custom_text = gr.TextArea(
-                label="O escribe tu propio guion (opcional)",
-                placeholder="Ej: 1. [Robot humanoide] Avances en robótica...",
-                lines=6
-            )
-            
-            music_file = gr.File(
-                label="Música de fondo (opcional - MP3)",
-                type="filepath",
-                file_types=[".mp3"]
-            )
-            
-            submit = gr.Button("🚀 Generar Video", variant="primary")
-    
-    output = gr.Video(
-        label="Video Generado",
-        format="mp4",
-        interactive=False
-    )
+        with gr.Column():
+            output_video = gr.Video(label="Resultado", interactive=False)
     
-    submit.click(
-        fn=create_contextual_video,
-        inputs=[prompt, custom_text, music_file],
-        outputs=output,
-        api_name="generate_video"
+    generate_btn.click(
+        fn=create_video,
+        inputs=prompt_input,
+        outputs=output_video
     )
 
+# Para Hugging Face Spaces
 if __name__ == "__main__":
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=True,
-        debug=True
-    )
+    app.launch(server_name="0.0.0.0", server_port=7860)