Update app.py

app.py

@@ -7,30 +7,39 @@ import re
 import logging
 import datetime
 
-# Configurar logging
+# Configurar logging para monitorear las llamadas al API
 logging.basicConfig(
     level=logging.INFO,
     format='%(asctime)s - %(levelname)s - %(message)s',
-    handlers=[logging.StreamHandler()]
+    handlers=[
+        logging.StreamHandler()
+    ]
 )
 logger = logging.getLogger("rorschach_app")
 
-# Configuración de Streamlit
-st.set_page_config(page_title="Interpretación Rorschach", page_icon="🧠")
+# Configuración mínima de Streamlit
+st.set_page_config(
+    page_title="Interpretación Rorschach",
+    page_icon="🧠",
+)
 
-# === Configurar el cliente de Hugging Face ===
-HF_TOKEN = os.getenv("HF_TOKEN")  # <-- Asegúrate de poner tu token aquí o definirlo como variable de entorno
-MODEL_ID = "mistralai/Mixtral-8x7B-Instruct-v0.1"
+# Usar tu token de Hugging Face
+hf_token = os.getenv("HF_TOKEN")  # O reemplázalo directamente: hf_token = "tu_token_aquí"
 
+# Inicializar cliente de Hugging Face
+client = None
 try:
-    client = InferenceClient(model=MODEL_ID, token=HF_TOKEN)
-    logger.info(f"✅ Conexión con el modelo {MODEL_ID} establecida correctamente")
+    client = InferenceClient(
+        model="mistralai/Mixtral-8x7B-Instruct-v0.1",
+        token=hf_token
+    )
+    logger.info("✅ Conexión con modelo Mixtral-8x7B establecida correctamente")
 except Exception as e:
-    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")
+    error_msg = f"❌ Error al inicializar cliente de Hugging Face: {str(e)}"
+    logger.error(error_msg)
+    st.error(error_msg)
 
-# Función para construir el prompt
+# Formatear prompt para interpretación Rorschach
 def format_prompt(message):
     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 
@@ -43,18 +52,20 @@ 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]"
     logger.info(f"Prompt generado con {len(prompt)} caracteres")
     return prompt
 
-# Función para generar la interpretación
+# Generar respuesta desde Hugging Face (modo no streaming)
 def generate(prompt):
     if not client:
-        logger.error("❌ Cliente no disponible")
-        return "Error de conexión con el modelo."
+        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:
-        logger.info("🔄 Iniciando generación de texto")
+        logger.info(f"🔄 Iniciando llamada al API de Hugging Face - {datetime.datetime.now()}")
+
         generate_kwargs = dict(
             temperature=0.7,
             max_new_tokens=800,
@@ -65,22 +76,23 @@ def generate(prompt):
         )
 
         formatted_prompt = format_prompt(prompt)
-        stream = client.text_generation(formatted_prompt, **generate_kwargs, stream=True, return_full_text=False)
-        output = ""
-        token_count = 0
+        start_time = datetime.datetime.now()
+
+        # Llamada sin streaming
+        output = client.text_generation(formatted_prompt, **generate_kwargs)
 
-        for response in stream:
-            output += response.token.text
-            token_count += 1
+        end_time = datetime.datetime.now()
+        duration = (end_time - start_time).total_seconds()
 
-        logger.info(f"✅ Respuesta generada: {token_count} tokens")
+        logger.info(f"✅ Respuesta generada en {duration:.2f} segundos")
         return output
 
     except Exception as e:
-        logger.error(f"❌ Error en la generación: {str(e)}")
-        return f"Ocurrió un error: {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)}"
 
-# Reemplazar variables en Word
+# Reemplazo de variables en documento Word
 def replace_variables_word(doc, variables):
     for paragraph in doc.paragraphs:
         for key, value in variables.items():
@@ -94,29 +106,32 @@ def replace_variables_word(doc, variables):
                         if f'<{key}>' in paragraph.text:
                             paragraph.text = re.sub(f'<{key}>', value, paragraph.text)
 
-# Generar documento Word
+# Generar documento Word con interpretación
 def generate_word_document(interpretation):
     try:
         template_path = os.path.join('PLANTILLAS', 'PLANTILLA_INTERPRETACION.docx')
+
         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)
-        replace_variables_word(doc, {'INTERPRETACION': interpretation})
+        variables = {'INTERPRETACION': interpretation}
+        replace_variables_word(doc, variables)
 
         with tempfile.NamedTemporaryFile(delete=False, suffix='.docx') as tmp:
             doc.save(tmp.name)
-            logger.info(f"✅ Documento Word generado: {tmp.name}")
+            logger.info(f"✅ Documento Word generado correctamente: {tmp.name}")
             return tmp.name
 
     except Exception as e:
-        logger.error(f"❌ Error generando documento: {str(e)}")
-        st.error(f"Error generando documento: {str(e)}")
+        error_msg = f"❌ Error al generar el documento: {str(e)}"
+        logger.error(error_msg)
+        st.error(error_msg)
         return None
 
-# === Interfaz Streamlit ===
+# Interfaz Streamlit
 st.title("Interpretación del Test de Rorschach")
 logger.info("🚀 Aplicación iniciada")
 
@@ -130,35 +145,39 @@ 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")
+        logger.info(f"🔄 Procesando entrada de {len(entrada_usuario)} caracteres")
         with st.spinner("Generando interpretación..."):
             bot_response = generate(entrada_usuario)
-
             st.subheader("Interpretación")
             st.write(bot_response)
 
             document_path = generate_word_document(bot_response)
             if document_path:
                 with open(document_path, "rb") as file:
-                    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")
+                    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")
+                logger.error("❌ No se pudo generar el documento Word")
 
-# Mostrar logs
+# Mostrar logs en la interfaz (opcional)
 if st.checkbox("Mostrar logs", value=False):
     class StreamlitLogHandler(logging.Handler):
         def emit(self, record):
-            st.code(self.format(record))
+            log_entry = self.format(record)
+            st.code(log_entry)
 
     st.subheader("Logs del sistema")
-    handler = StreamlitLogHandler()
-    handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))
-    logger.addHandler(handler)
+    log_output = st.empty()
+
+    stream_handler = StreamlitLogHandler()
+    stream_handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))
+    logger.addHandler(stream_handler)
+
     logger.info("📊 Visualización de logs activada")
-    logger.removeHandler(handler)
+    logger.removeHandler(stream_handler)