Spaces:
Sleeping
Sleeping
| import os | |
| import asyncio | |
| import logging | |
| import tempfile | |
| import requests | |
| from datetime import datetime | |
| from moviepy.editor import VideoFileClip, concatenate_videoclips, AudioFileClip, CompositeAudioClip | |
| import edge_tts | |
| import gradio as gr | |
| from transformers import GPT2Tokenizer, GPT2LMHeadModel | |
| import torch | |
| # --- Importar la librería de Pexels --- | |
| from pexels_api import API # ¡Asegúrate de instalarla: pip install pexels-api! | |
| # --- Configuración de Logging --- | |
| logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') | |
| logger = logging.getLogger(__name__) | |
| # --- Clave API de Pexels --- | |
| # IMPORTANTE: No uses tu clave API directamente aquí en un repositorio público. | |
| # Lo ideal es cargarla desde una variable de entorno o un archivo de configuración SEGURO. | |
| # Para Hugging Face Spaces, puedes añadirla como un "Secret" llamado PEXELS_API_KEY. | |
| PEXELS_API_KEY = os.environ.get("PEXELS_API_KEY", "TU_CLAVE_API_PEXELS_AQUI") # Reemplaza "TU_CLAVE_API_PEXELS_AQUI" con tu clave si pruebas localmente sin variables de entorno | |
| pexels_api = API(PEXELS_API_KEY) | |
| # --- Inicialización de Tokenizer y Modelo GPT-2 --- | |
| MODEL_NAME = "gpt2-small" | |
| try: | |
| tokenizer = GPT2Tokenizer.from_pretrained(MODEL_NAME) | |
| model = GPT2LMHeadModel.from_pretrained(MODEL_NAME).eval() | |
| if tokenizer.pad_token is None: | |
| tokenizer.pad_token = tokenizer.eos_token | |
| logger.info(f"Modelo GPT-2 '{MODEL_NAME}' cargado exitosamente.") | |
| except Exception as e: | |
| logger.error(f"Error al cargar el modelo GPT-2 '{MODEL_NAME}': {e}") | |
| tokenizer = None | |
| model = None | |
| # --- Funciones de Utilidad --- | |
| def generate_script(prompt, max_length=250): | |
| if not tokenizer or not model: | |
| logger.error("Modelo GPT-2 no disponible para generar guion.") | |
| return "Lo siento, el generador de guiones no está disponible en este momento." | |
| logger.info("Generando guion con GPT-2...") | |
| try: | |
| inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=512) | |
| device = torch.device("cuda" if torch.cuda.is_available() else "cpu") | |
| inputs = {k: v.to(device) for k, v in inputs.items()} | |
| model.to(device) | |
| with torch.no_grad(): | |
| outputs = model.generate( | |
| **inputs, | |
| max_length=max_length, | |
| do_sample=True, | |
| top_p=0.95, | |
| top_k=60, | |
| temperature=0.9, | |
| pad_token_id=tokenizer.pad_token_id, | |
| eos_token_id=tokenizer.eos_token_id | |
| ) | |
| text = tokenizer.decode(outputs[0], skip_special_tokens=True) | |
| logger.info(f"Guion generado (longitud: {len(text)} caracteres): {text[:200]}...") | |
| return text | |
| except Exception as e: | |
| logger.error(f"Error durante la generación del guion: {e}") | |
| return "No se pudo generar el guion. Intenta con otro prompt o un guion propio." | |
| async def text_to_speech(text, voice="es-ES-ElviraNeural", output_path="voz.mp3"): | |
| logger.info(f"Generando audio TTS para: '{text[:100]}...'") | |
| try: | |
| communicate = edge_tts.Communicate(text, voice) | |
| await communicate.save(output_path) | |
| logger.info(f"Audio TTS guardado en {output_path}") | |
| except Exception as e: | |
| logger.error(f"Error al generar audio TTS: {e}") | |
| raise | |
| def download_video_sample(url): | |
| if not url: | |
| return None | |
| logger.info(f"Intentando descargar video de: {url}") | |
| tmp = None | |
| try: | |
| tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") | |
| response = requests.get(url, stream=True, timeout=20) # Aumentar timeout para videos más grandes | |
| response.raise_for_status() | |
| for chunk in response.iter_content(chunk_size=8192): | |
| if chunk: | |
| tmp.write(chunk) | |
| tmp.close() | |
| logger.info(f"Video descargado a: {tmp.name}") | |
| return tmp.name | |
| except requests.exceptions.RequestException as e: | |
| logger.error(f"Error de red/HTTP al descargar el video {url}: {e}") | |
| if tmp and os.path.exists(tmp.name): | |
| os.remove(tmp.name) | |
| return None | |
| except Exception as e: | |
| logger.error(f"Error inesperado al descargar video {url}: {e}") | |
| if tmp and os.path.exists(tmp.name): | |
| os.remove(tmp.name) | |
| return None | |
| def loop_audio_to_length(audio_clip, target_duration): | |
| if audio_clip.duration >= target_duration: | |
| return audio_clip.subclip(0, target_duration) | |
| loops = int(target_duration / audio_clip.duration) + 1 | |
| audios = [audio_clip] * loops | |
| concatenated = concatenate_videoclips(audios) | |
| return concatenated.subclip(0, target_duration) | |
| # --- NUEVA FUNCIÓN: Búsqueda de videos en Pexels --- | |
| def search_pexels_videos(query, num_videos=3, min_duration_sec=5): | |
| """ | |
| Busca videos en Pexels basados en una query y devuelve una lista de URLs de descarga. | |
| """ | |
| if not PEXELS_API_KEY or PEXELS_API_KEY == "TU_CLAVE_API_PEXELS_AQUI": | |
| logger.warning("PEXELS_API_KEY no configurada. No se buscarán videos en Pexels.") | |
| return [] | |
| logger.info(f"Buscando {num_videos} videos en Pexels para la query: '{query}'") | |
| video_urls = [] | |
| try: | |
| # Pexels API para videos: search_videos(query, orientation, size, per_page, page) | |
| # La API de Pexels no permite filtrar directamente por duración mínima. | |
| # Tendremos que filtrar después de obtener los resultados. | |
| pexels_api.search_videos(query, per_page=num_videos * 3) # Pedimos más por si algunos no cumplen duración | |
| videos = pexels_api.get_videos() | |
| if not videos: | |
| logger.warning(f"No se encontraron videos en Pexels para la query: '{query}'") | |
| return [] | |
| for video in videos: | |
| # Pexels devuelve diferentes archivos de video (quality). Buscamos la más adecuada (p.ej., medium o large). | |
| # También verificamos la duración si está disponible en los metadatos de Pexels. | |
| if video.get('duration') and video['duration'] < min_duration_sec: | |
| logger.info(f"Saltando video {video['id']} de Pexels por duración ({video['duration']}s < {min_duration_sec}s).") | |
| continue | |
| # Buscar la URL de descarga del video de mayor calidad disponible o una calidad aceptable. | |
| # Los archivos vienen en una lista 'video_files'. | |
| best_quality_url = None | |
| for file in video.get('video_files', []): | |
| # Preferir calidades como 'hd', 'sd', 'medium', 'large' | |
| if file.get('quality') in ['hd', 'sd', 'medium', 'large'] and file.get('link'): | |
| best_quality_url = file['link'] | |
| break # Tomar el primero que cumpla | |
| elif file.get('link'): # Si no hay calidad específica, tomar cualquier enlace válido | |
| best_quality_url = file['link'] | |
| if best_quality_url: | |
| video_urls.append(best_quality_url) | |
| if len(video_urls) >= num_videos: | |
| break # Suficientes videos | |
| else: | |
| logger.warning(f"No se encontró URL de descarga válida para el video Pexels ID: {video.get('id')}") | |
| logger.info(f"Encontrados {len(video_urls)} URLs de video de Pexels para '{query}'.") | |
| return video_urls | |
| except Exception as e: | |
| logger.error(f"Error al buscar videos en Pexels para '{query}': {e}") | |
| return [] | |
| # --- Función Principal de Creación de Video --- | |
| def crear_video(prompt_type, input_text, musica_url=None): | |
| logger.info(f"Iniciando creación de video. Tipo de prompt: {prompt_type}") | |
| guion = "" | |
| if prompt_type == "Generar Guion con IA": | |
| guion = generate_script(input_text) | |
| if not guion or guion == "No se pudo generar el guion. Intenta con otro prompt o un guion propio.": | |
| raise ValueError(guion) | |
| else: # prompt_type == "Usar Mi Guion" | |
| guion = input_text | |
| if not guion.strip(): | |
| raise ValueError("Por favor, introduce tu guion.") | |
| if not guion.strip(): | |
| raise ValueError("El guion está vacío. No se puede proceder.") | |
| temp_files = [] | |
| clips = [] | |
| try: | |
| # 1. Generar audio TTS | |
| voz_archivo = os.path.join(tempfile.gettempdir(), f"voz_temp_{os.getpid()}.mp3") | |
| temp_files.append(voz_archivo) | |
| asyncio.run(text_to_speech(guion, output_path=voz_archivo)) | |
| audio_tts = AudioFileClip(voz_archivo) | |
| # 2. Búsqueda y descarga de videos con Pexels | |
| # Usamos el guion o el prompt inicial para la búsqueda en Pexels | |
| search_query = input_text if prompt_type == "Generar Guion con IA" else guion.split('.')[0] # Usar primera frase del guion | |
| pexels_video_urls = search_pexels_videos(search_query, num_videos=4, min_duration_sec=7) # Pedimos 4, min 7s | |
| # Si Pexels no devuelve nada o falla, podemos tener unas URLs de fallback | |
| if not pexels_video_urls: | |
| logger.warning("Pexels no devolvió videos. Usando videos de ejemplo de fallback.") | |
| pexels_video_urls = [ | |
| "https://www.learningcontainer.com/wp-content/uploads/2020/05/sample-mp4-file.mp4", | |
| "https://file-examples.com/storage/fe2c91b5c46522c0734a74a/2017/04/file_example_MP4_480_1_5MG.mp4", | |
| "https://sample-videos.com/video123/mp4/720/big_buck_bunny_720p_1mb.mp4", | |
| "https://test-videos.co.uk/vids/bigbuckbunny/mp4/720/big_buck_bunny_720p_1mb.mp4" | |
| ] | |
| valid_clip_found = False | |
| for url in pexels_video_urls: | |
| video_path = download_video_sample(url) | |
| if video_path: | |
| temp_files.append(video_path) | |
| try: | |
| clip = VideoFileClip(video_path).subclip(0, min(15, VideoFileClip(video_path).duration)) | |
| if clip.duration > 1: | |
| clips.append(clip) | |
| valid_clip_found = True | |
| else: | |
| logger.warning(f"Clip de video muy corto ({clip.duration:.2f}s) de {url}, omitiendo.") | |
| clip.close() | |
| except Exception as e: | |
| logger.warning(f"No se pudo cargar o procesar el clip de video {video_path} de {url}: {e}") | |
| else: | |
| logger.warning(f"No se pudo descargar el video de la URL: {url}") | |
| if not valid_clip_found or not clips: | |
| logger.error("No se pudieron obtener clips de video válidos. Abortando creación de video.") | |
| raise ValueError("No se encontraron clips de video válidos. Asegúrate de que las URLs de Pexels o fallback sean correctas y accesibles.") | |
| # 3. Concatenar videos | |
| video_base = concatenate_videoclips(clips, method="compose") | |
| logger.info(f"Video base concatenado, duración: {video_base.duration:.2f}s") | |
| if video_base.duration < audio_tts.duration: | |
| logger.info(f"Duración del video ({video_base.duration:.2f}s) es menor que la del audio TTS ({audio_tts.duration:.2f}s). Repitiendo video.") | |
| num_repeats = int(audio_tts.duration / video_base.duration) + 1 | |
| repeated_clips = [video_base] * num_repeats | |
| video_base = concatenate_videoclips(repeated_clips, method="compose") | |
| final_video_duration = audio_tts.duration | |
| # 4. Música de fondo en loop | |
| mezcla_audio = audio_tts | |
| if musica_url and musica_url.strip(): | |
| musica_path = download_video_sample(musica_url) | |
| if musica_path: | |
| temp_files.append(musica_path) | |
| try: | |
| musica_audio = AudioFileClip(musica_path) | |
| musica_loop = loop_audio_to_length(musica_audio, final_video_duration) | |
| mezcla_audio = CompositeAudioClip([musica_loop.volumex(0.3), audio_tts.set_duration(final_video_duration).volumex(1.0)]) | |
| logger.info("Música de fondo añadida y mezclada.") | |
| except Exception as e: | |
| logger.warning(f"No se pudo procesar la música de fondo de {musica_url}: {e}. Se usará solo la voz.") | |
| else: | |
| logger.warning(f"No se pudo descargar la música de {musica_url}. Se usará solo la voz.") | |
| # 5. Asignar audio al video y ajustar duración | |
| video_final = video_base.set_audio(mezcla_audio).subclip(0, final_video_duration) | |
| logger.info(f"Video final configurado con audio. Duración final: {video_final.duration:.2f}s") | |
| # 6. Guardar video final | |
| output_dir = "generated_videos" | |
| os.makedirs(output_dir, exist_ok=True) | |
| output_path = os.path.join(output_dir, f"video_output_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4") | |
| logger.info(f"Escribiendo video final a: {output_path}") | |
| video_final.write_videofile(output_path, fps=24, threads=4, logger=None, preset="medium", codec="libx264") | |
| logger.info(f"Video generado exitosamente en: {output_path}") | |
| return output_path | |
| except Exception as e: | |
| logger.error(f"Error general en la creación del video: {e}", exc_info=True) | |
| raise e | |
| finally: | |
| for f in temp_files: | |
| if os.path.exists(f): | |
| try: | |
| os.remove(f) | |
| logger.info(f"Archivo temporal eliminado: {f}") | |
| except Exception as e: | |
| logger.warning(f"No se pudo eliminar el archivo temporal {f}: {e}") | |
| for clip in clips: | |
| if clip: | |
| clip.close() | |
| if 'audio_tts' in locals() and audio_tts: | |
| audio_tts.close() | |
| if 'musica_audio' in locals() and musica_audio: | |
| musica_audio.close() | |
| if 'video_final' in locals() and video_final: | |
| video_final.close() | |
| if 'video_base' in locals() and video_base: | |
| video_base.close() | |
| def run_app(prompt_type, prompt_ia, prompt_manual, musica_url): | |
| input_text = "" | |
| if prompt_type == "Generar Guion con IA": | |
| input_text = prompt_ia | |
| if not input_text.strip(): | |
| raise gr.Error("Por favor, introduce un tema para generar el guion.") | |
| else: | |
| input_text = prompt_manual | |
| if not input_text.strip(): | |
| raise gr.Error("Por favor, introduce tu guion.") | |
| logger.info(f"Solicitud recibida: Tipo='{prompt_type}', Input='{input_text[:50]}...', Música='{musica_url}'") | |
| try: | |
| video_path = crear_video(prompt_type, input_text, musica_url if musica_url.strip() else None) | |
| if video_path: | |
| logger.info(f"Proceso completado. Video disponible en: {video_path}") | |
| return video_path, gr.update(value="¡Video generado exitosamente!") | |
| else: | |
| raise gr.Error("Hubo un problema desconocido al generar el video. Revisa los logs.") | |
| except ValueError as ve: | |
| logger.error(f"Error de validación: {ve}") | |
| return None, gr.update(value=f"Error: {ve}", text_color="red") | |
| except Exception as e: | |
| logger.error(f"Error inesperado al ejecutar la aplicación: {e}", exc_info=True) | |
| return None, gr.update(value=f"Ocurrió un error grave: {e}. Por favor, inténtalo de nuevo.", text_color="red") | |
| # --- Interfaz de Gradio --- | |
| with gr.Blocks() as app: | |
| gr.Markdown(""" | |
| ### 🎬 Generador de Video Inteligente con Pexels 🚀 | |
| Crea videos con guiones generados por IA o propios, voz automática y videos de stock relevantes de Pexels. | |
| """) | |
| with gr.Tab("Generar Video"): | |
| with gr.Row(): | |
| prompt_type = gr.Radio( | |
| ["Generar Guion con IA", "Usar Mi Guion"], | |
| label="Método de Guion", | |
| value="Generar Guion con IA" | |
| ) | |
| with gr.Column(visible=True) as ia_guion_column: | |
| prompt_ia = gr.Textbox( | |
| label="Tema para Generar Guion (con IA)", | |
| lines=2, | |
| placeholder="Ej: Las maravillas del universo y las estrellas." | |
| ) | |
| with gr.Column(visible=False) as manual_guion_column: | |
| prompt_manual = gr.Textbox( | |
| label="Introduce Tu Guion Propio", | |
| lines=5, | |
| placeholder="Ej: Hola a todos, hoy hablaremos de un tema fascinante..." | |
| ) | |
| musica_input = gr.Textbox( | |
| label="URL de Música de Fondo (opcional, MP3 recomendado)", | |
| placeholder="Ej: https://www.soundhelix.com/examples/mp3/SoundHelix-Song-1.mp3" | |
| ) | |
| boton = gr.Button("✨ Generar Video") | |
| with gr.Column(): | |
| salida_video = gr.Video(label="Video Generado", interactive=False) | |
| estado_mensaje = gr.Textbox(label="Estado del Proceso", interactive=False, value="") | |
| prompt_type.change( | |
| fn=lambda value: (gr.update(visible=value == "Generar Guion con IA"), | |
| gr.update(visible=value == "Usar Mi Guion")), | |
| inputs=prompt_type, | |
| outputs=[ia_guion_column, manual_guion_column] | |
| ) | |
| boton.click( | |
| fn=lambda: (None, gr.update(value="Iniciando generación... Esto puede tardar varios minutos (descarga de videos).")), | |
| outputs=[salida_video, estado_mensaje], | |
| queue=False | |
| ).then( | |
| fn=run_app, | |
| inputs=[prompt_type, prompt_ia, prompt_manual, musica_input], | |
| outputs=[salida_video, estado_mensaje] | |
| ) | |
| prompt_ia.change(fn=lambda: gr.update(value=""), outputs=estado_mensaje, queue=False) | |
| prompt_manual.change(fn=lambda: gr.update(value=""), outputs=estado_mensaje, queue=False) | |
| musica_input.change(fn=lambda: gr.update(value=""), outputs=estado_mensaje, queue=False) | |
| if __name__ == "__main__": | |
| logger.info("Iniciando aplicación Gradio para Hugging Face Spaces...") | |
| app.launch(server_name="0.0.0.0", server_port=7860, share=False) |