Update app.py

app.py

@@ -4,28 +4,38 @@ from docx import Document
 import tempfile
 import os
 import re
-import time
+import logging
+import datetime
+
+# Configurar logging para monitorear las llamadas al API
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler()  # Log a stdout/stderr
+    ]
+)
+logger = logging.getLogger("rorschach_app")
 
-# Configuración básica de Streamlit
+# Configuración mínima de Streamlit
 st.set_page_config(
-    page_title="Interpretación Test de Rorschach",
+    page_title="Interpretación Rorschach",
     page_icon="🧠",
 )
 
-# Inicializar cliente - manteniendo simple pero con manejo de errores
-@st.cache_resource
-def get_inference_client():
-    try:
-        return InferenceClient("mistralai/Mistral-7B-Instruct-v0.2")
-    except Exception as e:
-        st.error(f"Error al inicializar el cliente de Hugging Face: {str(e)}")
-        return None
-
-client = get_inference_client()
-
-# Function to format the prompt for Rorschach interpretation - MEJORADO
-def format_prompt(message, history):
-    # Prompt mejorado pero manteniendo compatibilidad con formato original
+# Inicializar cliente - con log de verificación
+client = None
+try:
+    client = InferenceClient("mistralai/Mistral-7B-Instruct-v0.2")
+    logger.info("✅ Conexión con modelo Mistral-7B establecida correctamente")
+except Exception as e:
+    error_msg = f"❌ Error al inicializar cliente de Hugging Face: {str(e)}"
+    logger.error(error_msg)
+    st.error(error_msg)
+
+# Function to format the prompt for Rorschach interpretation
+def format_prompt(message):
+    # Prompt optimizado para interpretación Rorschach
     system_prompt = """Eres un experto en interpretación del Test de Rorschach. 
     Analiza las respuestas del paciente a las láminas y proporciona una interpretación 
     psicológica detallada basada en el método de Exner.
@@ -38,64 +48,65 @@ def format_prompt(message, history):
     - Funcionamiento cognitivo, afectivo e interpersonal
     """
     
-    prompt = "<s>"
-    # Añadir instrucciones de sistema al inicio solo si no hay historial previo
-    if not history:
-        prompt += f"[INST] {system_prompt} [/INST] Entendido, analizaré las respuestas profesionalmente. "
+    prompt = f"<s>[INST] {system_prompt} [/INST] Entendido. [INST] Interpretación Rorschach: {message} [/INST]"
     
-    # Añadir el historial de conversación manteniendo formato original
-    for user_prompt, bot_response in history:
-        prompt += f"[INST] {user_prompt} [/INST]"
-        prompt += f" {bot_response} "
-    
-    # Añadir la consulta actual con formato específico para Rorschach
-    prompt += f"[INST] Interpretación Rorschach: {message} [/INST]"
+    # Log del prompt para verificación
+    logger.info(f"Prompt generado con {len(prompt)} caracteres")
     
     return prompt
 
-# Function to generate response - OPTIMIZADA
-def generate(prompt, history, temperature=0.7, max_new_tokens=800, top_p=0.95, repetition_penalty=1.1):
+# Function to generate response - con logs detallados
+def generate(prompt):
     if not client:
+        logger.error("❌ No hay cliente disponible para generar respuesta")
         return "Error de conexión con el modelo. Por favor, inténtelo de nuevo más tarde."
     
     try:
-        temperature = max(float(temperature), 1e-2)
-        top_p = float(top_p)
+        logger.info(f"🔄 Iniciando llamada al API de Hugging Face - {datetime.datetime.now()}")
         
-        # Parámetros optimizados para interpretación psicológica
+        # Parámetros fijos optimizados para interpretación psicológica
         generate_kwargs = dict(
-            temperature=temperature,
-            max_new_tokens=max_new_tokens,
-            top_p=top_p,
-            repetition_penalty=repetition_penalty,
+            temperature=0.7,
+            max_new_tokens=800,
+            top_p=0.95,
+            repetition_penalty=1.1,
             do_sample=True,
             seed=42,
         )
         
-        formatted_prompt = format_prompt(prompt, history)
+        formatted_prompt = format_prompt(prompt)
         
-        # Mostrar indicador de progreso simple
-        with st.spinner("Generando interpretación psicológica..."):
-            # Stream de la respuesta
-            stream = client.text_generation(formatted_prompt, **generate_kwargs, stream=True, details=True, return_full_text=False)
-            output = ""
-            
-            for response in stream:
-                output += response.token.text
-            
-            return output
+        # Monitoreo de tiempo de respuesta
+        start_time = datetime.datetime.now()
+        
+        # Stream de la respuesta
+        stream = client.text_generation(formatted_prompt, **generate_kwargs, stream=True, details=True, return_full_text=False)
+        output = ""
+        token_count = 0
+        
+        for response in stream:
+            output += response.token.text
+            token_count += 1
+        
+        end_time = datetime.datetime.now()
+        duration = (end_time - start_time).total_seconds()
+        
+        # Log detallado del resultado
+        logger.info(f"✅ Respuesta generada: {token_count} tokens en {duration:.2f} segundos")
+        
+        return output
         
     except Exception as e:
-        st.error(f"Error en la generación: {str(e)}")
+        error_msg = f"❌ Error en la generación: {str(e)}"
+        logger.error(error_msg)
         return f"Lo siento, ocurrió un error durante la interpretación. Detalles: {str(e)}"
 
-# Manteniendo la función original para reemplazar variables en Word
+# Function to replace variables in a Word template - sin cambios
 def replace_variables_word(doc, variables):
     for paragraph in doc.paragraphs:
         for key, value in variables.items():
             if f'<{key}>' in paragraph.text:
                 paragraph.text = re.sub(f'<{key}>', value, paragraph.text)
-                
     for table in doc.tables:
         for row in table.rows:
             for cell in row.cells:
@@ -104,14 +115,15 @@ def replace_variables_word(doc, variables):
                         if f'<{key}>' in paragraph.text:
                             paragraph.text = re.sub(f'<{key}>', value, paragraph.text)
 
-# Manteniendo la función original para generar el documento Word
+# Function to generate a Word document with interpretation - sin cambios
 def generate_word_document(interpretation):
     try:
         template_path = os.path.join('PLANTILLAS', 'PLANTILLA_INTERPRETACION.docx')
         
         # Verificar si existe la plantilla
         if not os.path.exists(template_path):
-            st.warning(f"No se encontró la plantilla en {template_path}.")
+            logger.warning(f"⚠️ No se encontró la plantilla en {template_path}")
+            st.warning(f"No se encontró la plantilla en {template_path}")
             return None
             
         doc = Document(template_path)
@@ -121,82 +133,80 @@ def generate_word_document(interpretation):
         
         with tempfile.NamedTemporaryFile(delete=False, suffix='.docx') as tmp:
             doc.save(tmp.name)
+            logger.info(f"✅ Documento Word generado correctamente: {tmp.name}")
             return tmp.name
             
     except Exception as e:
-        st.error(f"Error al generar el documento: {str(e)}")
+        error_msg = f"❌ Error al generar el documento: {str(e)}"
+        logger.error(error_msg)
+        st.error(error_msg)
         return None
 
-# Streamlit interface - simplificada pero mejorada
+# Streamlit interface - simplificada al máximo
 st.title("Interpretación del Test de Rorschach")
-st.markdown("""
-Esta aplicación genera interpretaciones preliminares del Test de Rorschach usando IA.
-""")
-
-# Sidebar con parámetros opcionales
-with st.sidebar:
-    st.header("Configuración")
-    temperature = st.slider("Creatividad", 0.1, 1.0, 0.7, 0.1, 
-                           help="Valores más altos = respuestas más variadas")
-    max_tokens = st.slider("Longitud", 200, 1000, 512, 50)
 
-# Chat history
-if 'history' not in st.session_state:
-    st.session_state.history = []
+# Log de inicio de sesión
+logger.info("🚀 Aplicación iniciada")
 
-# User input - área de texto más cómoda
+# User input - simplificado
 entrada_usuario = st.text_area(
     "Ingrese respuestas del Test de Rorschach:",
     height=150,
     placeholder="Ejemplo: Lámina I: Veo un murciélago..."
 )
 
-# Botones en una fila
-col1, col2 = st.columns([1, 3])
-
-with col1:
-    submit_button = st.button("Enviar", type="primary")
-    
-    if submit_button and entrada_usuario:
-        # Generate response
-        bot_response = generate(
-            entrada_usuario, 
-            st.session_state.history,
-            temperature=temperature,
-            max_new_tokens=max_tokens
-        )
-        
-        st.session_state.history.append((entrada_usuario, bot_response))
+# UI simplificada con un solo botón
+if st.button("Enviar", type="primary"):
+    if not entrada_usuario:
+        st.warning("Por favor ingrese texto para interpretar")
+    else:
+        logger.info(f"🔄 Procesando entrada de {len(entrada_usuario)} caracteres")
         
-        # Generate Word document - usando la función original
-        document_path = generate_word_document(bot_response)
-        
-        if document_path:
-            # Proporcionar enlace de descarga
-            with open(document_path, "rb") as file:
-                file_data = file.read()
-                
-            st.download_button(
-                label="Descargar Interpretación",
-                data=file_data,
-                file_name="Interpretacion_Rorschach.docx",
-                mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document"
-            )
-
-with col2:
-    clear_button = st.button("Limpiar historial")
-    if clear_button:
-        st.session_state.history = []
-        st.experimental_rerun()
-
-# Display conversation - similar al original pero con mejor formato
-st.subheader("Historial de interpretaciones")
-
-if not st.session_state.history:
-    st.info("No hay interpretaciones previas.")
-else:
-    chat_text = ""
-    for user_msg, bot_msg in st.session_state.history:
-        chat_text += f"Paciente: {user_msg}\n\nInterpretación: {bot_msg}\n\n---\n\n"
+        # UI feedback
+        with st.spinner("Generando interpretación..."):
+            # Generate response
+            bot_response = generate(entrada_usuario)
+            
+            # UI para mostrar la respuesta
+            st.subheader("Interpretación")
+            st.write(bot_response)
+            
+            # Generate Word document
+            document_path = generate_word_document(bot_response)
+            
+            if document_path:
+                # Proporcionar enlace de descarga
+                with open(document_path, "rb") as file:
+                    file_data = file.read()
+                    
+                st.download_button(
+                    label="Descargar Interpretación",
+                    data=file_data,
+                    file_name="Interpretacion_Rorschach.docx",
+                    mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+                )
+                logger.info("📄 Botón de descarga mostrado al usuario")
+            else:
+                logger.error("❌ No se pudo generar el documento Word")
+
+# Mostrar logs en la interfaz (para depuración)
+if st.checkbox("Mostrar logs", value=False):
+    class StreamlitLogHandler(logging.Handler):
+        def emit(self, record):
+            log_entry = self.format(record)
+            st.code(log_entry)
+    
+    # Mostrar los últimos 10 logs del sistema
+    st.subheader("Logs del sistema")
+    log_output = st.empty()
+    
+    # Agregar handler temporal para mostrar logs
+    stream_handler = StreamlitLogHandler()
+    stream_handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))
+    logger.addHandler(stream_handler)
+    
+    # Generar log de prueba
+    logger.info("📊 Visualización de logs activada")
     
-    st.text_area("Respuestas e interpretaciones", value=chat_text, height=300, disabled=True)
+    # Eliminar handler temporal
+    logger.removeHandler(stream_handler)