Update app.py

app.py

@@ -17,15 +17,52 @@ from collections import Counter
 import shutil
 import json
 
-# Configuración de logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+# Configuración de logging MEJORADA
+logging.basicConfig(
+    level=logging.DEBUG,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(),
+        logging.FileHandler('video_generator_full.log', encoding='utf-8')
+    ]
+)
 logger = logging.getLogger(__name__)
+logger.info("="*80)
+logger.info("INICIO DE EJECUCIÓN - GENERADOR DE VIDEOS")
+logger.info("="*80)
 
-# Clave API de Pexels
+# Clave API de Pexels (configuración segura)
 PEXELS_API_KEY = os.environ.get("PEXELS_API_KEY")
+if not PEXELS_API_KEY:
+    logger.critical("NO SE ENCONTRÓ PEXELS_API_KEY EN VARIABLES DE ENTORNO")
+    raise ValueError("API key de Pexels no configurada")
+else:
+    logger.info("API key de Pexels configurada correctamente")
 
-# Buscar videos en Pexels usando API REST - Versión mejorada
+# Inicialización de modelos CON LOGS DETALLADOS
+MODEL_NAME = "datificate/gpt2-small-spanish"
+logger.info(f"Inicializando modelo GPT-2: {MODEL_NAME}")
+try:
+    tokenizer = GPTizer.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 cargado | Vocabulario: {len(tokenizer)} tokens")
+except Exception as e:
+    logger.error(f"FALLA CRÍTICA al cargar GPT-2: {str(e)}", exc_info=True)
+    tokenizer = model = None
+
+logger.info("Cargando modelo KeyBERT...")
+try:
+    kw_model = KeyBERT('distilbert-base-multilingual-cased')
+    logger.info("KeyBERT inicializado correctamente")
+except Exception as e:
+    logger.error(f"FALLA al cargar KeyBERT: {str(e)}", exc_info=True)
+    kw_model = None
+
+# [FUNCIÓN BUSCAR_VIDEOS_PEXELS ORIGINAL CON LOGS AÑADIDOS]
 def buscar_videos_pexels(query, api_key, per_page=5):
+    logger.debug(f"Buscando en Pexels: '{query}' | Resultados: {per_page}")
     headers = {"Authorization": api_key}
     try:
         params = {
@@ -35,6 +72,7 @@ def buscar_videos_pexels(query, api_key, per_page=5):
             "size": "medium"
         }
         
+        logger.debug(f"Params: {params}")
         response = requests.get(
             "https://api.pexels.com/videos/search",
             headers=headers,
@@ -43,52 +81,33 @@ def buscar_videos_pexels(query, api_key, per_page=5):
         )
         response.raise_for_status()
         
-        # Intentar parsear la respuesta
         try:
             data = response.json()
+            logger.info(f"Pexels: {len(data.get('videos', []))} videos encontrados")
             return data.get('videos', [])
         except json.JSONDecodeError:
-            logger.error("Respuesta JSON inválida de Pexels")
+            logger.error(f"Pexels: JSON inválido | Status: {response.status_code} | Respuesta: {response.text[:200]}...")
             return []
             
     except requests.exceptions.RequestException as e:
-        logger.error(f"Error de conexión con Pexels: {e}")
+        logger.error(f"Error de conexión Pexels: {str(e)}")
     except Exception as e:
-        logger.error(f"Error inesperado: {e}")
+        logger.error(f"Error inesperado Pexels: {str(e)}", exc_info=True)
     
     return []
 
-# Inicialización de modelos
-MODEL_NAME = "datificate/gpt2-small-spanish"
-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("Modelo GPT-2 en español cargado")
-except Exception as e:
-    logger.error(f"Error al cargar modelo GPT-2: {e}")
-    tokenizer = model = None
-
-try:
-    kw_model = KeyBERT('distilbert-base-multilingual-cased')
-    logger.info("KeyBERT cargado")
-except Exception as e:
-    logger.error(f"Error al cargar KeyBERT: {e}")
-    kw_model = None
-
-# Función mejorada para generar guiones
-def generate_script(prompt, max_length=150): 
+# [FUNCIÓN GENERATE_SCRIPT ORIGINAL CON LOGS]
+def generate_script(prompt, max_length=150):
+    logger.info(f"Generando guión | Prompt: '{prompt[:50]}...' | Longitud máxima: {max_length}")
     if not tokenizer or not model:
-        return prompt  # Fallback al prompt original
+        logger.warning("Modelos no disponibles - Usando prompt original")
+        return prompt
     
     try:
-        # Prompt mejorado con instrucciones claras
         enhanced_prompt = f"Escribe un guion corto y coherente sobre: {prompt}"
-        
         inputs = tokenizer(enhanced_prompt, return_tensors="pt", truncation=True, max_length=512)
         
-        # Parámetros optimizados para español
+        logger.debug("Generando texto con GPT-2...")
         outputs = model.generate(
             **inputs,
             max_length=max_length,
@@ -100,63 +119,71 @@ def generate_script(prompt, max_length=150):
             pad_token_id=tokenizer.pad_token_id,
             eos_token_id=tokenizer.eos_token_id
         )
-        text = tokenizer.decode(outputs[0], skip_special_tokens=True)
         
-        # Limpiar texto generado
-        text = re.sub(r'<[^>]+>', '', text)  # Eliminar tokens especiales
+        text = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        text = re.sub(r'<[^>]+>', '', text)
         sentences = text.split('.')
+        
         if sentences:
-            text = sentences[0] + '.'  # Tomar la primera oración coherente
+            final_text = sentences[0] + '.'
+            logger.info(f"Guion generado: '{final_text[:100]}...'")
+            return final_text
         return text
     except Exception as e:
-        logger.error(f"Error generando guion: {e}")
-        return prompt  # Fallback al prompt original
+        logger.error(f"Error generando guion: {str(e)}", exc_info=True)
+        return prompt
 
-# Generación de voz
+# [FUNCIÓN TEXT_TO_SPEECH ORIGINAL CON LOGS]
 async def text_to_speech(text, output_path, voice="es-ES-ElviraNeural"):
+    logger.info(f"Convirtiendo texto a voz | Caracteres: {len(text)} | Voz: {voice}")
     try:
         communicate = edge_tts.Communicate(text, voice)
         await communicate.save(output_path)
+        logger.info(f"Audio guardado en: {output_path} | Tamaño: {os.path.getsize(output_path)} bytes")
         return True
     except Exception as e:
-        logger.error(f"Error en TTS: {e}")
+        logger.error(f"Error en TTS: {str(e)}", exc_info=True)
         return False
 
-# Descarga de videos - Versión más robusta
-def download_video_file(url, temp_dir): 
+# [FUNCIÓN DOWNLOAD_VIDEO_FILE ORIGINAL CON LOGS]
+def download_video_file(url, temp_dir):
     if not url:
+        logger.warning("URL de video no proporcionada")
         return None
     
     try:
-        response = requests.get(url, stream=True, timeout=30)
-        response.raise_for_status()
-        
+        logger.info(f"Descargando video desde: {url[:50]}...")
         file_name = f"video_{datetime.now().strftime('%H%M%S%f')}.mp4"
         output_path = os.path.join(temp_dir, file_name)
         
-        with open(output_path, 'wb') as f:
-            for chunk in response.iter_content(chunk_size=8192):
-                f.write(chunk)
+        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)
+        
+        logger.info(f"Video descargado: {output_path} | Tamaño: {os.path.getsize(output_path)} bytes")
         return output_path
     except Exception as e:
-        logger.error(f"Error descargando video: {e}")
+        logger.error(f"Error descargando video: {str(e)}", exc_info=True)
         return None
 
-# Loop para audio
+# [FUNCIÓN LOOP_AUDIO_TO_LENGTH ORIGINAL CON LOGS]
 def loop_audio_to_length(audio_clip, target_duration):
+    logger.debug(f"Ajustando audio | Duración actual: {audio_clip.duration:.2f}s | Objetivo: {target_duration:.2f}s")
     if audio_clip.duration >= target_duration:
         return audio_clip.subclip(0, target_duration)
     
-    loops = int(target_duration / audio_clip.duration) + 1
+    loops = math.ceil(target_duration / audio_clip.duration)
+    logger.debug(f"Creando {loops} loops de audio")
     audios = [audio_clip] * loops
     return concatenate_videoclips(audios).subclip(0, target_duration)
 
-# Extracción de palabras clave robusta - Versión mejorada
+# [FUNCIÓN EXTRACT_VISUAL_KEYWORDS_FROM_SCRIPT ORIGINAL CON LOGS]
 def extract_visual_keywords_from_script(script_text):
-    # Limpiar texto
+    logger.info("Extrayendo palabras clave del guion")
     clean_text = re.sub(r'[^\w\sáéíóúñ]', '', script_text.lower())
     
-    # Método 1: KeyBERT si está disponible
     if kw_model:
         try:
             keywords = kw_model.extract_keywords(
@@ -166,64 +193,74 @@ def extract_visual_keywords_from_script(script_text):
                 top_n=3
             )
             if keywords:
+                logger.debug(f"KeyBERT keywords: {keywords}")
                 return [kw[0].replace(" ", "+") for kw in keywords]
         except Exception as e:
-            logger.warning(f"KeyBERT falló: {e}")
+            logger.warning(f"KeyBERT falló: {str(e)}")
     
-    # Método 2: Frecuencia de palabras (fallback)
     words = clean_text.split()
     stop_words = {"el", "la", "los", "las", "de", "en", "y", "a", "que", "es", "un", "una", "con"}
     keywords = [word for word in words if len(word) > 3 and word not in stop_words]
     
-    # Si aún no hay palabras clave, usar palabras predeterminadas
     if not keywords:
         logger.warning("Usando palabras clave predeterminadas")
         return ["naturaleza", "ciudad", "paisaje"]
     
-    # Contar frecuencia y seleccionar las 3 más comunes
     word_counts = Counter(keywords)
-    return [word.replace(" ", "+") for word, _ in word_counts.most_common(3)]
+    top_keywords = [word.replace(" ", "+") for word, _ in word_counts.most_common(3)]
+    logger.info(f"Palabras clave finales: {top_keywords}")
+    return top_keywords
 
-# Función principal para crear video - Versión mejorada
+# [FUNCIÓN CREAR_VIDEO ORIGINAL CON LOGS]
 def crear_video(prompt_type, input_text, musica_file=None):
-    logger.info(f"Iniciando creación de video: {prompt_type}")
+    logger.info("="*80)
+    logger.info(f"INICIANDO CREACIÓN DE VIDEO | Tipo: {prompt_type}")
+    logger.debug(f"Input: '{input_text[:100]}...'")
     
     # 1. Generar o usar guion
+    start_time = datetime.now()
     if prompt_type == "Generar Guion con IA":
+        logger.info("Generando guion con IA...")
         guion = generate_script(input_text)
     else: 
+        logger.info("Usando guion proporcionado")
         guion = input_text
     
-    logger.info(f"Guion: {guion[:100]}...")
+    logger.info(f"Guion final ({len(guion)} caracteres): '{guion[:100]}...'")
     
-    # Validar guion
     if not guion.strip():
+        logger.error("El guion está vacío")
         raise ValueError("El guion está vacío")
     
     # Directorio temporal
     temp_dir = tempfile.mkdtemp()
+    logger.info(f"Directorio temporal creado: {temp_dir}")
     temp_files = []
     
     try:
         # 2. Generar audio de voz
+        logger.info("Generando audio de voz...")
         voz_path = os.path.join(temp_dir, "voz.mp3")
         if not asyncio.run(text_to_speech(guion, voz_path)):
+            logger.error("Fallo en generación de voz")
             raise ValueError("Error generando voz")
         temp_files.append(voz_path)
         
         audio_tts = AudioFileClip(voz_path)
         audio_duration = audio_tts.duration
+        logger.info(f"Duración audio voz: {audio_duration:.2f} segundos")
         
-        # 3. Extraer palabras clave con respaldo
+        # 3. Extraer palabras clave
+        logger.info("Extrayendo palabras clave...")
         try:
             keywords = extract_visual_keywords_from_script(guion)
+            logger.info(f"Palabras clave identificadas: {keywords}")
         except Exception as e:
-            logger.error(f"Error extrayendo palabras clave: {e}")
-            keywords = ["naturaleza", "paisaje"]  # Palabras clave de respaldo
-        
-        logger.info(f"Palabras clave: {keywords}")
+            logger.error(f"Error extrayendo keywords: {str(e)}")
+            keywords = ["naturaleza", "paisaje"]
         
-        # 4. Buscar y descargar videos con múltiples intentos
+        # 4. Buscar y descargar videos
+        logger.info("Buscando videos en Pexels...")
         videos_data = []
         for keyword in keywords:
             try:
@@ -232,17 +269,17 @@ def crear_video(prompt_type, input_text, musica_file=None):
                     videos_data.extend(videos)
                     logger.info(f"Encontrados {len(videos)} videos para '{keyword}'")
             except Exception as e:
-                logger.warning(f"Error buscando videos para '{keyword}': {e}")
+                logger.warning(f"Error buscando videos para '{keyword}': {str(e)}")
         
-        # Si no encontramos videos, intentar con palabras clave genéricas
         if not videos_data:
-            logger.warning("Usando palabras clave genéricas como respaldo")
+            logger.warning("No se encontraron videos - Usando palabras clave genéricas")
             for keyword in ["naturaleza", "ciudad", "paisaje"]:
                 videos = buscar_videos_pexels(keyword, PEXELS_API_KEY, per_page=3)
                 if videos:
                     videos_data.extend(videos)
         
         if not videos_data:
+            logger.error("No se encontraron videos para ninguna palabra clave")
             raise ValueError("No se encontraron videos en Pexels para ninguna palabra clave")
         
         video_paths = []
@@ -251,7 +288,6 @@ def crear_video(prompt_type, input_text, musica_file=None):
                 continue
                 
             try:
-                # Seleccionar la mejor calidad de video
                 best_quality = max(
                     video['video_files'], 
                     key=lambda x: x.get('width', 0) * x.get('height', 0)
@@ -264,12 +300,14 @@ def crear_video(prompt_type, input_text, musica_file=None):
                         temp_files.append(path)
                         logger.info(f"Video descargado: {best_quality['link']}")
             except Exception as e:
-                logger.warning(f"Error procesando video: {e}")
+                logger.warning(f"Error procesando video: {str(e)}")
         
         if not video_paths:
+            logger.error("No se pudo descargar ningún video")
             raise ValueError("No se pudo descargar ningún video")
         
         # 5. Procesar videos
+        logger.info("Procesando videos descargados...")
         clips = []
         current_duration = 0
         
@@ -281,54 +319,56 @@ def crear_video(prompt_type, input_text, musica_file=None):
                 clip = VideoFileClip(path)
                 usable_duration = min(clip.duration, 10)
                 
-                if usable_duration > 1:  # Ignorar clips muy cortos
+                if usable_duration > 1:
                     clips.append(clip.subclip(0, usable_duration))
                     current_duration += usable_duration
-                    logger.info(f"Añadido clip de {usable_duration:.1f}s (total: {current_duration:.1f}/{audio_duration:.1f}s)")
+                    logger.debug(f"Clip añadido: {usable_duration:.1f}s (total: {current_duration:.1f}/{audio_duration:.1f}s)")
             except Exception as e:
-                logger.warning(f"Error procesando video {path}: {e}")
+                logger.warning(f"Error procesando video {path}: {str(e)}")
         
         if not clips:
+            logger.error("No hay clips válidos para crear el video")
             raise ValueError("No hay clips válidos para crear el video")
         
         video_base = concatenate_videoclips(clips, method="compose")
+        logger.info(f"Duración base del video: {video_base.duration:.2f}s")
         
-        # Ajustar duración del video si es necesario
         if video_base.duration < audio_duration:
-            num_repeats = int(audio_duration / video_base.duration) + 1
-            repeated_clips = [video_base] * num_repeats
-            video_base = concatenate_videoclips(repeated_clips).subclip(0, audio_duration)
+            num_repeats = math.ceil(audio_duration / video_base.duration)
+            logger.info(f"Repitiendo video {num_repeats} veces para ajustar duración")
+            video_base = concatenate_videoclips([video_base] * num_repeats).subclip(0, audio_duration)
         
         # 6. Manejar música de fondo
+        logger.info("Procesando audio...")
         final_audio = audio_tts
         
         if musica_file:
             try:
-                # Copiar archivo de música
                 music_path = os.path.join(temp_dir, "musica.mp3")
                 shutil.copyfile(musica_file, music_path)
                 temp_files.append(music_path)
+                logger.info(f"Música copiada a: {music_path}")
                 
-                # Procesar música
                 musica_audio = AudioFileClip(music_path)
+                logger.debug(f"Duración música original: {musica_audio.duration:.2f}s")
                 
-                # Crear loop si es necesario
                 if musica_audio.duration < audio_duration:
                     musica_audio = loop_audio_to_length(musica_audio, audio_duration)
+                    logger.debug(f"Música looped: {musica_audio.duration:.2f}s")
                 
-                # Mezclar con el audio de voz
                 final_audio = CompositeAudioClip([
-                    musica_audio.volumex(0.3),  # 30% volumen
-                    audio_tts.volumex(1.0)      # 100% volumen voz
+                    musica_audio.volumex(0.3),
+                    audio_tts.volumex(1.0)
                 ])
-                logger.info("Música de fondo añadida")
+                logger.info("Mezcla de audio completada")
             except Exception as e:
-                logger.warning(f"Error procesando música: {e}")
+                logger.warning(f"Error procesando música: {str(e)}")
         
         # 7. Crear video final
+        logger.info("Renderizando video final...")
         video_final = video_base.set_audio(final_audio)
-        
         output_path = os.path.join(temp_dir, "final_video.mp4")
+        
         video_final.write_videofile(
             output_path,
             fps=24,
@@ -339,39 +379,50 @@ def crear_video(prompt_type, input_text, musica_file=None):
             logger=None
         )
         
-        logger.info(f"Video creado: {output_path}")
+        total_time = (datetime.now() - start_time).total_seconds()
+        logger.info(f"VIDEO FINALIZADO: {output_path} | Tiempo total: {total_time:.2f}s")
         return output_path
         
     except Exception as e:
-        logger.error(f"Error creando video: {e}")
+        logger.error(f"ERROR EN CREAR_VIDEO: {str(e)}", exc_info=True)
         raise
     finally:
-        # Limpieza
+        logger.info("Limpiando archivos temporales...")
         for path in temp_files:
             try:
                 if os.path.isfile(path):
                     os.remove(path)
-            except:
-                pass
-        if os.path.exists(temp_dir):
+            except Exception as e:
+                logger.warning(f"No se pudo eliminar {path}: {str(e)}")
+        
+        try:
             shutil.rmtree(temp_dir, ignore_errors=True)
+        except Exception as e:
+            logger.warning(f"No se pudo eliminar {temp_dir}: {str(e)}")
 
-# Función para ejecutar la aplicación
+# [FUNCIÓN RUN_APP ORIGINAL CON LOGS]
 def run_app(prompt_type, prompt_ia, prompt_manual, musica_file):
+    logger.info("="*80)
+    logger.info("SOLICITUD RECIBIDA EN INTERFAZ")
     input_text = prompt_ia if prompt_type == "Generar Guion con IA" else prompt_manual
     
     if not input_text.strip():
+        logger.warning("Texto de entrada vacío")
         return None, "Por favor ingresa texto"
     
     try:
+        logger.info("Iniciando creación de video...")
         video_path = crear_video(prompt_type, input_text, musica_file)
+        logger.info("Video creado exitosamente")
         return video_path, "✅ Video generado exitosamente"
     except ValueError as ve:
+        logger.warning(f"Error de validación: {str(ve)}")
         return None, f"⚠️ {ve}"
     except Exception as e:
+        logger.error(f"Error crítico: {str(e)}", exc_info=True)
         return None, f"❌ Error: {str(e)}"
 
-# Interfaz de Gradio
+# [INTERFAZ DE GRADIO ORIGINAL COMPLETA]
 with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="""
     .gradio-container {max-width: 800px; margin: auto;}
     h1 {text-align: center;}
@@ -424,7 +475,6 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="
                 placeholder="Esperando acción..."
             )
 
-    # Manejar visibilidad de columnas
     prompt_type.change(
         lambda x: (gr.update(visible=x == "Generar Guion con IA"), 
                    gr.update(visible=x == "Usar Mi Guion")),
@@ -432,7 +482,6 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="
         outputs=[ia_guion_column, manual_guion_column]
     )
 
-    # Lógica de generación
     generate_btn.click(
         lambda: (None, "⏳ Procesando... (esto puede tomar 2-5 minutos)"),
         outputs=[video_output, status_output],
@@ -449,9 +498,14 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="
         - "Generar Guion con IA": Describe un tema
         - "Usar Mi Guion": Escribe tu guion completo
     2. **Sube música** (opcional): Selecciona un archivo de audio
-    3. **Haz clic en Generar Video**
+    3. **Haz clic en Generar Video"
     4. Espera a que se procese el video (puede tomar varios minutos)
     """)
 
 if __name__ == "__main__":
-    app.launch(server_name="0.0.0.0", server_port=7860)
+    logger.info("Iniciando aplicación Gradio...")
+    try:
+        app.launch(server_name="0.0.0.0", server_port=7860)
+    except Exception as e:
+        logger.critical(f"No se pudo iniciar la app: {str(e)}", exc_info=True)
+        raise