import os import re import requests import gradio as gr from moviepy.editor import * import edge_tts import tempfile import logging from datetime import datetime import numpy as np from sklearn.feature_extraction.text import TfidfVectorizer import nltk from transformers import pipeline import torch import asyncio import time # Configuración inicial nltk.download('punkt', quiet=True) logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') logger = logging.getLogger(__name__) # Configuración de modelos PEXELS_API_KEY = os.getenv("PEXELS_API_KEY") MODEL_NAME = "DeepESP/gpt2-spanish" # Modelo en español # Lista de voces disponibles VOICES = asyncio.run(edge_tts.list_voices()) VOICE_NAMES = [f"{v['Name']} ({v['Gender']}, {v['Locale']})" for v in VOICES] def generar_guion_profesional(prompt): """Genera guiones detallados""" generator = pipeline( "text-generation", model=MODEL_NAME, device=0 if torch.cuda.is_available() else -1 ) response = generator( f"Escribe un guion profesional para un video de YouTube sobre '{prompt}':", max_length=600, temperature=0.7, num_return_sequences=1 ) return response[0]['generated_text'] def buscar_videos_avanzado(prompt, guion, num_videos=5): """Búsqueda inteligente de videos usando análisis de contenido""" # Dividir el guion en oraciones oraciones = nltk.sent_tokenize(guion) # Extraer palabras clave con TF-IDF 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() indices_importantes = np.argsort(scores)[-5:] palabras_clave = [palabras[i] for i in indices_importantes] # Mezclar palabras clave del prompt y del guion palabras_prompt = re.findall(r'\b\w{4,}\b', prompt.lower()) todas_palabras = list(set(palabras_clave + palabras_prompt))[:5] # Buscar en Pexels headers = {"Authorization": PEXELS_API_KEY} response = requests.get( f"https://api.pexels.com/videos/search?query={'+'.join(todas_palabras)}&per_page={num_videos}", headers=headers, timeout=10 ) videos = response.json().get('videos', []) # Seleccionar videos de mejor calidad return sorted( videos, key=lambda x: x.get('width', 0) * x.get('height', 0), reverse=True )[:num_videos] async def crear_video_profesional(prompt, custom_script, voz_index, musica=None): try: # 1. Generar o usar guion guion = custom_script if custom_script else generar_guion_profesional(prompt) # 2. Seleccionar voz voz_seleccionada = VOICES[voz_index]['ShortName'] # 3. Generar voz voz_archivo = "voz.mp3" await edge_tts.Communicate(guion, voz_seleccionada).save(voz_archivo) audio = AudioFileClip(voz_archivo) duracion_total = audio.duration # 4. Buscar videos relevantes videos_data = buscar_videos_avanzado(prompt, guion) # 5. Descargar y preparar videos clips = [] for video in videos_data: # Seleccionar la mejor calidad de video video_files = sorted( video['video_files'], key=lambda x: x.get('width', 0) * x.get('height', 0), reverse=True ) video_url = video_files[0]['link'] # Descargar video response = requests.get(video_url, stream=True) temp_video = tempfile.NamedTemporaryFile(delete=False, suffix='.mp4') for chunk in response.iter_content(chunk_size=1024*1024): temp_video.write(chunk) temp_video.close() # Crear clip clip = VideoFileClip(temp_video.name) clips.append(clip) # 6. Calcular duración por clip duracion_por_clip = duracion_total / len(clips) # 7. Procesar clips de video clips_procesados = [] for clip in clips: # Si el clip es más corto que la duración asignada, hacer loop if clip.duration < duracion_por_clip: clip = clip.loop(duration=duracion_por_clip) # Si es más largo, recortar else: clip = clip.subclip(0, duracion_por_clip) clips_procesados.append(clip) # 8. Combinar videos video_final = concatenate_videoclips(clips_procesados) # 9. Procesar música 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) # 10. Exportar video output_path = f"video_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4" video_final.write_videofile( output_path, codec="libx264", audio_codec="aac", threads=4, preset='ultrafast', fps=24, logger=None ) return output_path except Exception as e: logger.error(f"ERROR: {str(e)}") return None finally: # Limpieza de archivos temporales if 'voz_archivo' in locals() and os.path.exists(voz_archivo): os.remove(voz_archivo) # Función para ejecutar la tarea asíncrona def run_async_task(prompt, custom_script, voz_index, musica=None): return asyncio.run(crear_video_profesional(prompt, custom_script, voz_index, musica)) # Interfaz profesional con queue deshabilitado with gr.Blocks(theme=gr.themes.Soft(), title="Generador de Videos") as app: gr.Markdown("# 🎬 GENERADOR DE VIDEOS CON IA") with gr.Row(): with gr.Column(scale=1): gr.Markdown("### Configuración") prompt = gr.Textbox(label="Tema principal", placeholder="Ej: 'Los misterios de la antigua Grecia'") custom_script = gr.TextArea( label="Guion personalizado (opcional)", placeholder="Pega aquí tu propio guion completo...", lines=6 ) voz = gr.Dropdown( label="Voz", choices=VOICE_NAMES, value=VOICE_NAMES[0], type="index" ) musica = gr.File(label="Música de fondo (opcional)", file_types=["audio"]) btn = gr.Button("🚀 Generar Video", variant="primary") with gr.Column(scale=2): output = gr.Video(label="Video Resultante", format="mp4") gr.Examples( examples=[ ["Los secretos de las pirámides egipcias", "", 5, None], ["La inteligencia artificial en medicina", "", 3, None] ], inputs=[prompt, custom_script, voz, musica], label="Ejemplos" ) # SOLUCIÓN CLAVE: Deshabilitar el sistema de colas btn.click( fn=run_async_task, inputs=[prompt, custom_script, voz, musica], outputs=output, queue=False # Deshabilitar el sistema de colas ) if __name__ == "__main__": app.launch( server_name="0.0.0.0", server_port=7860, enable_queue=False # Asegurar que el queue esté deshabilitado globalmente )