Update app.py

app.py

@@ -9,14 +9,13 @@ 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
-warnings.filterwarnings("ignore", category=UserWarning, module="transformers")
+# Suprimir warnings no deseados
+warnings.filterwarnings("ignore", category=UserWarning)
 warnings.filterwarnings("ignore", category=DeprecationWarning)
 
 PEXELS_API_KEY = os.getenv("PEXELS_API_KEY")
@@ -25,51 +24,51 @@ PEXELS_API_KEY = os.getenv("PEXELS_API_KEY")
 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-US-JennyNeural", "fr-FR-DeniseNeural", "de-DE-KatjaNeural"
 ]
 
-# 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
+# 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
 
-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
-    
+def generar_texto(tema):
+    """Genera texto largo sobre el tema sin estructuras predefinidas"""
     if model is None or tokenizer is None:
-        return f"Texto sobre {tema}. " * 100
+        return f"Contenido sobre {tema}. " * 50
     
     try:
-        inputs = tokenizer(f"Escribe un texto largo sobre {tema}", return_tensors="pt", truncation=True)
+        # Prompt directo y simple
+        prompt = f"Describe detalladamente {tema}"
         
+        # 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=1000,
+            max_length=800,
             do_sample=True,
             temperature=0.7,
-            top_k=50,
+            top_k=40,
             num_return_sequences=1,
             pad_token_id=tokenizer.eos_token_id
         )
         
-        return tokenizer.decode(outputs[0], skip_special_tokens=True)
+        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"Contenido generado sobre {tema}. " * 100
+        return f"Texto generado sobre {tema}. " * 50
 
-def buscar_videos(tema):
-    """Busca videos en Pexels con manejo de errores mejorado"""
+def obtener_videos(tema):
+    """Obtiene videos de Pexels con manejo robusto de errores"""
     try:
         headers = {"Authorization": PEXELS_API_KEY}
         response = requests.get(
@@ -79,47 +78,49 @@ def buscar_videos(tema):
         )
         return response.json().get("videos", [])[:3]
     except Exception as e:
-        logger.error(f"Error buscando videos: {str(e)}")
+        logger.error(f"Error obteniendo videos: {str(e)}")
         return []
 
-def crear_video(prompt, custom_script, voz_seleccionada, musica=None):
+def crear_video(prompt, voz_seleccionada):
     try:
-        start_time = time.time()
+        # 1. Generar texto
+        texto = generar_texto(prompt)
+        logger.info(f"Texto generado: {len(texto)} caracteres")
         
-        # 1. Generar guión
-        guion = generar_guion(prompt, custom_script)
-        logger.info(f"Guion generado ({len(guion)} caracteres)")
-        
-        # 2. Generar voz
+        # 2. Crear narración de voz
         voz_file = "narracion.mp3"
         subprocess.run([
             'edge-tts',
             '--voice', voz_seleccionada,
-            '--text', guion,
+            '--text', texto,
             '--write-media', voz_file
         ], check=True)
         
         audio = AudioFileClip(voz_file)
         duracion = audio.duration
         
-        # 3. Buscar y descargar videos
-        videos = buscar_videos(prompt) or buscar_videos("nature")
+        # 3. Obtener y procesar videos
+        videos = obtener_videos(prompt) or obtener_videos("nature")
         clips = []
         
         for i, video in enumerate(videos):
             try:
+                # Seleccionar video de mayor calidad
                 video_file = max(video['video_files'], key=lambda x: x.get('width', 0))
-                temp_file = f"temp_vid_{i}.mp4"
+                temp_file = f"temp_{i}.mp4"
                 
+                # Descargar video
                 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)
                 
+                # Procesar clip
                 clip = VideoFileClip(temp_file)
-                clip = clip.subclip(0, min(10, clip.duration))  # Máximo 10 segundos por clip
-                clips.append(clip)
+                clip_duration = min(duracion/len(videos), clip.duration)
+                clips.append(clip.subclip(0, clip_duration))
+                
             except Exception as e:
                 logger.error(f"Error procesando video {i}: {str(e)}")
         
@@ -131,6 +132,7 @@ def crear_video(prompt, custom_script, voz_seleccionada, musica=None):
         
         final_clip = final_clip.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,
@@ -141,39 +143,40 @@ def crear_video(prompt, custom_script, voz_seleccionada, musica=None):
             preset='fast'
         )
         
-        logger.info(f"Video creado en {time.time()-start_time:.2f} segundos")
         return output_file
         
     except Exception as e:
         logger.error(f"Error crítico: {str(e)}")
         return None
     finally:
-        # Limpieza
-        for f in [voz_file, *[f"temp_vid_{i}.mp4" for i in range(3)]]:
+        # Limpieza de archivos temporales
+        for f in [voz_file, *[f"temp_{i}.mp4" for i in range(3)]]:
             if os.path.exists(f):
-                os.remove(f)
+                try:
+                    os.remove(f)
+                except:
+                    pass
 
-# Interfaz simplificada y funcional
-with gr.Blocks(title="Generador de Videos") as app:
+# Interfaz minimalista
+with gr.Blocks() as app:
     with gr.Row():
         with gr.Column():
             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():
-            salida = gr.Video(label="Resultado")
+            video = gr.Video(label="Resultado")
 
     btn.click(
         fn=crear_video,
-        inputs=[tema, guion, voz],
-        outputs=salida
+        inputs=[tema, voz],
+        outputs=video
     )
 
 if __name__ == "__main__":
     app.launch(
         server_name="0.0.0.0",
         server_port=7860,
-        share=False  # Desactivado para evitar problemas
+        share=False
     )