Update app.py

app.py

@@ -1,336 +1,321 @@
 import os
+import re
 import random
 import requests
 import gradio as gr
-from moviepy.editor import VideoFileClip, concatenate_videoclips, AudioFileClip, CompositeVideoClip
+from moviepy.editor import VideoFileClip, concatenate_videoclips, AudioFileClip, CompositeAudioClip
 from moviepy.audio.fx.all import audio_loop
 import edge_tts
 import asyncio
 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
 logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
 logger = logging.getLogger(__name__)
 
-# Pexels API key from environment variable
+# 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")
-logger.info("Loaded PEXELS_API_KEY from environment")
 
-# Ensure asyncio works with Gradio
-def run_async(coro):
-    logger.info("Running async coroutine")
-    try:
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-        result = loop.run_until_complete(coro)
-        loop.close()
-        logger.info("Async coroutine completed")
-        return result
-    except Exception as e:
-        logger.error(f"Error en run_async: {e}")
-        return None
-
-# Load lightweight text generation model for Spanish
-logger.info("Loading text generation model: facebook/mbart-large-50")
+# Cargamos modelos de IA para análisis semántico
+logger.info("Cargando modelos de IA...")
 try:
-    generator = pipeline("text-generation", model="facebook/mbart-large-50", device="cpu")
-    logger.info("Model loaded successfully")
+    # 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 loading model: {e}")
-    generator = None
-
-# List available Spanish voices for Edge TTS
-SPANISH_VOICES = [
-    "es-MX-DaliaNeural",
-    "es-MX-JorgeNeural",
-    "es-MX-CecilioNeural",
-    "es-MX-BeatrizNeural",
-    "es-MX-CandelaNeural",
-    "es-MX-CarlosNeural",
-    "es-MX-LarissaNeural",
-    "es-MX-ManuelNeural",
-    "es-MX-MarinaNeural",
-    "es-MX-NuriaNeural"
-]
+    logger.error(f"Error cargando modelos de IA: {e}")
+    raise
 
-# Fetch videos from Pexels
-def fetch_pexels_videos(query, num_videos=5):
-    logger.info(f"Fetching {num_videos} videos from Pexels with query: {query}")
+# 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}"
+    url = f"https://api.pexels.com/videos/search?query={query}&per_page={num_videos*2}"  # Buscamos más para filtrar
+    
     try:
-        response = requests.get(url, headers=headers)
-        if response.status_code == 200:
-            videos = [video["video_files"][0]["link"] for video in response.json()["videos"]]
-            logger.info(f"Fetched {len(videos)} videos from Pexels")
-            return videos
-        logger.error(f"Failed to fetch videos from Pexels. Status code: {response.status_code}")
+        response = requests.get(url, headers=headers, timeout=15)
+        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 fetching videos from Pexels: {e}")
-    return []
+        logger.error(f"Error en búsqueda semántica: {e}")
+        return []
 
-# Generate script using local model or custom text
-def generate_script(prompt, custom_text=None):
-    logger.info("Generating script")
+# 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():
-        logger.info("Using custom text provided by user")
         return custom_text.strip()
-    if not prompt or not prompt.strip():
-        logger.error("No prompt or custom text provided")
-        return "Error: Debes proporcionar un prompt o un guion personalizado."
     
-    # Generate script with local model
-    if generator:
-        input_text = f"Genera un guion para un video sobre '{prompt}'. Crea una lista numerada con descripciones breves (máximo 20 palabras por ítem) para un top 10 relacionado con el tema en español."
-        logger.info(f"Generating script with prompt: {prompt}")
-        try:
-            result = generator(input_text, max_length=300, num_return_sequences=1, do_sample=True, truncation=True)[0]['generated_text']
-            logger.info("Script generated successfully")
-            return result.strip()
-        except Exception as e:
-            logger.error(f"Error generating script: {e}")
+    if not prompt or not prompt.strip():
+        return "Error: Proporciona un tema o guion"
     
-    # Fallback mock response
-    logger.info("Using fallback mock response")
-    if "recetas" in prompt.lower():
-        return """
-        1. Tacos al pastor: Jugosa carne marinada con piña.
-        2. Lasagna: Capas de pasta, carne y queso fundido.
-        3. Sushi: Arroz y pescado fresco en rollos delicados.
-        4. Pizza casera: Masa crujiente con tus ingredientes favoritos.
-        5. Paella: Arroz con mariscos y azafrán.
-        6. Ceviche: Pescado fresco marinado en limón.
-        7. Ramen: Caldo rico con fideos y cerdo.
-        8. Tiramisú: Postre cremoso con café y mascarpone.
-        9. Enchiladas: Tortillas rellenas con salsa picante.
-        10. Curry: Especias intensas con carne o vegetales.
+    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]
         """
-    return f"Top 10 sobre {prompt}: No se pudo generar un guion específico."
-
-# Generate voice using Edge TTS
-async def generate_voice(text, output_file="output.mp3"):
-    if not text or len(text.strip()) < 10:
-        logger.error("Texto demasiado corto para generar voz")
-        return None
         
-    logger.info(f"Generating voice with Edge TTS")
-    try:
-        # Seleccionar una voz aleatoria
-        voice = random.choice(SPANISH_VOICES)
-        logger.info(f"Using voice: {voice}")
+        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']
         
-        communicate = edge_tts.Communicate(text, voice=voice)
-        await communicate.save(output_file)
-        logger.info(f"Voice generated and saved to {output_file}")
-        return output_file
+        # 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 Exception as e:
-        logger.error(f"Error generating voice: {e}")
-        # Intentar con otra voz si falla
-        for voice in SPANISH_VOICES:
-            try:
-                logger.info(f"Trying with voice: {voice}")
-                communicate = edge_tts.Communicate(text, voice=voice)
-                await communicate.save(output_file)
-                logger.info(f"Voice generated with backup voice {voice}")
-                return output_file
-            except:
-                continue
-        logger.error("All voice attempts failed")
-        return None
+        logger.error(f"Error generando script: {e}")
+        return f"Top 10 sobre {prompt}: [ejemplo 1] Descripción breve..."
 
-# Download and trim video
-def download_and_trim_video(url, duration, output_path):
-    logger.info(f"Downloading video from {url}")
+# 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"
+    
     try:
-        response = requests.get(url, stream=True)
-        response.raise_for_status()
+        # 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)
         
-        with open("temp_video.mp4", "wb") as f:
-            for chunk in response.iter_content(chunk_size=1024):
-                f.write(chunk)
-                
-        logger.info("Trimming video")
-        clip = VideoFileClip("temp_video.mp4")
-        clip_duration = min(duration, clip.duration)
-        clip = clip.subclip(0, clip_duration)
-        clip.write_videofile(output_path, codec="libx264", audio_codec="aac", threads=4)
-        clip.close()
-        os.remove("temp_video.mp4")
-        logger.info(f"Video trimmed and saved to {output_path}")
-        return output_path
+        # Procesamiento con controles
+        with VideoFileClip(temp_path) as clip:
+            if clip.duration < 2:
+                raise ValueError("Video demasiado corto")
+            
+            end_time = min(duration, clip.duration - 0.1)
+            subclip = clip.subclip(0, end_time)
+            
+            # Configuración optimizada
+            subclip.write_videofile(
+                output_path,
+                codec="libx264",
+                audio_codec="aac",
+                fps=24,
+                threads=4,
+                preset='fast',
+                ffmpeg_params=[
+                    '-max_muxing_queue_size', '1024',
+                    '-crf', '23',
+                    '-movflags', '+faststart'
+                ]
+            )
+        
+        return True
+    
     except Exception as e:
-        logger.error(f"Error downloading/trimming video: {e}")
-        return None
+        logger.error(f"Error procesando video: {e}")
+        return False
+    finally:
+        if os.path.exists(temp_path):
+            os.remove(temp_path)
 
-# Main video creation function
-def create_video(prompt, custom_text, music_file):
-    logger.info("Starting video creation process")
+# 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}")
     
-    # Validar inputs
-    if not prompt and not custom_text:
-        logger.error("No prompt or custom text provided")
-        return "Error: Debes proporcionar un prompt o un guion personalizado."
-        
+    # 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."
+    
+    # 4. Procesamiento de videos
     output_dir = "output_videos"
     os.makedirs(output_dir, exist_ok=True)
-    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-    output_video = f"{output_dir}/video_{timestamp}.mp4"
-    logger.info(f"Output video will be saved to {output_video}")
-
-    # Generate or use provided script
-    script = generate_script(prompt, custom_text)
-    if "Error" in script:
-        logger.error(script)
-        return script
-
-    # Generate voice
-    voice_file = "temp_audio.mp3"
-    voice_result = run_async(generate_voice(script, voice_file))
+    output_path = f"{output_dir}/video_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
     
-    if not voice_result or not os.path.exists(voice_file):
-        logger.error("Voice generation failed")
-        return "Error: No se pudo generar la voz. Intenta con un texto diferente."
-        
     try:
-        audio = AudioFileClip(voice_file)
-        video_duration = audio.duration
-        logger.info(f"Audio duration: {video_duration} seconds")
-    except Exception as e:
-        logger.error(f"Error loading audio file: {e}")
-        return "Error: El archivo de audio generado es inválido."
-
-    # Fetch Pexels videos
-    query = prompt.split()[0] if prompt else "generic"
-    video_urls = fetch_pexels_videos(query, num_videos=5)
-    if not video_urls:
-        logger.error("No videos found on Pexels")
-        return "Error: No se encontraron videos en Pexels."
-
-    # Download and trim videos
-    clips = []
-    for i, url in enumerate(video_urls):
-        clip_path = f"temp_clip_{i}.mp4"
-        result = download_and_trim_video(url, video_duration / len(video_urls), clip_path)
-        if result:
-            try:
-                clip = VideoFileClip(clip_path)
-                clips.append(clip)
-                logger.info(f"Processed video clip {i+1}/{len(video_urls)}")
-            except Exception as e:
-                logger.error(f"Error loading clip {i+1}: {e}")
-                continue
-
-    if not clips:
-        logger.error("No valid video clips available")
-        return "Error: No se pudieron procesar los videos descargados."
-
-    # Concatenate video clips
-    logger.info("Concatenating video clips")
-    try:
-        final_clip = concatenate_videoclips(clips, method="compose")
-        final_clip = final_clip.set_duration(video_duration)
-    except Exception as e:
-        logger.error(f"Error concatenating clips: {e}")
-        return "Error: No se pudieron unir los segmentos de video."
-
-    # Add looped music or voice
-    try:
-        if music_file:
-            logger.info("Adding user-uploaded music")
-            music = AudioFileClip(music_file.name)
-            music = audio_loop(music, duration=video_duration)
-            final_audio = CompositeAudioClip([audio, music.volumex(0.3)])
+        # Descargar y preparar segmentos
+        clips = []
+        segment_duration = AudioFileClip(voice_file).duration / len(video_urls)
+        
+        for idx, url in enumerate(video_urls):
+            clip_path = f"segment_{idx}.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
+        final_video = concatenate_videoclips(clips, method="compose")
+        audio_clip = AudioFileClip(voice_file)
+        
+        # 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:
-            logger.info("Using generated voice as audio")
-            final_audio = audio
-
-        final_clip = final_clip.set_audio(final_audio)
-    except Exception as e:
-        logger.error(f"Error processing audio: {e}")
-        return "Error: Problema al procesar el audio."
-
-    # Write final video
-    logger.info(f"Writing final video to {output_video}")
-    try:
-        final_clip.write_videofile(
-            output_video, 
-            codec="libx264", 
-            audio_codec="aac", 
+            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=4,
-            preset='ultrafast',
-            bitrate="3000k"
+            threads=6,
+            preset='fast',
+            bitrate="5000k"
         )
-    except Exception as e:
-        logger.error(f"Error writing video file: {e}")
-        return "Error: No se pudo generar el video final."
+        
+        return output_path
     
-    # Clean up
-    logger.info("Cleaning up temporary files")
-    try:
+    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)}"
+    finally:
+        # Limpieza
         for clip in clips:
             clip.close()
-        audio.close()
-        if music_file:
-            music.close()
-        final_clip.close()
-        os.remove(voice_file)
+        if os.path.exists(voice_file):
+            os.remove(voice_file)
         for i in range(len(video_urls)):
-            if os.path.exists(f"temp_clip_{i}.mp4"):
-                os.remove(f"temp_clip_{i}.mp4")
-    except Exception as e:
-        logger.error(f"Error during cleanup: {e}")
-
-    logger.info("Video creation completed successfully")
-    return output_video
+            if os.path.exists(f"segment_{i}.mp4"):
+                os.remove(f"segment_{i}.mp4")
 
-# Gradio interface
-with gr.Blocks() as demo:
-    gr.Markdown("# Generador de Videos Automáticos")
+# Interfaz mejorada
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
     gr.Markdown("""
-    Crea videos automáticos con voz en español. 
-    Ingresa un tema (ej. 'Top 10 recetas mexicanas') o escribe tu propio guion.
+    # 🎬 Generador de Videos con IA Semántica
+    **Crea videos donde las imágenes coinciden perfectamente con tu texto**
     """)
     
     with gr.Row():
-        with gr.Column():
+        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 del Video", 
-                placeholder="Ejemplo: Top 10 lugares para visitar en México",
+                label="Tema principal del video",
+                placeholder="Ej: 'Top 5 innovaciones tecnológicas de 2024'",
                 max_lines=2
             )
-            custom_text = gr.Textbox(
-                label="Guion Personalizado (opcional)", 
-                placeholder="Pega aquí tu propio guion si prefieres...",
-                max_lines=10
+            
+            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)", 
+                label="Música de fondo (opcional - MP3)",
+                type="filepath",
                 file_types=[".mp3"]
             )
-            submit = gr.Button("Generar Video", variant="primary")
             
-        with gr.Column():
-            output = gr.Video(label="Video Generado", format="mp4")
-            gr.Examples(
-                examples=[
-                    ["Top 10 ciudades de México", "", None],
-                    ["", "1. Ciudad de México - La capital vibrante\n2. Guadalajara - Cuna del mariachi\n3. Monterrey - Modernidad industrial", None]
-                ],
-                inputs=[prompt, custom_text, music_file],
-                label="Ejemplos para probar"
-            )
+            submit = gr.Button("🚀 Generar Video", variant="primary")
+    
+    output = gr.Video(
+        label="Video Generado",
+        format="mp4",
+        interactive=False
+    )
     
     submit.click(
-        fn=create_video,
+        fn=create_contextual_video,
         inputs=[prompt, custom_text, music_file],
         outputs=output,
         api_name="generate_video"
     )
 
-demo.launch(server_name="0.0.0.0", server_port=7860, share=True)
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True,
+        debug=True
+    )