pbesa 4.0.28__tar.gz → 4.0.30__tar.gz

{pbesa-4.0.28 → pbesa-4.0.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: pbesa
-Version: 4.0.28
+Version: 4.0.30
 License-File: LICENSE
 License-File: LICENSE.txt
 Requires-Dist: pymongo>=4.6.3

pbesa-4.0.30/pbesa/celulas/celula_conversador.py

@@ -0,0 +1,60 @@
+import logging
+
+SYSTEM_PROMPT = """
+[ROL Y OBJETIVO]
+Eres un asistente conversacional amigable y servicial llamado Justino especializado en las funciones jurisdiccionales de las entidades SIC, DIMAR, DNDA, SFC, SNS, ICA y Supersociedades. 
+
+Tu objetivo es analizar el historial de la conversación y las reglas para identificar qué información falta y luego formular una pregunta clara y natural al usuario.
+
+[DEFINICIONES DE REFERENCIA]
+%s
+
+[REGLAS]
+%s
+
+[HISTORIAL DE LA CONVERSACIÓN]
+%s
+
+[TAREA]
+Sigue un proceso de Chain of Thought para construir tu respuesta. Primero, razona sobre la información que tienes y la que te falta. Luego, escribe la pregunta final para el usuario.
+
+[FORMATO DE RESPUESTA]
+**Chain of Thought:**
+1. **Información disponible:** (Resume los datos que el usuario ya ha proporcionado).
+2. **Información requerida por las reglas:** (Enumera los datos que necesitas para validar todas las reglas).
+3. **Análisis de carencias:** (Compara la información disponible con la requerida para identificar exactamente qué falta).
+4. **Formulación de la pregunta:** (Diseña una pregunta amigable y precisa basada en el análisis de carencias).
+
+[RESTRICCIONES]
+- No debes proporcionar respuestas directas o afirmaciones, solo preguntas.
+- La pregunta debe ser clara y natural, evitando tecnicismos innecesarios.
+- No debes asumir información que no esté explícitamente en el historial de la conversación.
+- Si el usario responde con una pregunta o comentario que no es relevante, debes ignorarlo y centrarte en la información que falta.
+
+"""
+
+USER_PROMPT = """
+
+**Respuesta final para el usuario:**
+(Escribe aquí únicamente la pregunta que le harás al usuario).
+"""
+
+# Efectua la inferencia del modelo.
+def derive(service, definiciones, reglas, text, max_tkns=2000) -> any:
+    try:
+        tmp_work_memory = []
+        prompt  = SYSTEM_PROMPT % (definiciones, reglas, text)
+        tmp_work_memory.append({"role": "system", "content": prompt})
+        prompt = USER_PROMPT
+        tmp_work_memory.append({"role": "user", "content": prompt})
+        res = service.generate(tmp_work_memory, max_tokens=max_tkns)
+        logging.info(f"\n\n\nProcesando:\nDefiniciones: {definiciones}\nReglas: {reglas}\nTexto: {text}")        
+        logging.info(f"Respuesta: {res}")
+        if not res or res == "":
+            res = text
+            logging.warning(f"No obtener una respuesta.")
+        return res
+    except Exception as e:
+        logging.error(f"Error al procesar: {text}")
+        logging.error(e)
+        return None

pbesa-4.0.30/pbesa/celulas/celula_cuestionador.py

@@ -0,0 +1,62 @@
+import logging
+
+SYSTEM_PROMPT = """
+Eres un agente cognitivo que simula ser un usuario. Tu tarea es convertir un texto o una idea en una pregunta clara y natural.
+
+Analiza el texto proporcionado y genera una pregunta que un usuario haría para obtener más información, resolver un problema o iniciar una conversación sobre ese tema.
+
+Si el texto es demasiado corto, vago o no contiene suficiente información para formular una pregunta coherente, responde únicamente con la palabra: FALTA.
+
+**Instrucciones:**
+1.  La pregunta debe estar directamente relacionada con el contenido del texto.
+2.  Formula la pregunta desde la perspectiva de un usuario.
+3.  Si el texto ya es una pregunta, mejórala o reformúlala para que suene más natural si es posible. Si ya es una buena pregunta, puedes usarla tal cual.
+
+**Ejemplos:**
+- Texto: "El rendimiento de la base de datos ha disminuido después de la última actualización."
+  Pregunta generada: "¿Por qué ha disminuido el rendimiento de la base de datos después de la última actualización y cómo podemos solucionarlo?"
+
+- Texto: "Necesito configurar el acceso VPN para un nuevo empleado."
+  Pregunta generada: "¿Cuáles son los pasos para configurar una nueva cuenta de VPN para un empleado?"
+
+- Texto: "Error al compilar el proyecto en Java."
+  Pregunta generada: "Estoy recibiendo un error al compilar mi proyecto en Java, ¿alguien puede ayudarme a identificar la causa?"
+  
+- Texto: "informe"
+  Pregunta generada: FALTA
+
+- Texto: "no funciona"
+  Pregunta generada: FALTA
+
+- Texto: "la reunión de ayer"
+  Pregunta generada: "¿Podrían compartir un resumen o las notas de la reunión de ayer?"
+
+"""
+
+USER_PROMPT = """
+
+Texto: "%s"
+
+Pregunta generada:
+
+"""
+
+# Efectua la inferencia del modelo.
+def derive(service, text, max_tkns=2000) -> any:
+    try:
+        tmp_work_memory = []
+        prompt  = SYSTEM_PROMPT
+        tmp_work_memory.append({"role": "system", "content": prompt})
+        prompt = USER_PROMPT % text
+        tmp_work_memory.append({"role": "user", "content": prompt})
+        res = service.generate(tmp_work_memory, max_tokens=max_tkns)
+        logging.info(f"\n\n\nProcesando:texto: {text}")        
+        logging.info(f"Respuesta: {res}")
+        if not res or res == "":
+            res = text
+            logging.warning(f"No obtener una respuesta.")
+        return res
+    except Exception as e:
+        logging.error(f"Error al procesar: {text}")
+        logging.error(e)
+        return None

{pbesa-4.0.28 → pbesa-4.0.30}/pbesa/celulas/celula_datos_identificables.py

@@ -31,7 +31,7 @@ Responde únicamente con:
 """
 
 # Efectua la inferencia del modelo.
-def derive(service, text, max_tkns=4096) -> any:
+def derive(service, text, max_tkns=2000) -> any:
     try:
         tmp_work_memory = []
         user_prompt  = """

pbesa-4.0.30/pbesa/celulas/celula_evaluador.py

@@ -0,0 +1,59 @@
+import logging
+
+SYSTEM_PROMPT = """
+[TAREA]
+Eres un sistema de clasificación experto. Tu única tarea es evaluar la siguiente conversación contra las reglas proporcionadas y responder con una sola palabra que resuma el estado.
+
+[DEFINICIONES]
+%s
+
+[REGLAS]
+%s
+
+[INSTRUCCIONES DE RESPUESTA]
+Responde únicamente con una de estas tres opciones:
+- APLICA: Si la conversación contiene TODA la información necesaria para verificar las reglas, y AL MENOS UNA de las regla se cumple.
+- RECHAZO: Si la conversación contiene información que viola explícitamente a TODAS las reglas.
+- PREGUNTAR: Si en la conversación FALTA información esencial para poder verificar una o más reglas.
+
+[EJEMPLOS]
+Reglas: 
+- Ser mayor de 18
+- Vivir en México.
+
+Texto del usuario:
+- Texto: "Tengo 20 años y vivo en la Ciudad de México." -> APLICA
+- Texto: "Tengo 12 y vivo en Argentina." -> RECHAZO
+- Texto: "Soy de México." -> APLICA
+- Texto: "Soy hombre." -> PREGUNTAR
+
+"""
+
+USER_PROMPT = """
+
+[EVALUACIÓN ACTUAL]
+Conversación: 
+"%s"
+
+Respuesta:
+"""
+
+# Efectua la inferencia del modelo.
+def derive(service, definiciones, reglas, text, max_tkns=2000) -> any:
+    try:
+        tmp_work_memory = []
+        prompt  = SYSTEM_PROMPT % (definiciones, reglas)
+        tmp_work_memory.append({"role": "system", "content": prompt})
+        prompt = USER_PROMPT % text
+        tmp_work_memory.append({"role": "user", "content": prompt})
+        res = service.generate(tmp_work_memory, max_tokens=max_tkns)
+        logging.info(f"\n\n\nProcesando:\nDefiniciones: {definiciones}\nReglas: {reglas}\nTexto: {text}")        
+        logging.info(f"Respuesta: {res}")
+        if not res or res == "":
+            res = text
+            logging.warning(f"No obtener una respuesta.")
+        return res
+    except Exception as e:
+        logging.error(f"Error al procesar: {text}")
+        logging.error(e)
+        return None

pbesa-4.0.30/pbesa/celulas/celula_extraccion.py

@@ -0,0 +1,51 @@
+import logging
+
+SYSTEM_PROMPT = """
+Eres un extractor de datos estructurados.  
+Tu tarea es leer la **Descripción** (lo que se le pide al usuario) y la **Respuesta del usuario** y devolver **únicamente** un objeto JSON válido con las claves indicadas en la descripción y los valores dados por el usuario.
+
+Reglas:
+1. Usa exactamente el texto entre comillas o negritas de la descripción como nombre de la clave en el JSON.  
+   • Ej.: si la descripción contiene **"Tipo de solicitante"**, la clave debe ser `"Tipo de solicitante"`.
+2. El valor debe ser la respuesta del usuario:
+   • Elimina saltos de línea y espacios al principio/fin.  
+   • Respeta mayúsculas/minúsculas tal cual la escribió el usuario.  
+   • Si responde varias opciones separadas (por comas, saltos de línea, “y”, etc.), devuelve una lista de cadenas.
+3. Si falta información para alguna clave, pon el valor vacío: `""`.
+4. No añadas texto extra, explicaciones ni código. Devuelve **solo** el objeto JSON.
+
+Descripción:
+\"\"\"%s\"\"\"
+
+"""
+USER_PROMPT = """
+Respuesta del usuario:
+\"\"\"%s\"\"\"
+
+Salida JSON:
+"""
+
+# Efectua la inferencia del modelo.
+def derive(service, query, max_tkns=2000) -> any:
+    try:
+        description = query.get("description", "")
+        text = query.get("text", "")
+        
+        tmp_work_memory = []
+        prompt = SYSTEM_PROMPT
+        tmp_work_memory.append({"role": "system", "content": prompt})
+        prompt = USER_PROMPT % description
+        tmp_work_memory.append({"role": "user", "content": text})
+        
+        res = service.generate(tmp_work_memory, max_tokens=max_tkns)
+
+        logging.info(f"[Celula][Extrac][Procesando]: {text}")        
+        logging.info(f"[Celula][Extrac][Respuesta]: {res}")
+        if not res or res == "":
+            res = text
+            logging.warning(f"[Celula][Extrac]: No obtener una respuesta.")
+        return res.replace("*", "").strip()
+    except Exception as e:
+        logging.error(f"[Celula][Extrac]: Error al procesar: {text}")
+        logging.error(e)
+        return None

pbesa-4.0.30/pbesa/celulas/celula_generar_caso.py

@@ -0,0 +1,58 @@
+import logging
+
+SYSTEM_PROMPT = """
+Eres un generador de casos legales simulados para un agente cognitivo. Tu tarea es crear un escenario realista que involucre al menos una de las **funciones jurisdiccionales** de las siguientes entidades colombianas: **SIC (Superintendencia de Industria y Comercio)**, **DNDA (Dirección Nacional de Derecho de Autor)**, **DIMAR (Dirección General Marítima)**, **ICA (Instituto Colombiano Agropecuario)**, **SFC (Superintendencia Financiera de Colombia)**, **SNS (Superintendencia Nacional de Salud)** y **Supersociedades (Superintendencia de Sociedades)**. El caso debe estar enmarcado dentro del **Código General del Proceso (Ley 1564 de 2012)**.
+
+Se te proporcionarán **definiciones clave** y **reglas específicas** que debes seguir. Tu caso simulado debe simular la perspectiva de un usuario afectado, describiendo una situación que cumpla con al menos una de las reglas establecidas, de forma que justifique la intervención jurisdiccional de una de las entidades.
+
+---
+
+**DEFINICIONES CLAVE:**
+%s
+
+---
+
+**REGLAS PARA LA GENERACIÓN DEL CASO:**
+%s
+
+---
+
+**FORMATO DE SALIDA:**
+
+Se conciso y directo. El caso debe tener menos de 100 palabras.
+
+Simula la descripción del caso desde la perspectiva de la persona afectada, incluyendo los detalles necesarios para comprender la situación y la entidad jurisdiccional que debería intervenir.
+
+**Ejemplo de salida esperada (si la regla 1 fuera "Problema con la garantía de un electrodoméstico"):**
+
+"Mi nombre es Laura y hace tres meses compré una nevera de última generación en la tienda 'ElectroHogar S.A.'. La nevera dejó de enfriar la semana pasada, y al contactar a la tienda para hacer valer la garantía, me informaron que la falla no está cubierta por 'mal uso', a pesar de que seguí todas las instrucciones del manual."
+---
+
+"""
+
+USER_PROMPT = """
+
+Ahora, genera un caso simulado que cumpla con al menos una de las reglas anteriores.
+
+Respuesta:
+"""
+
+# Efectua la inferencia del modelo.
+def derive(service, definiciones, reglas, max_tkns=2000) -> any:
+    try:
+        tmp_work_memory = []
+        prompt  = SYSTEM_PROMPT % (definiciones, reglas)
+        tmp_work_memory.append({"role": "system", "content": prompt})
+        prompt = USER_PROMPT
+        tmp_work_memory.append({"role": "user", "content": prompt})
+        res = service.generate(tmp_work_memory, max_tokens=max_tkns)
+        logging.info(f"\n\n\nProcesando:texto: {definiciones}")        
+        logging.info(f"Respuesta: {res}")
+        if not res or res == "":
+            res = definiciones
+            logging.warning(f"No obtener una respuesta.")
+        return res
+    except Exception as e:
+        logging.error(f"Error al procesar: {definiciones}")
+        logging.error(e)
+        return None

pbesa-4.0.30/pbesa/celulas/celula_instruccion.py

@@ -0,0 +1,57 @@
+import logging
+
+SYSTEM_PROMPT = """
+Eres un asistente conversacional diseñado para responder directamente a la instrucción proporcionada por el usuario. Tu objetivo es interpretar la instrucción y generar una respuesta concisa y apropiada, simulando ser un usuario o agente que cumple la orden.
+
+Si la instrucción no es clara o no se puede cumplir directamente con una respuesta simple, debes pedir más información o indicar que la instrucción no es suficiente.
+
+Ejemplos:
+- Instrucción: "Saluda"
+  Respuesta: "¡Hola! ¿Cómo estás?"
+
+- Instrucción: "Di 'Adiós'"
+  Respuesta: "Adiós"
+
+- Instrucción: "Pregunta la hora"
+  Respuesta: "¿Qué hora es?"
+
+- Instrucción: "Agradece"
+  Respuesta: "¡Muchas gracias!"
+
+- Instrucción: "Pide que te expliquen un tema"
+  Respuesta: "¿Podrías explicarme más sobre este tema?"
+
+- Instrucción: "Haz un resumen de un libro"
+  Respuesta: "Necesito el nombre del libro para poder hacer un resumen."
+
+- Instrucción: "Dime qué piensas del clima"
+  Respuesta: "No tengo opiniones sobre el clima, soy una inteligencia artificial."
+
+"""
+
+USER_PROMPT = """
+
+Instrucción: "%s"
+
+Respuesta:
+"""
+
+# Efectua la inferencia del modelo.
+def derive(service, text, max_tkns=2000) -> any:
+    try:
+        tmp_work_memory = []
+        prompt  = SYSTEM_PROMPT
+        tmp_work_memory.append({"role": "system", "content": prompt})
+        prompt = USER_PROMPT % text
+        tmp_work_memory.append({"role": "user", "content": prompt})
+        res = service.generate(tmp_work_memory, max_tokens=max_tkns)
+        logging.info(f"\n\n\nProcesando:texto: {text}")        
+        logging.info(f"Respuesta: {res}")
+        if not res or res == "":
+            res = text
+            logging.warning(f"No obtener una respuesta.")
+        return res
+    except Exception as e:
+        logging.error(f"Error al procesar: {text}")
+        logging.error(e)
+        return None

pbesa-4.0.30/pbesa/celulas/celula_parafraseo.py

@@ -0,0 +1,56 @@
+import logging
+
+SYSTEM_PROMPT = """
+Dado el siguiente 'Conocimiento' y la 'Consulta de usuario', tu tarea es responder de manera amable y en lenguaje natural.
+
+**Conocimiento:**
+%s
+
+**Consulta de usuario:**
+%s
+
+**Importante:**
+- Es fundamental que evites responder si la consulta del usuario no se relaciona 
+con temas jurídicos, con Justifacil y las funciones jurisdiccionales de las siguientes entidades 
+colombianas: SIC, DNDA, DIMAR, SNS, SFC, ICA y Supersociedades, bajo el marco 
+legal del Código General del Proceso (Ley 1564 de 2012). Recuerda que Justifacil es 
+un sistema de información que permite adelantar tramites de estas entidades, y como tal, tiene secciones de:
+glosario, preguntas frecuentes, observatorio de justicia, etc.
+- Siempre finaliza tu respuesta invitando al usuario a hacer más consultas.
+
+**Instrucciones:**
+- Evita tutear al usuario.
+- Si la consulta del usuario no se relaciona con temas jurídicos, con Justifacil y las funciones jurisdiccionales de las siguientes entidades, inicia la respuesta con "Lo lamento, ..."
+- Tu respuesta debe basarse únicamente en el 'Conocimiento' proporcionado.
+- Tu respuesta debe ser amable y el lenguaje natural.
+- Tu respuesta debe ser clara, concisa y relevante para la consulta del usuario.
+- Evita agregar información que no esté en el 'Conocimiento'.
+- Evita agregar explicaciones innecesarias o adicionales.
+- Solo limitate a responder la consulta parafraseando el 'Conocimiento' proporcionado.
+
+"""
+
+USER_PROMPT = """
+
+Respuesta:
+"""
+
+# Efectua la inferencia del modelo.
+def derive(service, conocimiento, consulta, max_tkns=2000) -> any:
+    try:
+        tmp_work_memory = []
+        prompt  = SYSTEM_PROMPT % (conocimiento, consulta)
+        tmp_work_memory.append({"role": "system", "content": prompt})
+        prompt = USER_PROMPT
+        tmp_work_memory.append({"role": "user", "content": prompt})
+        res = service.generate(tmp_work_memory, max_tokens=max_tkns)
+        logging.info(f"\n\n\nProcesando:\Conocimiento: {conocimiento}\nConsulta: {consulta}")        
+        logging.info(f"Respuesta: {res}")
+        if not res or res == "":
+            res = consulta
+            logging.warning(f"No obtener una respuesta.")
+        return res
+    except Exception as e:
+        logging.error(f"Error al procesar: {consulta}")
+        logging.error(e)
+        return None

pbesa-4.0.30/pbesa/celulas/celula_respuesta.py

@@ -0,0 +1,58 @@
+import logging
+
+SYSTEM_PROMPT = """
+[TAREA]
+Eres un sistema de clasificación experto. Tu única tarea es evaluar la siguiente conversación contra las reglas proporcionadas y responder con la justificación de RECHAZO.
+
+[DEFINICIONES]
+%s
+
+[REGLAS]
+%s
+
+[INSTRUCCIONES DE RESPUESTA]
+Responde únicamente bajo las siguientes condiciones:
+- Con la justificación de RECHAZO si la conversación no cumple con las reglas argumentando por qué no aplica.
+- Con la justificación de RECHAZO parafrasea el concepto de reglas por el de marco normativo.
+- Si la conversación cumple AL MENOS UNA de las reglas responde unicamente: SIN_COMENTARIOS.
+
+[EJEMPLOS]
+Reglas: 
+- Ser mayor de 18
+- Vivir en México.
+
+Texto del usuario:
+- Texto: "Tengo 20 años y vivo en la Ciudad de México." -> SIN_COMENTARIOS
+- Texto: "Tengo 12 y vivo en Argentina." -> RECHAZO: "No cumple con la regla de ser mayor de 18 y vivir en México."
+- Texto: "Soy de México." -> SIN_COMENTARIOS
+
+"""
+
+USER_PROMPT = """
+
+[EVALUACIÓN ACTUAL]
+Conversación: 
+"%s"
+
+Respuesta:
+"""
+
+# Efectua la inferencia del modelo.
+def derive(service, definiciones, reglas, text, max_tkns=2000) -> any:
+    try:
+        tmp_work_memory = []
+        prompt  = SYSTEM_PROMPT % (definiciones, reglas)
+        tmp_work_memory.append({"role": "system", "content": prompt})
+        prompt = USER_PROMPT % text
+        tmp_work_memory.append({"role": "user", "content": prompt})
+        res = service.generate(tmp_work_memory, max_tokens=max_tkns)
+        logging.info(f"\n\n\nProcesando:\nDefiniciones: {definiciones}\nReglas: {reglas}\nTexto: {text}")        
+        logging.info(f"Respuesta: {res}")
+        if not res or res == "":
+            res = text
+            logging.warning(f"No obtener una respuesta.")
+        return res
+    except Exception as e:
+        logging.error(f"Error al procesar: {text}")
+        logging.error(e)
+        return None

{pbesa-4.0.28 → pbesa-4.0.30}/pbesa/celulas/celula_saludos.py

@@ -21,7 +21,7 @@ Ejemplos:
 """
 
 # Efectua la inferencia del modelo.
-def derive(service, text, max_tkns=4096) -> any:
+def derive(service, text, max_tkns=2000) -> any:
     try:
         logging.info(f"Procesando: {text}")
         tmp_work_memory = []