Update app.py

app.py

@@ -7,45 +7,31 @@ import re
 import logging
 import datetime
 
-# Configurar logging para monitorear las llamadas al API
+# Configurar logging
 logging.basicConfig(
     level=logging.INFO,
     format='%(asctime)s - %(levelname)s - %(message)s',
-    handlers=[
-        logging.StreamHandler()  # Log a stdout/stderr
-    ]
+    handlers=[logging.StreamHandler()]
 )
 logger = logging.getLogger("rorschach_app")
 
-# Configuración mínima de Streamlit
-st.set_page_config(
-    page_title="Interpretación Rorschach",
-    page_icon="🧠",
-)
-import os
-from huggingface_hub import InferenceClient
+# Configuración de Streamlit
+st.set_page_config(page_title="Interpretación Rorschach", page_icon="🧠")
 
-hf_token = os.getenv("HF_TOKEN")
-client = InferenceClient(
-    model="mistralai/Mixtral-8x7B-Instruct-v0.1",
-    token=hf_token
-)
+# === Configurar el cliente de Hugging Face ===
+HF_TOKEN = os.getenv("HF_TOKEN") or "TU_TOKEN_AQUI"  # <-- Asegúrate de poner tu token aquí o definirlo como variable de entorno
+MODEL_ID = "mistralai/Mixtral-8x7B-Instruct-v0.1"
 
-
-
-# Inicializar cliente - con log de verificación
-client = None
 try:
-    client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
-    logger.info("✅ Conexión con modelo Mistral-7B establecida correctamente")
+    client = InferenceClient(model=MODEL_ID, token=HF_TOKEN)
+    logger.info(f"✅ Conexión con el modelo {MODEL_ID} 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)
+    logger.error(f"❌ Error al inicializar cliente de Hugging Face: {str(e)}")
+    client = None
+    st.error("Error al conectar con el modelo de Hugging Face")
 
-# Function to format the prompt for Rorschach interpretation
+# Función para construir el prompt
 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.
@@ -57,24 +43,18 @@ def format_prompt(message):
     - Originalidad/popularidad
     - Funcionamiento cognitivo, afectivo e interpersonal
     """
-    
     prompt = f"<s>[INST] {system_prompt} [/INST] Entendido. [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 - con logs detallados
+# Función para generar la interpretación
 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."
-    
+        logger.error("❌ Cliente no disponible")
+        return "Error de conexión con el modelo."
+
     try:
-        logger.info(f"🔄 Iniciando llamada al API de Hugging Face - {datetime.datetime.now()}")
-        
-        # Parámetros fijos optimizados para interpretación psicológica
+        logger.info("🔄 Iniciando generación de texto")
         generate_kwargs = dict(
             temperature=0.7,
             max_new_tokens=800,
@@ -83,35 +63,24 @@ def generate(prompt):
             do_sample=True,
             seed=42,
         )
-        
+
         formatted_prompt = format_prompt(prompt)
-        
-        # 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)
+        stream = client.text_generation(formatted_prompt, **generate_kwargs, stream=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")
-        
+
+        logger.info(f"✅ Respuesta generada: {token_count} tokens")
         return output
-        
+
     except Exception as 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)}"
+        logger.error(f"❌ Error en la generación: {str(e)}")
+        return f"Ocurrió un error: {str(e)}"
 
-# Function to replace variables in a Word template - sin cambios
+# Reemplazar variables en Word
 def replace_variables_word(doc, variables):
     for paragraph in doc.paragraphs:
         for key, value in variables.items():
@@ -125,98 +94,71 @@ def replace_variables_word(doc, variables):
                         if f'<{key}>' in paragraph.text:
                             paragraph.text = re.sub(f'<{key}>', value, paragraph.text)
 
-# Function to generate a Word document with interpretation - sin cambios
+# Generar documento Word
 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):
             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)
-        
-        variables = {'INTERPRETACION': interpretation}
-        replace_variables_word(doc, variables)
-        
+        replace_variables_word(doc, {'INTERPRETACION': interpretation})
+
         with tempfile.NamedTemporaryFile(delete=False, suffix='.docx') as tmp:
             doc.save(tmp.name)
-            logger.info(f"✅ Documento Word generado correctamente: {tmp.name}")
+            logger.info(f"✅ Documento Word generado: {tmp.name}")
             return tmp.name
-            
+
     except Exception as e:
-        error_msg = f"❌ Error al generar el documento: {str(e)}"
-        logger.error(error_msg)
-        st.error(error_msg)
+        logger.error(f"❌ Error generando documento: {str(e)}")
+        st.error(f"Error generando documento: {str(e)}")
         return None
 
-# Streamlit interface - simplificada al máximo
+# === Interfaz Streamlit ===
 st.title("Interpretación del Test de Rorschach")
-
-# Log de inicio de sesión
 logger.info("🚀 Aplicación iniciada")
 
-# 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..."
 )
 
-# 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")
-        
-        # UI feedback
+        logger.info(f"Procesando entrada de {len(entrada_usuario)} caracteres")
         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")
+                    st.download_button(
+                        label="Descargar Interpretación",
+                        data=file.read(),
+                        file_name="Interpretacion_Rorschach.docx",
+                        mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+                    )
+                logger.info("📄 Botón de descarga mostrado")
             else:
-                logger.error("❌ No se pudo generar el documento Word")
+                logger.error("❌ No se pudo generar el documento")
 
-# Mostrar logs en la interfaz (para depuración)
+# Mostrar logs
 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.code(self.format(record))
+
     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
+    handler = StreamlitLogHandler()
+    handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))
+    logger.addHandler(handler)
     logger.info("📊 Visualización de logs activada")
-    
-    # Eliminar handler temporal
-    logger.removeHandler(stream_handler)
+    logger.removeHandler(handler)