Update app.py

app.py

@@ -4,97 +4,284 @@ from docx import Document
 import tempfile
 import os
 import re
+import time
+from datetime import datetime
 
-# Initialize the client
-client = InferenceClient("mistralai/Mistral-7B-Instruct-v0.2")
+# Configuración de Streamlit
+st.set_page_config(
+    page_title="Interpretación Test de Rorschach",
+    page_icon="🧠",
+    layout="wide"
+)
 
-# Function to format the prompt for Rorschach interpretation
+# Inicialización del cliente - usando API Token de Hugging Face
+# Si tienes token, descomenta estas líneas y añade tu token
+# import os
+# os.environ["HUGGINGFACE_TOKEN"] = "tu_token_aquí"  # Mejor usar st.secrets en producción
+
+# Inicializar cliente con manejo de errores
+@st.cache_resource
+def get_inference_client():
+    try:
+        return InferenceClient(
+            model="mistralai/Mistral-7B-Instruct-v0.2",
+            timeout=120  # Timeout más largo para respuestas extensas
+        )
+    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 with mejor contexto
 def format_prompt(message, history):
-    prompt = "<s>"
+    # Sistema de instrucciones más detallado para mejorar la interpretación
+    system_prompt = """Eres un experto en interpretación del Test de Rorschach. 
+    Tu tarea es analizar las respuestas del paciente a las láminas y proporcionar una interpretación 
+    psicológica detallada basada en el método de Exner y el enfoque psicodinámico.
+    
+    Para cada interpretación debes considerar:
+    1. Localización de las respuestas (W, D, Dd)
+    2. Determinantes (forma, color, movimiento, sombreado)
+    3. Contenido (humano, animal, objeto, etc.)
+    4. Originalidad/popularidad de las respuestas
+    5. Indicadores de funcionamiento cognitivo, afectivo e interpersonal
+    
+    Tu interpretación debe ser profesional pero accesible, evitando jerga técnica excesiva.
+    """
+    
+    prompt = "<s>[INST] " + system_prompt + " [/INST] Entendido, analizaré las respuestas del Test de Rorschach profesionalmente.\n\n"
+    
+    # Añadir el historial de conversación
     for user_prompt, bot_response in history:
-        prompt += f"[INST] {user_prompt} [/INST]"
-        prompt += f" {bot_response} "
-    prompt += f"[INST] Interpretación Rorschach: {message} [/INST]"
+        prompt += f"[INST] Respuestas a láminas: {user_prompt} [/INST]\n{bot_response}\n\n"
+    
+    # Añadir la consulta actual
+    prompt += f"[INST] Respuestas a láminas: {message} [/INST]"
+    
     return prompt
 
-# Function to generate response
-def generate(prompt, history, temperature=0.9, max_new_tokens=512, top_p=0.95, repetition_penalty=1.0):
-    temperature = max(float(temperature), 1e-2)
-    top_p = float(top_p)
-
-    generate_kwargs = dict(
-        temperature=temperature,
-        max_new_tokens=max_new_tokens,
-        top_p=top_p,
-        repetition_penalty=repetition_penalty,
-        do_sample=True,
-        seed=42,
-    )
-
-    formatted_prompt = format_prompt(prompt, history)
-
-    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
+# Function to generate response with manejo de errores y feedback visual
+def generate(prompt, history, temperature=0.7, max_new_tokens=800, top_p=0.95, repetition_penalty=1.1):
+    if not client:
+        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)
+        
+        # Parámetros 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,
+            do_sample=True,
+            seed=42,
+        )
+        
+        formatted_prompt = format_prompt(prompt, history)
+        
+        # Mostrar indicador de progreso
+        progress_text = "Generando interpretación psicológica..."
+        my_bar = st.progress(0, text=progress_text)
+        
+        # Stream de la respuesta con feedback visual
+        stream = client.text_generation(formatted_prompt, **generate_kwargs, stream=True, details=True, return_full_text=False)
+        output = ""
+        
+        for i, response in enumerate(stream):
+            output += response.token.text
+            # Actualizar la barra de progreso simulando avance
+            progress_percent = min(i/100, 1.0)
+            my_bar.progress(progress_percent, text=progress_text)
+            # Pequeña pausa para mejorar UX
+            time.sleep(0.01)
+        
+        # Completar la barra de progreso
+        my_bar.progress(1.0, text="¡Interpretación completa!")
+        time.sleep(0.5)
+        my_bar.empty()
+        
+        return output
+        
+    except Exception as e:
+        st.error(f"Error en la generación: {str(e)}")
+        return f"Lo siento, ocurrió un error durante la interpretación. Detalles: {str(e)}"
 
-# Function to replace variables in a Word template
+# Function to replace variables in a Word template con manejo mejorado
 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)
+                # Preservar el formato existente
+                paragraph_format = paragraph.paragraph_format
+                run_formats = [(run.text, run.bold, run.italic, run.font.size, run.font.name) 
+                               for run in paragraph.runs]
+                
+                paragraph.text = paragraph.text.replace(f'<{key}>', value)
+                
+                # Restablecer formato después del reemplazo si es necesario
+                paragraph.paragraph_format = paragraph_format
+    
+    # Procesar tablas
     for table in doc.tables:
         for row in table.rows:
             for cell in row.cells:
                 for paragraph in cell.paragraphs:
                     for key, value in variables.items():
                         if f'<{key}>' in paragraph.text:
-                            paragraph.text = re.sub(f'<{key}>', value, paragraph.text)
+                            paragraph.text = paragraph.text.replace(f'<{key}>', value)
 
 # Function to generate a Word document with interpretation
-def generate_word_document(interpretation):
-    template_path = os.path.join('PLANTILLAS', 'PLANTILLA_INTERPRETACION.docx')
-    doc = Document(template_path)
-    
-    variables = {'INTERPRETACION': interpretation}
-    replace_variables_word(doc, variables)
+def generate_word_document(interpretation, patient_name="", test_date=""):
+    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}. Usando documento en blanco.")
+            doc = Document()
+            doc.add_heading('Interpretación Test de Rorschach', 0)
+            doc.add_paragraph(interpretation)
+        else:
+            doc = Document(template_path)
+            
+            # Preparar variables para la plantilla
+            variables = {
+                'INTERPRETACION': interpretation,
+                'NOMBRE_PACIENTE': patient_name,
+                'FECHA_EVALUACION': test_date,
+                'FECHA_INFORME': datetime.now().strftime("%d/%m/%Y")
+            }
+            
+            replace_variables_word(doc, variables)
+        
+        # Guardar el documento temporal
+        with tempfile.NamedTemporaryFile(delete=False, suffix='.docx') as tmp:
+            doc.save(tmp.name)
+            return tmp.name
+            
+    except Exception as e:
+        st.error(f"Error al generar el documento: {str(e)}")
+        return None
 
-    with tempfile.NamedTemporaryFile(delete=False, suffix='.docx') as tmp:
-        doc.save(tmp.name)
-        return tmp.name
+# Interfaz de Streamlit mejorada
+st.title("🧠 Interpretación del Test de Rorschach")
+st.markdown("""
+Esta aplicación utiliza inteligencia artificial para ayudar en la interpretación preliminar 
+de respuestas al Test de Rorschach. **No sustituye el juicio clínico profesional.**
+""")
 
-# Streamlit interface
-st.title("Interpretación del Test de Rorschach")
+# Sidebar con opciones
+with st.sidebar:
+    st.header("Configuración")
+    
+    # Parámetros del paciente
+    st.subheader("Datos del Paciente")
+    patient_name = st.text_input("Nombre del paciente (opcional)")
+    test_date = st.date_input("Fecha de evaluación", datetime.now()).strftime("%d/%m/%Y")
+    
+    # Parámetros del modelo
+    st.subheader("Parámetros del Modelo")
+    temperature = st.slider("Temperatura", 0.1, 1.0, 0.7, 0.1, 
+                          help="Valores más altos = respuestas más creativas. Valores más bajos = respuestas más consistentes.")
+    max_tokens = st.slider("Longitud máxima", 200, 1500, 800, 100,
+                          help="Número máximo de tokens en la respuesta")
 
 # Chat history
 if 'history' not in st.session_state:
     st.session_state.history = []
 
-# User input
-entrada_usuario = st.text_input("Que ves en las imágenes ..:", key="entrada_usuario")
+# Explicación del uso
+with st.expander("ℹ️ Cómo usar esta aplicación"):
+    st.markdown("""
+    1. Escribe las respuestas del paciente a las láminas del Test de Rorschach en el campo de texto.
+    2. Incluye el número de lámina para cada respuesta, por ejemplo: "Lámina I: Veo un murciélago".
+    3. Haz clic en "Generar Interpretación" para recibir el análisis.
+    4. Puedes descargar la interpretación como documento Word.
+    
+    **Nota importante**: Esta herramienta está diseñada para asistir en la interpretación preliminar.
+    Siempre debe complementarse con el juicio clínico de un profesional cualificado.
+    """)
+
+# Uso de columnas para mejor distribución
+col1, col2 = st.columns([3, 2])
+
+with col1:
+    # User input - área de texto más grande para múltiples respuestas
+    entrada_usuario = st.text_area(
+        "Ingrese las respuestas del paciente a las láminas:",
+        height=200,
+        placeholder="Ejemplo:\nLámina I: Veo un murciélago\nLámina II: Dos personas chocando las manos, hay sangre\n..."
+    )
+    
+    # Botones de acción
+    col_btn1, col_btn2, _ = st.columns([1, 1, 2])
+    
+    with col_btn1:
+        submit_button = st.button("Generar Interpretación", type="primary")
+    
+    with col_btn2:
+        clear_button = st.button("Limpiar Historial")
+        if clear_button:
+            st.session_state.history = []
+            st.experimental_rerun()
 
 # Generate response and create Word document
-if st.button("Enviar"):
-    if entrada_usuario:
-        bot_response = generate(entrada_usuario, st.session_state.history)
+if submit_button and entrada_usuario:
+    with st.spinner("Analizando respuestas..."):
+        bot_response = generate(
+            entrada_usuario, 
+            st.session_state.history,
+            temperature=temperature,
+            max_new_tokens=max_tokens
+        )
+        
+        # Añadir al historial
         st.session_state.history.append((entrada_usuario, bot_response))
-
-        # Generate Word document
-        document_path = generate_word_document(bot_response)
         
-        # Provide download link
-        with open(document_path, "rb") as file:
-            st.download_button(
-                label="Descargar Interpretación",
-                data=file,
-                file_name="Interpretacion_Rorschach.docx",
-                mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document"
-            )
-
-# Display conversation
-chat_text = ""
-for user_msg, bot_msg in st.session_state.history:
-    chat_text += f"Tu: {user_msg}\nBuho: {bot_msg}\n\n"
-st.text_area("Respuestas del Buho", value=chat_text, height=300, disabled=False)
+        # Generar documento Word
+        document_path = generate_word_document(
+            bot_response,
+            patient_name=patient_name,
+            test_date=test_date
+        )
+        
+        if document_path:
+            # Proporcionar enlace de descarga
+            with open(document_path, "rb") as file:
+                file_data = file.read()
+                
+            # Nombre personalizado para el archivo
+            file_name = f"Interpretacion_Rorschach_{datetime.now().strftime('%Y%m%d')}.docx"
+            if patient_name:
+                file_name = f"Rorschach_{patient_name.replace(' ', '_')}_{datetime.now().strftime('%Y%m%d')}.docx"
+            
+            with col2:
+                st.download_button(
+                    label="📄 Descargar Interpretación (Word)",
+                    data=file_data,
+                    file_name=file_name,
+                    mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+                )
+
+# Display conversation en la segunda columna
+with col2:
+    st.subheader("Historial de Interpretaciones")
+    
+    if not st.session_state.history:
+        st.info("Aún no hay interpretaciones generadas. Complete el formulario y haga clic en 'Generar Interpretación'.")
+    else:
+        # Mostrar la última interpretación primero
+        for i, (user_msg, bot_msg) in enumerate(reversed(st.session_state.history)):
+            with st.expander(f"Interpretación {len(st.session_state.history) - i}", expanded=(i == 0)):
+                st.markdown("**Respuestas del paciente:**")
+                st.text(user_msg)
+                st.markdown("**Interpretación psicológica:**")
+                st.markdown(bot_msg)
+
+# Pie de página
+st.markdown("---")
+st.markdown("📌 **Nota**: Esta aplicación usa el modelo Mistral-7B para generar interpretaciones preliminares.")
+st.markdown("⚠️ Los resultados deben ser revisados por un profesional cualificado antes de usarse en contextos clínicos.")