Update app.py

app.py

@@ -1,4 +1,4 @@
-# ====================    Interprete de manchas de Test de Rorschach   =====================================
+# ====================    Asesor de Notificación SIVIGILA - Colombia   =====================================
 #
 #    (o\ | /o)
 #     \.\_/. /
@@ -6,238 +6,250 @@
 # \ VVVV/ \VVVV /
 #  \____/ \____/
 # __________________________________________________________________________________________________________
-# DIANA MILENA SOLER Psicologa Est Medicina U. Juan N Corpas JAIRO ALEXANDER ERASO MD U Nacional de Colombia
-# 
+# Adaptado por JAIRO ALEXANDER ERASO MD U Nacional de Colombia, basado en la solicitud del usuario.
+#
 
 import streamlit as st
-import google.generativeai as genai # Import Gemini
-from docx import Document
-import tempfile
+import google.generativeai as genai
 import os
-import re
+import json
 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()
-    ]
-)
-logger = logging.getLogger("rorschach_gemini_app")
-
-# Configuración mínima de Streamlit
+# --- CONFIGURACIÓN BÁSICA ---
 st.set_page_config(
-    page_title="Interpretación Rorschach con Gemini",
-    page_icon="🧠",
+    page_title="Asesor SIVIGILA Colombia",
+    page_icon="🇨🇴",
+    layout="wide"
 )
 
-# --- CONFIGURACIÓN Gemini ---
-GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
-if not GEMINI_API_KEY:
-    st.error("GEMINI_API_KEY no encontrada. Por favor configúrala en tus variables de entorno.")
-    logger.error("GEMINI_API_KEY no encontrada.")
-    st.stop()
+# Configurar logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger("sivigila_app")
 
+# --- CONFIGURACIÓN DE GEMINI ---
 try:
+    GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+    if not GEMINI_API_KEY:
+        st.error("No se encontró la variable de entorno GEMINI_API_KEY. Por favor, configúrala.")
+        logger.error("GEMINI_API_KEY no encontrada.")
+        st.stop()
     genai.configure(api_key=GEMINI_API_KEY)
     logger.info("✅ Configuración de Gemini API realizada.")
 except Exception as e:
-    error_msg = f"❌ Error al configurar Gemini API: {str(e)}"
-    logger.error(error_msg)
-    st.error(error_msg)
+    st.error(f"❌ Error al configurar Gemini API: {e}")
+    logger.error(f"Error al configurar Gemini API: {e}")
     st.stop()
 
 @st.cache_resource
 def get_gemini_model():
-    logger.info("🔄 Cargando modelo Gemini...")
-    # Puedes cambiar a "gemini-pro" si lo prefieres, gemini-1.5-flash es más rápido y económico
-    return genai.GenerativeModel("gemini-1.5-flash-latest")
-
-# Inicializar modelo Gemini
-model = None
-try:
-    model = get_gemini_model()
-    logger.info("✅ Modelo Gemini cargado correctamente (gemini-1.5-flash-latest)")
-except Exception as e:
-    error_msg = f"❌ Error al inicializar modelo Gemini: {str(e)}"
-    logger.error(error_msg)
-    st.error(error_msg)
-    # st.stop() # Decidir si detener la app si el modelo no carga
-
-# Formatear prompt para interpretación Rorschach con Gemini
-def format_prompt_gemini(message):
-    system_prompt = """Eres un experto en interpretación del Test de Rorschach.
-    Analiza las respuestas del usuario a las láminas y proporciona una interpretación
-    psicológica detallada basada en el método de Exner.
-
-    Considera:
-    - Localización de las respuestas
-    - Determinantes (forma, color, movimiento)
-    - Contenido de las respuestas
-    - Originalidad/popularidad
-    - Funcionamiento cognitivo, afectivo e interpersonal
-    Al final describe una conclusion creativa en terminos sencillos de la personalidad del usuario
-    con recomendaciones generales.
-    """
+    """Carga el modelo de Gemini y lo cachea para no recargarlo."""
+    logger.info("🔄 Cargando modelo Gemini (gemini-1.5-flash-latest)...")
+    try:
+        return genai.GenerativeModel("gemini-1.5-flash-latest")
+    except Exception as e:
+        st.error(f"❌ No se pudo cargar el modelo Gemini: {e}")
+        logger.error(f"Error cargando modelo Gemini: {e}")
+        return None
 
-    # Gemini prefiere una concatenación más directa o el uso de 'parts' para roles.
-    # Para una única llamada de generación de texto, concatenar es simple.
-    prompt = f"{system_prompt}\n\nInterpretación Rorschach para las siguientes respuestas del usuario:\n{message}"
-    logger.info(f"Prompt para Gemini generado con {len(prompt)} caracteres")
-    return prompt
+model = get_gemini_model()
 
-# Generar respuesta desde Gemini
-def generate_with_gemini(user_input_message):
+# --- CARGA Y PROCESAMIENTO DE DATOS ---
+@st.cache_data
+def load_data():
+    """Carga y procesa los archivos JSON, uniéndolos para un acceso rápido."""
+    try:
+        path_codigos = os.path.join('PLANTILLAS', 'DIC_NOMBRES_CODIGOS_FICHAS.json')
+        path_notificacion = os.path.join('PLANTILLAS', 'DATOS_NOTIFICACION.json')
+
+        with open(path_codigos, 'r', encoding='utf-8') as f:
+            data_codigos = json.load(f)
+        
+        with open(path_notificacion, 'r', encoding='utf-8') as f:
+            data_notificacion = json.load(f)
+
+        # Crear un diccionario para búsqueda rápida de datos de notificación por FICHA
+        notificacion_map = {item['FICHA']: item for item in data_notificacion}
+        
+        # Generar una lista de nombres de eventos únicos para la búsqueda con IA
+        nombres_eventos_unicos = sorted(list(set(item['NOMBRES DE PROTOCOLOS'] for item in data_codigos)))
+
+        logger.info(f"✅ Datos cargados: {len(data_codigos)} registros de códigos y {len(data_notificacion)} eventos de notificación.")
+        return data_codigos, notificacion_map, nombres_eventos_unicos
+
+    except FileNotFoundError as e:
+        st.error(f"❌ Error: No se encontró el archivo {e.filename}. Asegúrate de que los archivos JSON estén en la carpeta 'PLANTILLAS'.")
+        logger.error(f"Archivo no encontrado: {e.filename}")
+        return None, None, None
+    except json.JSONDecodeError as e:
+        st.error(f"❌ Error: El archivo JSON tiene un formato incorrecto: {e}")
+        logger.error(f"Error de formato JSON: {e}")
+        return None, None, None
+
+data_codigos, notificacion_map, nombres_eventos_unicos = load_data()
+
+
+# --- LÓGICA DE BÚSQUEDA ---
+
+def search_direct(query, data, notif_map):
+    """Realiza una búsqueda directa por código, nombre exacto o ficha."""
+    query_lower = query.lower().strip()
+    results = set() # Usar un set para evitar duplicados de fichas
+    
+    for item in data:
+        ficha = item.get("FICHA")
+        if not ficha:
+            continue
+
+        # Comprobar coincidencias en varios campos
+        if (query_lower == item.get("CIE 10", "").lower().strip() or
+            query_lower == item.get("CIE 11", "").lower().strip() or
+            query_lower == ficha.lower().strip() or
+            query_lower in item.get("NOMBRES DE PROTOCOLOS", "").lower()):
+            results.add(ficha)
+            
+    if not results:
+        return []
+    
+    # Construir la lista de resultados completos
+    final_results = []
+    for ficha in results:
+        # Encontrar todos los detalles de códigos para esa ficha
+        detalles_codigos = [d for d in data if d.get("FICHA") == ficha]
+        # Obtener los datos de notificación
+        info_notificacion = notif_map.get(ficha)
+        if info_notificacion:
+            final_results.append({
+                "info_notificacion": info_notificacion,
+                "detalles_codigos": detalles_codigos
+            })
+            
+    return final_results
+
+
+def search_with_gemini(query, event_list):
+    """Usa Gemini para encontrar el evento más relevante a partir de una consulta en lenguaje natural."""
     if not model:
-        logger.error("❌ No hay modelo Gemini disponible para generar respuesta")
-        return "Error de conexión con el modelo Gemini. Por favor, inténtelo de nuevo más tarde."
-
+        return "Error: Modelo de IA no disponible."
+
+    # Prompt cuidadosamente diseñado para obtener una respuesta estructurada
+    system_prompt = f"""
+    Eres un asesor experto en SIVIGILA, el sistema de vigilancia en salud pública de Colombia.
+    Tu tarea es identificar el evento de notificación más relevante basado en la consulta de un profesional de la salud.
+    A continuación, te proporciono una lista de los nombres oficiales de los protocolos de notificación.
+    
+    LISTA DE PROTOCOLOS OFICIALES:
+    {'; '.join(event_list)}
+    
+    Analiza la siguiente consulta del usuario y devuelve ÚNICAMENTE el nombre exacto del protocolo o protocolos de la lista que mejor correspondan.
+    Si encuentras varios, sepáralos con un punto y coma (;).
+    Si la consulta no corresponde a ningún protocolo de la lista, responde con "NO_ENCONTRADO".
+    No añadas explicaciones, saludos ni texto adicional. Solo el nombre del protocolo.
+    
+    Consulta del usuario: "{query}"
+    """
+    
     try:
-        logger.info(f"🔄 Iniciando llamada al API de Gemini - {datetime.datetime.now()}")
-
-        generation_config = genai.types.GenerationConfig(
-            temperature=0.7, # Gemini usa un rango similar, 0.9 es bastante creativo
-            max_output_tokens=1024, # Aumentado un poco para asegurar respuestas completas
-            top_p=0.95,
-            # top_k es otro parámetro que podrías usar en Gemini
-            # repetition_penalty no es un parámetro directo en GenerationConfig
-            # do_sample es implícito si temperature > 0
-            # seed no es un parámetro directo de GenerationConfig para `generate_content`
-        )
-
-        formatted_prompt = format_prompt_gemini(user_input_message)
-        start_time = datetime.datetime.now()
-
-        # Llamada a Gemini
-        response = model.generate_content(
-            formatted_prompt,
-            generation_config=generation_config
-        )
-
-        end_time = datetime.datetime.now()
-        duration = (end_time - start_time).total_seconds()
-
-        logger.info(f"✅ Respuesta de Gemini generada en {duration:.2f} segundos")
-
-        # Acceder al texto de la respuesta
+        logger.info(f"🔄 Enviando consulta a Gemini: '{query}'")
+        response = model.generate_content(system_prompt)
+        
         if response.parts:
-            output_text = response.text
+            result_text = response.text.strip()
+            logger.info(f"✅ Respuesta de Gemini: '{result_text}'")
+            if result_text == "NO_ENCONTRADO":
+                return []
+            # Devolver una lista de nombres de protocolos encontrados
+            return [name.strip() for name in result_text.split(';') if name.strip()]
         else:
-            # Esto podría ocurrir si la respuesta fue bloqueada por filtros de seguridad
             logger.warning(f"⚠️ Respuesta de Gemini vacía o bloqueada. Razón: {response.prompt_feedback}")
-            output_text = (
-                "No se pudo generar una respuesta. Esto podría deberse a filtros de seguridad "
-                f"o a un problema con la solicitud. Razón del feedback: {response.prompt_feedback}"
-            )
-        return output_text
-
+            return "Respuesta bloqueada por filtros de seguridad."
+            
     except Exception as e:
-        error_msg = f"❌ Error en la generación con Gemini: {str(e)}"
-        logger.error(error_msg)
-        # Verificar si el error es por API key inválida (aunque ya se verifica al inicio)
-        if "API_KEY_INVALID" in str(e):
-             st.error("La clave API de Gemini es inválida o ha expirado. Verifica tu configuración.")
-        return f"Lo siento, ocurrió un error durante la interpretación con Gemini. Detalles: {str(e)}"
-
-# Reemplazo de variables en documento Word
-from docx.enum.text import WD_ALIGN_PARAGRAPH
-
-def replace_variables_word(doc, variables):
-    for paragraph in doc.paragraphs:
-        for key, value in variables.items():
-            if f'<{key}>' in paragraph.text:
-                # Usar run para preservar formato si es posible, pero simple replace es más robusto para placeholder
-                # Si el placeholder está solo, paragraph.text es suficiente
-                # Si está entre otro texto, se necesita más cuidado con runs
-                new_text = paragraph.text.replace(f'<{key}>', str(value)) # Asegurar que value sea string
-                if paragraph.text != new_text: # Solo si hubo cambio
-                    paragraph.text = new_text
-                    paragraph.alignment = WD_ALIGN_PARAGRAPH.LEFT # Justificación
-    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:
-                            new_text = paragraph.text.replace(f'<{key}>', str(value))
-                            if paragraph.text != new_text:
-                                paragraph.text = new_text
-                                paragraph.alignment = WD_ALIGN_PARAGRAPH.LEFT
-
-
-# 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)
-        variables = {'INTERPRETACION': interpretation}
-        replace_variables_word(doc, variables)
+        logger.error(f"❌ Error en la llamada a Gemini: {e}")
+        return f"Error en la comunicación con la IA: {e}"
 
-        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:
-        error_msg = f"❌ Error al generar el documento: {str(e)}"
-        logger.error(error_msg)
-        st.error(error_msg)
-        return None
+# --- INTERFAZ DE USUARIO (UI) ---
 
-# Interfaz Streamlit
-st.title("Interpretación del Test de Rorschach (con Gemini)")
-logger.info("🚀 Aplicación (Gemini) iniciada")
+st.title("👨‍⚕️ Asesor Experto en Notificación SIVIGILA - Colombia")
+st.markdown("Busque una enfermedad por nombre, sinónimo, código CIE-10 o CIE-11 para obtener información de notificación.")
 
-entrada_usuario = st.text_area(
-    "Ingrese respuestas del Test de Rorschach:",
-    height=150,
-    placeholder="Ejemplo: Lámina I: Veo un murciélago sobre un noche estrellada..."
+query = st.text_input(
+    "Ingrese su búsqueda:",
+    placeholder="Ej: Dengue, T630, mordedura de serpiente, intoxicación por mercurio...",
+    help="Puede buscar por nombre de la enfermedad, palabras clave, o códigos CIE."
 )
 
-if st.button("Enviar Interpretación", type="primary"):
-    if not entrada_usuario:
-        st.warning("Por favor ingrese texto para interpretar")
-    elif not model: # Verificar si el modelo se cargó
-        st.error("El modelo de IA no está disponible. Por favor, revise la configuración y los logs.")
-        logger.error("Intento de generar interpretación sin modelo cargado.")
+if st.button("Buscar", type="primary"):
+    if not query:
+        st.warning("Por favor, ingrese un término de búsqueda.")
+    elif data_codigos is None or notificacion_map is None:
+        st.error("Los datos no se pudieron cargar. La aplicación no puede funcionar.")
     else:
-        logger.info(f"🔄 Procesando entrada de {len(entrada_usuario)} caracteres para Gemini")
-        with st.spinner("Generando interpretación con Gemini..."):
-            bot_response = generate_with_gemini(entrada_usuario) # Llamada a la nueva función
-            st.subheader("Interpretación (Gemini)")
-            st.markdown(bot_response) # Usar markdown para mejor formato si Gemini lo usa
-
-            if "No se pudo generar una respuesta" not in bot_response and "ocurrió un error" not in bot_response :
-                document_path = generate_word_document(bot_response)
-                if document_path:
-                    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_Gemini.docx",
-                        mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document"
-                    )
-                    logger.info("📄 Botón de descarga (Gemini) mostrado al usuario")
-                    # Clean up the temporary file
-                    try:
-                        os.remove(document_path)
-                        logger.info(f"🧹 Archivo temporal {document_path} eliminado.")
-                    except OSError as e_rm:
-                        logger.error(f"⚠️ Error al eliminar archivo temporal {document_path}: {e_rm}")
-
-                else:
-                    logger.error("❌ No se pudo generar el documento Word (Gemini)")
-            else:
-                logger.warning("⚠️ No se generó documento Word debido a error en la interpretación.")
-
-# --- END OF FILE manchas_gemini.py ---
+        # --- Lógica principal al hacer clic en el botón ---
+        with st.spinner("Buscando..."):
+            
+            # 1. Intento de búsqueda directa
+            results = search_direct(query, data_codigos, notificacion_map)
+            
+            # 2. Si no hay resultados directos, usar IA
+            if not results:
+                logger.info(f"Búsqueda directa para '{query}' no arrojó resultados. Usando Gemini...")
+                protocol_names = search_with_gemini(query, nombres_eventos_unicos)
+                
+                if isinstance(protocol_names, str): # Manejo de errores de Gemini
+                    st.error(protocol_names)
+                    protocol_names = []
+
+                if protocol_names:
+                    # Usamos los nombres devueltos por Gemini para hacer una búsqueda directa
+                    temp_results = []
+                    for name in protocol_names:
+                        temp_results.extend(search_direct(name, data_codigos, notificacion_map))
+                    
+                    # Eliminar duplicados si Gemini devuelve protocolos que caen en la misma ficha
+                    unique_fichas = set()
+                    for res in temp_results:
+                        ficha = res["info_notificacion"]["FICHA"]
+                        if ficha not in unique_fichas:
+                            results.append(res)
+                            unique_fichas.add(ficha)
+        
+        # 3. Mostrar resultados
+        st.markdown("---")
+        if not results:
+            st.info(f"No se encontraron eventos de notificación obligatoria para su búsqueda: '{query}'.")
+        else:
+            st.success(f"Se encontraron {len(results)} evento(s) relacionado(s) con su búsqueda:")
+            
+            for result in results:
+                info = result["info_notificacion"]
+                codigos = result["detalles_codigos"]
+                
+                with st.expander(f"**Evento: {info.get('Evento', 'Sin nombre')} (Ficha: {info.get('FICHA', 'N/A')})**", expanded=True):
+                    
+                    # Resumen de notificación
+                    st.subheader("Información de Notificación")
+                    col1, col2, col3 = st.columns(3)
+                    
+                    notif_inmediata = info.get("Notificación Inmediata", "NO") == "SI"
+                    notif_super = info.get("Notificación superinmedita", "NO") == "SI"
+
+                    if notif_inmediata or notif_super:
+                        st.success("**Requiere Notificación Inmediata.**")
+                        if notif_super:
+                            st.warning(f"**¡ATENCIÓN! Requiere Notificación SUPERINMEDIATA:** {info.get('Descripción superinmediata', '')}")
+                    else:
+                        st.info("**Notificación Semanal.**")
+
+                    st.markdown(f"**Requisito:** {info.get('REQUISITO', 'No especificado')}")
+                    st.markdown(f"**Fichas a utilizar:** {info.get('Fichas a Utilizar', 'No especificado').replace('+', '\n+')}")
+                    
+                    # Detalles de códigos
+                    st.subheader("Códigos Relacionados (CIE-10 y CIE-11)")
+                    for codigo in codigos:
+                        st.markdown(f"""
+                        - **Nombre Protocolo:** `{codigo.get('NOMBRES DE PROTOCOLOS', 'N/A')}`
+                          - **CIE-10:** `{codigo.get('CIE 10', 'N/A')}`
+                          - **CIE-11:** `{codigo.get('CIE 11', 'N/A')}` | **Nombre CIE-11:** *{codigo.get('NOMBRES DE CIE 11', 'N/A')}*
+                        """)