Update app.py

app.py

@@ -14,38 +14,24 @@ import random
 from transformers import pipeline
 import torch
 import asyncio
-import nest_asyncio
 from nltk.tokenize import sent_tokenize
 
-# Setup
 nltk.download('punkt', quiet=True)
-nest_asyncio.apply()
-
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
 PEXELS_API_KEY = os.getenv("PEXELS_API_KEY")
 MODEL_NAME = "DeepESP/gpt2-spanish"
 
-VOICE_NAMES, VOICES = [], []
-
 async def get_voices():
-    voces = await edge_tts.list_voices()
-    voice_names = [f"{v['Name']} ({v['Gender']}, {v['LocaleName']})" for v in voces]
-    return voice_names, voces
-
-async def get_and_set_voices():
-    global VOICE_NAMES, VOICES
     try:
-        VOICE_NAMES, VOICES = await get_voices()
-        if not VOICES:
-            raise Exception("No se encontraron voces.")
-    except Exception as e:
-        logger.warning(f"Fallo al cargar voces: {e}")
-        VOICE_NAMES = ["Voz Predeterminada (Femenino, es-ES)"]
-        VOICES = [{'ShortName': 'es-ES-ElviraNeural'}]
+        voices = await edge_tts.list_voices()
+        voice_names = [f"{v['Name']} ({v['Gender']}, {v['LocaleName']})" for v in voices]
+        return voice_names, voices
+    except:
+        return ["Voz Predeterminada (Femenino, es-ES)"], [{'ShortName': 'es-ES-ElviraNeural'}]
 
-asyncio.get_event_loop().run_until_complete(get_and_set_voices())
+VOICE_NAMES, VOICES = asyncio.run(get_voices())
 
 def generar_guion_profesional(prompt):
     try:
@@ -56,8 +42,11 @@ def generar_guion_profesional(prompt):
         )
         response = generator(
             f"Escribe un guion profesional para un video de YouTube sobre '{prompt}'. "
-            "Incluye introducción, desarrollo en 3 secciones y conclusión:",
-            max_length=1000,
+            "La estructura debe incluir:\n"
+            "1. Introducción atractiva\n"
+            "2. Tres secciones detalladas con subtítulos\n"
+            "3. Conclusión impactante\n"
+            "Usa un estilo natural para narración:",
             temperature=0.7,
             top_k=50,
             top_p=0.95,
@@ -68,95 +57,130 @@ def generar_guion_profesional(prompt):
             raise ValueError("Guion demasiado breve")
         return guion
     except Exception as e:
-        logger.error(f"Error generando guion: {e}")
-        return f"""Introducción sobre {prompt}. 
-        Sección 1: Orígenes e historia.
-        Sección 2: Estado actual.
-        Sección 3: Futuro e impacto.
-        Conclusión reflexiva."""
+        logger.error(f"Error generando guion: {str(e)}")
+        temas = {
+            "historia": ["orígenes", "eventos clave", "impacto actual"],
+            "tecnología": ["funcionamiento", "aplicaciones", "futuro"],
+            "ciencia": ["teorías", "evidencia", "implicaciones"],
+            "misterio": ["enigma", "teorías", "explicaciones"],
+            "arte": ["orígenes", "características", "influencia"]
+        }
+        categoria = "general"
+        for key in temas:
+            if key in prompt.lower():
+                categoria = key
+                break
+        puntos_clave = temas.get(categoria, ["aspectos importantes", "datos relevantes", "conclusiones"])
+        return f"""
+        ¡Hola a todos! Bienvenidos a este análisis completo sobre {prompt}. 
+        En este video exploraremos a fondo este fascinante tema a través de tres secciones clave.
+        
+        SECCIÓN 1: {puntos_clave[0].capitalize()}
+        Comenzaremos analizando los {puntos_clave[0]} fundamentales. 
+        Esto nos permitirá entender mejor la base de {prompt}.
+        
+        SECCIÓN 2: {puntos_clave[1].capitalize()}
+        En esta parte, examinaremos los {puntos_clave[1]} más relevantes 
+        y cómo se relacionan con el tema principal.
+        
+        SECCIÓN 3: {puntos_clave[2].capitalize()}
+        Finalmente, exploraremos las {puntos_clave[2]} 
+        y qué significan para el futuro de este campo.
+        
+        ¿Listos para profundizar? ¡Empecemos!
+        """
 
 def buscar_videos_avanzado(prompt, guion, num_videos=5):
     try:
         oraciones = sent_tokenize(guion)
-        vectorizer = TfidfVectorizer(stop_words='spanish')
+        vectorizer = TfidfVectorizer(stop_words=['el', 'la', 'los', 'las', 'de', 'en', 'y', 'que'])
         tfidf = vectorizer.fit_transform(oraciones)
         palabras = vectorizer.get_feature_names_out()
         scores = np.asarray(tfidf.sum(axis=0)).ravel()
-        top_indices = np.argsort(scores)[-5:]
-        palabras_clave = [palabras[i] for i in top_indices]
-
+        indices_importantes = np.argsort(scores)[-5:]
+        palabras_clave = [palabras[i] for i in indices_importantes]
         palabras_prompt = re.findall(r'\b\w{4,}\b', prompt.lower())
-        todas = list(set(palabras_clave + palabras_prompt))[:5]
-
+        todas_palabras = list(set(palabras_clave + palabras_prompt))[:5]
         headers = {"Authorization": PEXELS_API_KEY}
         response = requests.get(
-            f"https://api.pexels.com/videos/search?query={'+'.join(todas)}&per_page={num_videos}",
+            f"https://api.pexels.com/videos/search?query={'+'.join(todas_palabras)}&per_page={num_videos}",
             headers=headers,
             timeout=15
         )
-        return response.json().get('videos', [])
+        videos = response.json().get('videos', [])
+        logger.info(f"Palabras clave usadas: {todas_palabras}")
+        videos_ordenados = sorted(
+            videos,
+            key=lambda x: x.get('width', 0) * x.get('height', 0),
+            reverse=True
+        )
+        return videos_ordenados[:num_videos]
     except Exception as e:
-        logger.error(f"Error buscando videos: {e}")
-        return []
+        logger.error(f"Error en búsqueda de videos: {str(e)}")
+        response = requests.get(
+            f"https://api.pexels.com/videos/search?query={prompt}&per_page={num_videos}",
+            headers={"Authorization": PEXELS_API_KEY},
+            timeout=10
+        )
+        return response.json().get('videos', [])[:num_videos]
 
 async def crear_video_profesional(prompt, custom_script, voz_index, musica=None):
-    voz_archivo = "voz.mp3"
     try:
-        guion = custom_script if custom_script.strip() else generar_guion_profesional(prompt)
+        guion = custom_script if custom_script else generar_guion_profesional(prompt)
+        logger.info(f"Guion generado ({len(guion.split())} palabras)")
         voz_seleccionada = VOICES[voz_index]['ShortName'] if VOICES else 'es-ES-ElviraNeural'
-
-        # Generar audio
+        voz_archivo = "voz.mp3"
         await edge_tts.Communicate(guion, voz_seleccionada).save(voz_archivo)
         audio = AudioFileClip(voz_archivo)
-
-        # Obtener videos
+        duracion_total = audio.duration
         videos_data = buscar_videos_avanzado(prompt, guion)
         if not videos_data:
             raise Exception("No se encontraron videos")
-
-        # Procesar videos
         clips = []
         for video in videos_data[:3]:
             video_file = next((vf for vf in video['video_files'] if vf['quality'] == 'sd'), video['video_files'][0])
             with tempfile.NamedTemporaryFile(suffix='.mp4', delete=False) as temp_video:
                 response = requests.get(video_file['link'], stream=True)
-                for chunk in response.iter_content(chunk_size=1024 * 1024):
+                for chunk in response.iter_content(chunk_size=1024*1024):
                     temp_video.write(chunk)
                 clip = VideoFileClip(temp_video.name).subclip(0, min(10, video['duration']))
                 clips.append(clip)
-
-        # Crear video final
         video_final = concatenate_videoclips(clips)
+        if musica:
+            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 = CompositeAudioClip([audio, musica_clip.volumex(0.25)])
         video_final = video_final.set_audio(audio)
-
         output_path = f"video_output_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
         video_final.write_videofile(output_path, fps=24, threads=2)
         return output_path
-
     except Exception as e:
-        logger.error(f"Error crítico: {e}")
+        logger.error(f"Error crítico: {str(e)}")
         return None
     finally:
-        if os.path.exists(voz_archivo):
-            os.remove(voz_archivo)
+        if os.path.exists("voz.mp3"):
+            os.remove("voz.mp3")
+
+def run_async_func(prompt, custom_script, voz_index, musica=None):
+    return asyncio.run(crear_video_profesional(prompt, custom_script, voz_index, musica))
 
-# Gradio app
 with gr.Blocks(title="Generador de Videos") as app:
     with gr.Row():
         with gr.Column():
             prompt = gr.Textbox(label="Tema del video")
             custom_script = gr.TextArea(label="Guión personalizado (opcional)")
             voz = gr.Dropdown(VOICE_NAMES, label="Voz", value=VOICE_NAMES[0])
+            musica = gr.File(label="Música de fondo (opcional)", file_types=["audio"])
             btn = gr.Button("Generar Video", variant="primary")
         with gr.Column():
             output = gr.Video(label="Resultado", format="mp4")
 
-    async def wrapper(p, cs, v):
-        return await crear_video_profesional(p, cs, VOICE_NAMES.index(v))
-
     btn.click(
-        fn=wrapper,
-        inputs=[prompt, custom_script, voz],
+        fn=lambda p, cs, v, m: asyncio.run(crear_video_profesional(p, cs, VOICE_NAMES.index(v), m)),
+        inputs=[prompt, custom_script, voz, musica],
         outputs=output
     )