Update app.py

app.py

@@ -8,67 +8,45 @@ import logging
 import re
 import torch
 from transformers import GPT2LMHeadModel, GPT2Tokenizer
-import warnings
 
-# Configuración inicial
+# Configuración básica
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Suprimir warnings no deseados
-warnings.filterwarnings("ignore", category=UserWarning)
-warnings.filterwarnings("ignore", category=DeprecationWarning)
+# Configuración de entorno (usa tu propia API key de Pexels)
+PEXELS_API_KEY = os.getenv("PEXELS_API_KEY") or "TU_API_KEY_AQUI"
 
-PEXELS_API_KEY = os.getenv("PEXELS_API_KEY")
+# Voces disponibles (Edge-TTS)
+VOICES = ["es-MX-DaliaNeural", "es-ES-ElviraNeural", "en-US-JennyNeural"]
 
-# Lista de voces válidas
-VOICES = [
-    "es-MX-DaliaNeural", "es-ES-ElviraNeural", "es-AR-ElenaNeural",
-    "es-MX-JorgeNeural", "es-ES-AlvaroNeural", "es-AR-TomasNeural",
-    "en-US-JennyNeural", "fr-FR-DeniseNeural", "de-DE-KatjaNeural"
-]
-
-# Cargar modelo GPT-2 con configuración optimizada
-try:
-    tokenizer = GPT2Tokenizer.from_pretrained("datificate/gpt2-small-spanish")
-    model = GPT2LMHeadModel.from_pretrained("datificate/gpt2-small-spanish")
-    logger.info("Modelo GPT-2 cargado correctamente")
-except Exception as e:
-    logger.error(f"Error cargando modelo: {str(e)}")
-    model = None
-    tokenizer = None
+# Carga el modelo GPT-2 en español (ligero y rápido)
+tokenizer = GPT2Tokenizer.from_pretrained("datificate/gpt2-small-spanish")
+model = GPT2LMHeadModel.from_pretrained("datificate/gpt2-small-spanish")
 
 def generar_texto(tema):
-    """Genera texto largo sobre el tema sin estructuras predefinidas"""
-    if model is None or tokenizer is None:
-        return f"Contenido sobre {tema}. " * 50
-    
+    """Genera un texto largo y natural sobre el tema (sin estructuras forzadas)."""
     try:
-        # Prompt directo y simple
-        prompt = f"Describe detalladamente {tema}"
+        prompt = f"Habla extensamente sobre {tema} en un tono natural y detallado:"
+        inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=512)
         
-        # Codificar el texto con truncamiento
-        inputs = tokenizer(prompt, return_tensors="pt", max_length=512, truncation=True)
-        
-        # Generar texto con parámetros optimizados
         outputs = model.generate(
             inputs.input_ids,
             max_length=800,
             do_sample=True,
             temperature=0.7,
-            top_k=40,
-            num_return_sequences=1,
+            top_k=50,
             pad_token_id=tokenizer.eos_token_id
         )
         
         texto = tokenizer.decode(outputs[0], skip_special_tokens=True)
         return re.sub(r'\s+', ' ', texto).strip()
-        
+    
     except Exception as e:
-        logger.error(f"Error generando texto: {str(e)}")
-        return f"Texto generado sobre {tema}. " * 50
+        logger.error(f"Error generando texto: {e}")
+        return f"Contenido generado sobre {tema}."
 
-def obtener_videos(tema):
-    """Obtiene videos de Pexels con manejo robusto de errores"""
+def buscar_videos(tema):
+    """Busca videos en Pexels y devuelve los 3 más relevantes."""
     try:
         headers = {"Authorization": PEXELS_API_KEY}
         response = requests.get(
@@ -78,64 +56,65 @@ def obtener_videos(tema):
         )
         return response.json().get("videos", [])[:3]
     except Exception as e:
-        logger.error(f"Error obteniendo videos: {str(e)}")
+        logger.error(f"Error buscando videos: {e}")
         return []
 
-def crear_video(prompt, voz_seleccionada):
+def crear_video(tema, voz_seleccionada):
+    """Genera el video final con voz y clips de video."""
     try:
         # 1. Generar texto
-        texto = generar_texto(prompt)
-        logger.info(f"Texto generado: {len(texto)} caracteres")
+        texto = generar_texto(tema)
         
-        # 2. Crear narración de voz
-        voz_file = "narracion.mp3"
+        # 2. Convertir texto a voz (Edge-TTS)
+        voz_archivo = "narracion.mp3"
         subprocess.run([
             'edge-tts',
             '--voice', voz_seleccionada,
             '--text', texto,
-            '--write-media', voz_file
+            '--write-media', voz_archivo
         ], check=True)
         
-        audio = AudioFileClip(voz_file)
-        duracion = audio.duration
+        # 3. Procesar audio
+        audio = AudioFileClip(voz_archivo)
+        duracion_total = audio.duration
         
-        # 3. Obtener y procesar videos
-        videos = obtener_videos(prompt) or obtener_videos("nature")
+        # 4. Buscar y descargar videos
+        videos = buscar_videos(tema) or buscar_videos("nature")
         clips = []
         
-        for i, video in enumerate(videos):
+        for i, video in enumerate(videos[:3]):  # Máximo 3 videos
             try:
-                # Seleccionar video de mayor calidad
-                video_file = max(video['video_files'], key=lambda x: x.get('width', 0))
-                temp_file = f"temp_{i}.mp4"
+                mejor_calidad = max(video['video_files'], key=lambda x: x.get('width', 0))
+                url_video = mejor_calidad['link']
                 
-                # Descargar video
-                with requests.get(video_file['link'], stream=True) as r:
+                # Descargar video temporal
+                temp_file = f"temp_video_{i}.mp4"
+                with requests.get(url_video, stream=True) as r:
                     r.raise_for_status()
                     with open(temp_file, 'wb') as f:
                         for chunk in r.iter_content(chunk_size=8192):
                             f.write(chunk)
                 
-                # Procesar clip
+                # Ajustar duración del clip
                 clip = VideoFileClip(temp_file)
-                clip_duration = min(duracion/len(videos), clip.duration)
-                clips.append(clip.subclip(0, clip_duration))
+                duracion_clip = min(duracion_total / len(videos), clip.duration)
+                clips.append(clip.subclip(0, duracion_clip))
                 
             except Exception as e:
-                logger.error(f"Error procesando video {i}: {str(e)}")
+                logger.error(f"Error procesando video {i}: {e}")
         
-        # 4. Crear video final
+        # 5. Combinar clips (o usar fondo negro si no hay videos)
         if not clips:
-            final_clip = ColorClip((1280, 720), (0, 0, 0), duration=duracion)
+            video_final = ColorClip((1280, 720), (0, 0, 0), duration=duracion_total)
         else:
-            final_clip = concatenate_videoclips(clips).set_duration(duracion)
+            video_final = concatenate_videoclips(clips, method="compose")
         
-        final_clip = final_clip.set_audio(audio)
+        video_final = video_final.set_audio(audio)
         
-        # 5. Exportar video
-        output_file = f"video_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
-        final_clip.write_videofile(
-            output_file,
+        # 6. Exportar video
+        nombre_archivo = f"video_final_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
+        video_final.write_videofile(
+            nombre_archivo,
             fps=24,
             codec="libx264",
             audio_codec="aac",
@@ -143,40 +122,37 @@ def crear_video(prompt, voz_seleccionada):
             preset='fast'
         )
         
-        return output_file
-        
+        return nombre_archivo
+    
     except Exception as e:
-        logger.error(f"Error crítico: {str(e)}")
+        logger.error(f"Error crítico: {e}")
         return None
+    
     finally:
         # Limpieza de archivos temporales
-        for f in [voz_file, *[f"temp_{i}.mp4" for i in range(3)]]:
-            if os.path.exists(f):
-                try:
-                    os.remove(f)
-                except:
-                    pass
+        if os.path.exists(voz_archivo):
+            os.remove(voz_archivo)
+        for i in range(3):
+            temp_file = f"temp_video_{i}.mp4"
+            if os.path.exists(temp_file):
+                os.remove(temp_file)
 
-# Interfaz minimalista
+# Interfaz de Gradio (sencilla y funcional)
 with gr.Blocks() as app:
+    gr.Markdown("# 🎬 Generador Automático de Videos")
+    
     with gr.Row():
-        with gr.Column():
-            tema = gr.Textbox(label="Tema del video")
-            voz = gr.Dropdown(label="Voz", choices=VOICES, value=VOICES[0])
-            btn = gr.Button("Generar Video")
-        
-        with gr.Column():
-            video = gr.Video(label="Resultado")
-
+        tema = gr.Textbox(label="Tema del video", placeholder="Ej: 'Historia de la inteligencia artificial'")
+        voz = gr.Dropdown(label="Voz", choices=VOICES, value=VOICES[0])
+        btn = gr.Button("Generar Video", variant="primary")
+    
+    salida = gr.Video(label="Resultado")
+    
     btn.click(
         fn=crear_video,
         inputs=[tema, voz],
-        outputs=video
+        outputs=salida
     )
 
 if __name__ == "__main__":
-    app.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False
-    )
+    app.launch(server_name="0.0.0.0", server_port=7860)