Update app.py

app.py

@@ -9,13 +9,15 @@ import re
 import torch
 from transformers import GPT2LMHeadModel, GPT2Tokenizer
 import warnings
+import time
 
 # Configuración inicial
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Suprimir warnings específicos de transformers
+# Suprimir warnings específicos
 warnings.filterwarnings("ignore", category=UserWarning, module="transformers")
+warnings.filterwarnings("ignore", category=DeprecationWarning)
 
 PEXELS_API_KEY = os.getenv("PEXELS_API_KEY")
 
@@ -24,245 +26,154 @@ 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",
-    "it-IT-ElsaNeural", "pt-BR-FranciscaNeural", "ja-JP-NanamiNeural",
-    "en-GB-SoniaNeural", "es-CL-CatalinaNeural", "es-CO-GonzaloNeural"
+    "it-IT-ElsaNeural", "pt-BR-FranciscaNeural", "ja-JP-NanamiNeural"
 ]
 
-# Cargar modelo y tokenizador de GPT-2 en español
-try:
-    tokenizer = GPT2Tokenizer.from_pretrained("datificate/gpt2-small-spanish")
-    model = GPT2LMHeadModel.from_pretrained("datificate/gpt2-small-spanish")
-    logger.info("Modelo GPT-2 en español cargado correctamente")
-except Exception as e:
-    logger.error(f"Error cargando el modelo: {str(e)}")
-    model = None
-    tokenizer = None
+# Cargar modelo GPT-2 con manejo de errores mejorado
+def cargar_modelo():
+    try:
+        tokenizer = GPT2Tokenizer.from_pretrained("datificate/gpt2-small-spanish")
+        model = GPT2LMHeadModel.from_pretrained("datificate/gpt2-small-spanish")
+        logger.info("Modelo GPT-2 cargado correctamente")
+        return tokenizer, model
+    except Exception as e:
+        logger.error(f"Error cargando modelo: {str(e)}")
+        return None, None
 
-def generar_guion_largo(tema, custom_script=None):
-    """Genera un texto largo sobre el tema usando GPT-2 con configuración correcta"""
+tokenizer, model = cargar_modelo()
+
+def generar_guion(tema, custom_script=None):
+    """Genera texto basado en el tema sin estructuras predefinidas"""
     if custom_script:
         return custom_script
-        
+    
     if model is None or tokenizer is None:
-        return f"Texto generado automáticamente sobre {tema}. " * 50
+        return f"Texto sobre {tema}. " * 100
     
     try:
-        # Prompt directo como solicitaste
-        prompt = f"Escribe un texto largo y detallado sobre {tema}"
-        
-        inputs = tokenizer(prompt, return_tensors="pt", max_length=512, truncation=True)
+        inputs = tokenizer(f"Escribe un texto largo sobre {tema}", return_tensors="pt", truncation=True)
         
-        # Generar texto con configuración corregida
         outputs = model.generate(
             inputs.input_ids,
-            max_length=800,
+            max_length=1000,
             do_sample=True,
-            temperature=0.9,
+            temperature=0.7,
             top_k=50,
-            top_p=0.95,
             num_return_sequences=1,
-            pad_token_id=tokenizer.eos_token_id,
-            # early_stopping=True  # Eliminado para evitar warnings
+            pad_token_id=tokenizer.eos_token_id
         )
         
-        guion = tokenizer.decode(outputs[0], skip_special_tokens=True)
-        
-        # Limpiar texto
-        guion = re.sub(r'<.*?>', '', guion)
-        guion = re.sub(r'\n+', '\n', guion)
-        guion = re.sub(r'\s+', ' ', guion).strip()
-        
-        logger.info(f"Guion generado: {len(guion)} caracteres")
-        return guion
-        
+        return tokenizer.decode(outputs[0], skip_special_tokens=True)
     except Exception as e:
-        logger.error(f"Error generando guion: {str(e)}")
-        return f"Texto generado automáticamente sobre {tema}. " * 50
+        logger.error(f"Error generando texto: {str(e)}")
+        return f"Contenido generado sobre {tema}. " * 100
 
-def buscar_videos_pexels(tema, num_videos=4):
-    """Busca videos en Pexels usando el tema directamente"""
+def buscar_videos(tema):
+    """Busca videos en Pexels con manejo de errores mejorado"""
     try:
         headers = {"Authorization": PEXELS_API_KEY}
-        
-        logger.info(f"Buscando videos para: {tema}")
-        
         response = requests.get(
-            f"https://api.pexels.com/videos/search?query={tema}&per_page={num_videos}",
+            f"https://api.pexels.com/videos/search?query={tema}&per_page=3",
             headers=headers,
-            timeout=15
+            timeout=10
         )
-        
-        if response.status_code != 200:
-            return []
-            
-        return response.json().get("videos", [])[:num_videos]
+        return response.json().get("videos", [])[:3]
     except Exception as e:
         logger.error(f"Error buscando videos: {str(e)}")
         return []
 
-def descargar_video(url, output_path):
-    """Descarga un video de manera eficiente"""
-    try:
-        with requests.get(url, stream=True, timeout=30) as r:
-            r.raise_for_status()
-            with open(output_path, 'wb') as f:
-                for chunk in r.iter_content(chunk_size=8192):
-                    f.write(chunk)
-        return True
-    except Exception as e:
-        logger.error(f"Error descargando video: {str(e)}")
-        return False
-
 def crear_video(prompt, custom_script, voz_seleccionada, musica=None):
     try:
-        # 1. Generar guion largo
-        guion = generar_guion_largo(prompt, custom_script)
+        start_time = time.time()
+        
+        # 1. Generar guión
+        guion = generar_guion(prompt, custom_script)
+        logger.info(f"Guion generado ({len(guion)} caracteres)")
         
-        # 2. Generar narración
-        voz_archivo = "voz.mp3"
+        # 2. Generar voz
+        voz_file = "narracion.mp3"
         subprocess.run([
             'edge-tts',
             '--voice', voz_seleccionada,
             '--text', guion,
-            '--write-media', voz_archivo
+            '--write-media', voz_file
         ], check=True)
         
-        # 3. Procesar audio principal
-        audio = AudioFileClip(voz_archivo)
-        duracion_total = audio.duration
-        
-        # 4. Buscar videos relevantes
-        videos_data = buscar_videos_pexels(prompt)
-        
-        if not videos_data:
-            logger.warning("No se encontraron videos. Usando videos genéricos...")
-            videos_data = buscar_videos_pexels("nature")
+        audio = AudioFileClip(voz_file)
+        duracion = audio.duration
         
-        # 5. Descargar y preparar videos
+        # 3. Buscar y descargar videos
+        videos = buscar_videos(prompt) or buscar_videos("nature")
         clips = []
-        for i, video in enumerate(videos_data):
+        
+        for i, video in enumerate(videos):
             try:
-                # Seleccionar la mejor calidad disponible
-                if 'video_files' not in video or not video['video_files']:
-                    continue
-                    
-                video_file = max(
-                    video['video_files'], 
-                    key=lambda x: x.get('width', 0) * x.get('height', 0)
-                )
-                video_url = video_file['link']
-                temp_path = f"temp_video_{i}.mp4"
+                video_file = max(video['video_files'], key=lambda x: x.get('width', 0))
+                temp_file = f"temp_vid_{i}.mp4"
+                
+                with requests.get(video_file['link'], 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)
                 
-                if descargar_video(video_url, temp_path):
-                    clip = VideoFileClip(temp_path)
-                    
-                    # Calcular duración proporcional para cada clip
-                    duracion_clip = duracion_total / len(videos_data)
-                    
-                    # Ajustar clip a la duración requerida
-                    if clip.duration < duracion_clip:
-                        clip = clip.loop(duration=duracion_clip)
-                    else:
-                        clip = clip.subclip(0, duracion_clip)
-                    
-                    clips.append(clip)
+                clip = VideoFileClip(temp_file)
+                clip = clip.subclip(0, min(10, clip.duration))  # Máximo 10 segundos por clip
+                clips.append(clip)
             except Exception as e:
                 logger.error(f"Error procesando video {i}: {str(e)}")
         
+        # 4. Crear video final
         if not clips:
-            # Crear video de fondo negro si no hay videos
-            clip = ColorClip(size=(1280, 720), color=(0, 0, 0), duration=duracion_total)
-            clips = [clip]
+            final_clip = ColorClip((1280, 720), (0, 0, 0), duration=duracion)
+        else:
+            final_clip = concatenate_videoclips(clips).set_duration(duracion)
         
-        # 6. Combinar videos
-        final_clip = concatenate_videoclips(clips, method="compose")
         final_clip = final_clip.set_audio(audio)
         
-        # 7. Aplicar música de fondo si existe
-        if musica:
-            try:
-                musica_clip = AudioFileClip(musica.name)
-                if musica_clip.duration < duracion_total:
-                    musica_clip = musica_clip.loop(duration=duracion_total)
-                else:
-                    musica_clip = musica_clip.subclip(0, duracion_total)
-                
-                audio_final = CompositeAudioClip([
-                    audio.volumex(1.0),
-                    musica_clip.volumex(0.25)
-                ])
-                final_clip = final_clip.set_audio(audio_final)
-            except Exception as e:
-                logger.error(f"Error procesando música: {str(e)}")
-        
-        # 8. Exportar video final
-        output_path = f"video_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
+        output_file = f"video_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
         final_clip.write_videofile(
-            output_path,
+            output_file,
             fps=24,
             codec="libx264",
             audio_codec="aac",
-            threads=4,
+            threads=2,
             preset='fast'
         )
         
-        logger.info(f"Video generado exitosamente: {output_path}")
-        return output_path
+        logger.info(f"Video creado en {time.time()-start_time:.2f} segundos")
+        return output_file
         
     except Exception as e:
-        logger.error(f"ERROR: {str(e)}")
+        logger.error(f"Error crítico: {str(e)}")
         return None
     finally:
-        # Limpieza garantizada
-        if os.path.exists(voz_archivo):
-            os.remove(voz_archivo)
-        for i in range(5):
-            temp_file = f"temp_video_{i}.mp4"
-            if os.path.exists(temp_file):
-                os.remove(temp_file)
+        # Limpieza
+        for f in [voz_file, *[f"temp_vid_{i}.mp4" for i in range(3)]]:
+            if os.path.exists(f):
+                os.remove(f)
 
-# Interfaz mejorada
-with gr.Blocks(title="Generador de Videos", theme=gr.themes.Soft()) as app:
-    gr.Markdown("# 🎬 GENERADOR AUTOMÁTICO DE VIDEOS")
-    
+# Interfaz simplificada y funcional
+with gr.Blocks(title="Generador de Videos") as app:
     with gr.Row():
         with gr.Column():
-            prompt = gr.Textbox(
-                label="Tema del video", 
-                placeholder="Ej: 'La historia de la piratería en el Caribe'",
-                max_lines=1
-            )
-            custom_script = gr.TextArea(
-                label="Guion personalizado (opcional)", 
-                placeholder="Pega tu guion completo aquí...",
-                lines=8,
-                max_lines=20
-            )
-            voz = gr.Dropdown(
-                label="Voz Narradora", 
-                choices=VOICES, 
-                value=VOICES[0],
-                interactive=True
-            )
-            musica = gr.File(
-                label="Música de fondo (opcional)", 
-                file_types=["audio"],
-                type="filepath"
-            )
-            btn = gr.Button("Generar Video", variant="primary")
-            
+            tema = gr.Textbox(label="Tema del video")
+            guion = gr.TextArea(label="Guion personalizado (opcional)", lines=5)
+            voz = gr.Dropdown(label="Voz", choices=VOICES, value=VOICES[0])
+            btn = gr.Button("Generar Video")
+        
         with gr.Column():
-            output = gr.Video(
-                label="Video Resultado", 
-                format="mp4",
-                interactive=False
-            )
-    
+            salida = gr.Video(label="Resultado")
+
     btn.click(
         fn=crear_video,
-        inputs=[prompt, custom_script, voz, musica],
-        outputs=output
+        inputs=[tema, guion, voz],
+        outputs=salida
     )
 
 if __name__ == "__main__":
-    app.launch(server_name="0.0.0.0", server_port=7860)
+    app.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False  # Desactivado para evitar problemas
+    )