Update app.py

app.py

@@ -1,106 +1,228 @@
 import os
 import subprocess
+import requests
 import gradio as gr
 from moviepy.editor import *
-import requests
 from datetime import datetime
 import tempfile
+import logging
+from transformers import pipeline
 
 # Configuración inicial
-PEXELS_API_KEY = os.getenv("PEXELS_API_KEY")  # Configurar en variables de entorno
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+PEXELS_API_KEY = os.getenv("PEXELS_API_KEY")  # Configurar en Hugging Face
 
-# Lista de voces válidas
+# Lista de voces válidas (puedes añadir más)
 VOICES = [
-    "es-MX-DaliaNeural", "es-ES-ElviraNeural", 
-    "es-AR-ElenaNeural", "en-US-JennyNeural",
-    "fr-FR-DeniseNeural", "de-DE-KatjaNeural"
+    "es-MX-DaliaNeural", "es-ES-ElviraNeural", "es-AR-ElenaNeural",
+    "en-US-JennyNeural", "fr-FR-DeniseNeural", "de-DE-KatjaNeural",
+    "it-IT-ElsaNeural", "pt-BR-FranciscaNeural", "ja-JP-NanamiNeural"
 ]
 
+# Inicializar el generador de texto
+try:
+    script_generator = pipeline("text-generation", model="facebook/mbart-large-50")
+except:
+    logger.warning("No se pudo cargar el modelo de generación de texto")
+    script_generator = None
+
+def generar_guion(prompt):
+    """Genera un guion automático usando IA"""
+    if script_generator:
+        try:
+            result = script_generator(
+                f"Genera un guion breve para un video sobre '{prompt}' con 3 puntos principales:",
+                max_length=250,
+                num_return_sequences=1
+            )
+            return result[0]['generated_text']
+        except Exception as e:
+            logger.error(f"Error generando guion: {str(e)}")
+    
+    # Fallback si falla la generación
+    return f"1. Primer punto sobre {prompt}\n2. Segundo punto\n3. Tercer punto"
+
 def descargar_video(url, output_path):
     """Descarga un video y lo guarda localmente"""
     try:
-        response = requests.get(url, stream=True, timeout=15)
+        response = requests.get(url, stream=True, timeout=20)
+        response.raise_for_status()
         with open(output_path, 'wb') as f:
-            for chunk in response.iter_content(chunk_size=1024*1024):
-                f.write(chunk)
+            for chunk in response.iter_content(chunk_size=1024*1024):  # 1MB chunks
+                if chunk:
+                    f.write(chunk)
         return True
     except Exception as e:
-        print(f"Error descargando video: {str(e)}")
+        logger.error(f"Error descargando video: {str(e)}")
         return False
 
-def generar_video(prompt, voz_seleccionada, musica=None):
+def crear_video(prompt, custom_script, voz_seleccionada, musica=None):
     try:
-        # 1. Generar voz
+        # 1. Generar o usar guion
+        guion = custom_script if custom_script else generar_guion(prompt)
+        logger.info(f"Guion: {guion[:100]}...")
+        
+        # 2. Generar voz
         voz_archivo = "voz.mp3"
         subprocess.run([
             'edge-tts',
             '--voice', voz_seleccionada,
-            '--text', prompt,
+            '--text', guion,
             '--write-media', voz_archivo
         ], check=True)
         
-        # 2. Buscar videos en Pexels
+        # 3. Buscar videos en Pexels
         headers = {"Authorization": PEXELS_API_KEY}
         response = requests.get(
-            f"https://api.pexels.com/videos/search?query={prompt[:50]}&per_page=2",
+            f"https://api.pexels.com/videos/search?query={prompt[:50]}&per_page=3",
             headers=headers,
             timeout=15
         )
-        videos = response.json().get("videos", [])
+        videos_data = response.json().get("videos", [])
         
-        # 3. Descargar y procesar videos
+        if not videos_data:
+            raise Exception("No se encontraron videos en Pexels")
+        
+        # 4. Descargar y preparar clips de video
         clips = []
-        for v in videos[:2]:
-            video_url = v["video_files"][0]["link"]
-            temp_video = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False)
-            if descargar_video(video_url, temp_video.name):
-                clip = VideoFileClip(temp_video.name).subclip(0, min(5, VideoFileClip(temp_video.name).duration))
-                clips.append(clip)
+        for i, video in enumerate(videos_data[:3]):
+            # Seleccionar la mejor calidad de video disponible
+            video_files = sorted(
+                [vf for vf in video['video_files'] if vf.get('width')],
+                key=lambda x: x['width'],
+                reverse=True
+            )
+            
+            if not video_files:
+                continue
+                
+            video_url = video_files[0]['link']
+            temp_video_path = f"temp_video_{i}.mp4"
+            
+            if descargar_video(video_url, temp_video_path):
+                clip = VideoFileClip(temp_video_path)
+                
+                # Calcular duración proporcional
+                clip_duration = min(10, clip.duration)  # Máximo 10 segundos por clip
+                clips.append(clip.subclip(0, clip_duration))
         
         if not clips:
             raise Exception("No se pudieron cargar videos válidos")
         
-        # 4. Procesar audio
+        # 5. Procesar audio
         audio = AudioFileClip(voz_archivo)
+        total_duration = audio.duration
+        
         if musica:
             musica_clip = AudioFileClip(musica.name)
-            if musica_clip.duration < audio.duration:
-                musica_clip = musica_clip.loop(duration=audio.duration)
-            audio = CompositeAudioClip([audio, musica_clip.volumex(0.3)])
+            if musica_clip.duration < total_duration:
+                # Crear loop si la música es más corta
+                looped_music = musica_clip.loop(duration=total_duration)
+            else:
+                looped_music = musica_clip.subclip(0, total_duration)
+                
+            audio = CompositeAudioClip([audio, looped_music.volumex(0.25)])
         
-        # 5. Crear video final
-        final_clip = concatenate_videoclips(clips).set_audio(audio)
+        # 6. Crear video final
+        # Calcular duración por clip
+        clip_durations = [c.duration for c in clips]
+        total_clip_duration = sum(clip_durations)
+        scale_factor = total_duration / total_clip_duration if total_clip_duration > 0 else 1
+        
+        # Ajustar velocidad de los clips para que coincidan con el audio
+        adjusted_clips = [c.fx(vfx.speedx, scale_factor) for c in clips]
+        final_clip = concatenate_videoclips(adjusted_clips, method="compose")
+        
+        # Aplicar transición suave entre clips
+        final_clip = final_clip.fx(vfx.fadein, 0.5).fx(vfx.fadeout, 0.5)
+        
+        # Ajustar duración exacta
+        final_clip = final_clip.set_duration(total_duration).set_audio(audio)
+        
+        # 7. Guardar video final
         output_path = f"video_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
-        final_clip.write_videofile(output_path, codec="libx264", audio_codec="aac", threads=2)
+        final_clip.write_videofile(
+            output_path,
+            codec="libx264",
+            audio_codec="aac",
+            threads=2,
+            preset='fast',
+            fps=24
+        )
         
         return output_path
+        
     except Exception as e:
-        print(f"ERROR: {str(e)}")
+        logger.error(f"ERROR: {str(e)}")
         return None
     finally:
-        # Limpieza
+        # Limpieza de archivos temporales
         if os.path.exists(voz_archivo):
             os.remove(voz_archivo)
+        for i in range(3):
+            if os.path.exists(f"temp_video_{i}.mp4"):
+                os.remove(f"temp_video_{i}.mp4")
 
-# Interfaz Gradio
-with gr.Blocks() as app:
-    gr.Markdown("# 🎬 Generador de Videos Automático")
+# Interfaz Gradio mejorada
+with gr.Blocks(theme=gr.themes.Soft(), title="Generador de Videos Profesional") as app:
+    gr.Markdown("# 🎬 GENERADOR DE VIDEOS AUTOMÁTICO")
     
     with gr.Row():
-        with gr.Column():
-            prompt = gr.Textbox(label="Tema del video")
-            voz = gr.Dropdown(label="Selección de voz", choices=VOICES, value="es-ES-ElviraNeural")
-            musica = gr.File(label="Música de fondo (opcional)", file_types=[".mp3"])
-            btn = gr.Button("Generar Video")
-        
-        with gr.Column():
-            output = gr.Video(label="Resultado")
+        with gr.Column(scale=1):
+            gr.Markdown("### Configuración del Video")
+            prompt = gr.Textbox(label="Tema principal", placeholder="Ej: 'Lugares misteriosos de España'")
+            custom_script = gr.TextArea(
+                label="Guion personalizado (opcional)", 
+                placeholder="Pega aquí tu propio guion...",
+                lines=5
+            )
+            voz = gr.Dropdown(
+                label="Selecciona una voz",
+                choices=VOICES,
+                value="es-ES-ElviraNeural",
+                interactive=True
+            )
+            musica = gr.File(
+                label="Música de fondo (opcional)", 
+                file_types=[".mp3", ".wav"],
+                type="filepath"
+            )
+            btn = gr.Button("🚀 GENERAR VIDEO", variant="primary", size="lg")
+            
+        with gr.Column(scale=2):
+            output = gr.Video(
+                label="Video Resultante", 
+                format="mp4",
+                interactive=False,
+                elem_id="video-player"
+            )
+            
+            gr.Examples(
+                examples=[
+                    ["Lugares históricos de Roma", "", "it-IT-ElsaNeural", None],
+                    ["Tecnologías del futuro", "", "en-US-JennyNeural", None],
+                    ["Playas paradisíacas del Caribe", "", "es-MX-DaliaNeural", None]
+                ],
+                inputs=[prompt, custom_script, voz, musica],
+                label="Ejemplos para probar"
+            )
 
     btn.click(
-        fn=generar_video,
-        inputs=[prompt, voz, musica],
+        fn=crear_video,
+        inputs=[prompt, custom_script, voz, musica],
         outputs=output
     )
 
+# CSS para mejorar la visualización
+app.css = """
+#video-player {
+    max-width: 100%;
+    border-radius: 10px;
+    box-shadow: 0 4px 12px rgba(0,0,0,0.15);
+}
+"""
+
 if __name__ == "__main__":
     app.launch(server_name="0.0.0.0", server_port=7860)