pbesa 4.0.18__tar.gz → 4.0.19__tar.gz

{pbesa-4.0.18 → pbesa-4.0.19}/.gitignore

@@ -12,4 +12,5 @@
 __pycache__
 .vscode
 *.h5
-.env
+.env
+.pkl

{pbesa-4.0.18 → pbesa-4.0.19}/PKG-INFO

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

pbesa-4.0.19/pbesa/celulas/celula_simulador_ciudadano.py

@@ -0,0 +1,115 @@
+import logging
+
+SYSTEM_PROMPT = """
+Eres un **simulador de demandantes ante entes de control**.  
+Tu tarea es leer la **solicitud de demanda** que se te entregue y luego **responder cualquier pregunta** actuando como la persona que radicó dicha demanda.
+
+Responde siempre en **primera persona**, manteniendo un tono respetuoso y claro.  
+Menciona o alude a los entes de control involucrados cuando sea pertinente (SIC – Superintendencia de Industria y Comercio, ICA – Instituto Colombiano Agropecuario, DIMAR – Dirección General Marítima, SFC – Superintendencia Financiera de Colombia, SNS – Superintendencia Nacional de Salud, entre otros).
+
+---
+
+### Criterios que debe cumplir la respuesta
+
+1. **Perspectiva**: primera persona singular (“yo”, “mi”).  
+2. **Coherencia**: debe basarse exclusivamente en la información provista en la demanda.  
+3. **Pertinencia**: enfócate en la pregunta; no agregues información externa ni resoluciones legales.  
+4. **Claridad**: utiliza lenguaje sencillo y directo, evitando tecnicismos innecesarios.  
+5. **Respeto**: mantén un tono formal y cortés frente a la autoridad.
+
+**Importante**:
+- Solo responde a la pregunta. No agregues información adicional que no esté relacionada con la demanda.
+- Solo responde a la pregunta. No agregres explicaciones o justificaciones.
+- Si te preguntan datos personales, responde con datos inventados.
+- Si te preguntan datos de contacto, responde con datos inventados.
+- Si te preguntan de persona jurídica, responde con datos inventados.
+- Si te preguntan si deseas que te asista en la radicación de la demanda, responde que sí.
+
+---
+
+### Ejemplos
+
+**Demanda de ejemplo**  
+> “Como ciudadano preocupado por la seguridad fluvial, pongo en conocimiento que una barcaza de la Empresa de Transporte Fluvial del Magdalena se encuentra navegando sin certificado de navegabilidad vigente, lo cual representa un riesgo para la vida humana y la operación segura en el río.”
+
+| Pregunta                                           | Respuesta esperada                                                                                                                                                               |
+|----------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| “¿Cuál es el principal riesgo que identificó?”     | “Considero que el principal riesgo es la posible pérdida de vidas humanas ante un accidente, pues la embarcación no ha demostrado cumplir con los requisitos técnicos exigidos por DIMAR.” |
+| “¿Por qué decidió acudir ante la DIMAR y no a otra entidad?” | “Acudí a DIMAR porque es la autoridad marítima competente para verificar los certificados de navegabilidad y sancionar irregularidades en operaciones fluviales.”                  |
+| “¿Ha presentado pruebas?”                          | “Sí, anexé fotografías donde se observa la matrícula de la barcaza y la fecha de expiración del certificado.”                                                                     |
+
+---
+"""
+
+USER_PROMPT = """
+### Plantilla de uso
+
+Demanda:
+%s
+"""
+class UserSimulator(object):
+    """
+    Clase que simula un usuario demandante ante entes de control.
+    """
+
+    class __UserSimulator:
+
+        def __init__(self, service):
+            self.iteracion = 1
+            self.work_memory = []
+            self.service = service
+
+        # Efectua la inferencia del modelo.
+        def evaluate(self, text, max_tkns=2000, reset=False) -> any:
+            try:
+                if reset:
+                    self.iteracion = 1
+                    self.work_memory = []
+                logging.info("\n")
+                logging.info(f"Procesando: {text} - Iteración: {self.iteracion}")
+                if self.iteracion == 1:
+                    prompt  = SYSTEM_PROMPT
+                    self.work_memory.append({"role": "system", "content": SYSTEM_PROMPT})    
+                    prompt  = USER_PROMPT % text
+                    self.work_memory.append({"role": "user", "content": prompt})
+                else:
+                    self.work_memory.append({"role": "user", "content": text})
+                res = self.service.generate(self.work_memory, max_tkns)
+                self.work_memory.append({"role": "assistant", "content": res})
+                self.iteracion += 1
+                logging.info(f"Respuesta: {res}")
+                logging.info("\n")
+                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
+    
+    # Singleton instance
+    instance = None
+
+    def __new__(cls, service) -> object:
+        """ Create new instance """
+        if not UserSimulator.instance:
+            UserSimulator.instance = UserSimulator.__UserSimulator(service)
+        return UserSimulator.instance
+    
+    def __getattr__(self, name: str) -> object:
+        """ Get attribute
+        @param name Attribute name
+        @return object Attribute
+        """
+        return getattr(self.instance, name)
+    
+    def __setattr__(self, name:str) -> object:
+        """ Set attribute
+        @param name Attribute name
+        @return object Attribute
+        """
+        return setattr(self.instance, name)
+
+def derive(service, text, max_tkns=2000, reset=False) -> any:
+    return UserSimulator(service).evaluate(text, max_tkns=max_tkns, reset=reset)

pbesa-4.0.19/pbesa/celulas/data_extraction_cel.py

@@ -0,0 +1,148 @@
+import re
+import json
+import logging
+
+SYSTEM_PROMPT = """
+Eres un generador de JSON. Tu tarea es extraer la información proporcionada por el usuario, basándose en la descripción de los campos requeridos, y formatearla como un objeto JSON.
+
+**Descripción de los campos requeridos:**
+%s
+
+**Instrucciones para la extracción y formato JSON:**
+1.  Identifica cada valor proporcionado por el usuario y asócialo con su campo correspondiente de la descripción.
+2.  Los nombres de los campos en el JSON deben ser exactamente los de la "Descripción de los campos requeridos", sin las llaves ni guiones.
+3.  Si un campo no tiene un valor claro en la respuesta del usuario, omítelo del JSON.
+4.  Asegúrate de que el JSON sea válido.
+
+**Ejemplo de cómo el usuario podría responder y cómo debe ser el JSON resultante (basado en la descripción de campos "datos del Demandante: - Correo electrónico - Primer Nombre - Segundo Nombre - Primer Apellido - Segundo Apellido - Tipo de documento - Identificación - País donde se hace la solicitud - Departamento / Estado / Provincia donde se hace la solicitud - Municipio / Ciudad donde se hace la solicitud - Dirección notificación judicial"):**
+
+**Respuesta del usuario:** "micorreo@correo.com, Fabian, Jose, Roldan, Piñeros, CC, 123456789, Colombia, Cundinamarca, Bogotá, Calle 100 #10-20"
+**JSON resultante:**
+```json
+{
+  "Correo electrónico": "micorreo@correo.com",
+  "Primer Nombre": "Fabian",
+  "Segundo Nombre": "Jose",
+  "Primer Apellido": "Roldan",
+  "Segundo Apellido": "Piñeros",
+  "Tipo de documento": "CC",
+  "Identificación": "123456789",
+  "País donde se hace la solicitud": "Colombia",
+  "Departamento / Estado / Provincia donde se hace la solicitud": "Cundinamarca",
+  "Municipio / Ciudad donde se hace la solicitud": "Bogotá",
+  "Dirección notificación judicial": "Calle 100 #10-20"
+}
+"""
+
+USER_PROMPT = """
+
+Texto: "%s"
+
+Clasificación:
+"""
+
+def extract_field_constraints(text):    
+    field_constraints = {}
+    start_index = text.find(':')
+    if start_index != -1:
+        text = text[start_index+1:].strip()
+    lines = text.strip().split('\n')
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+        clean_line = line.lstrip('- ').strip()
+        is_obligatorio = True
+        if '(obligatorio)' in clean_line:
+            is_obligatorio = True
+            field_name = clean_line.replace('(obligatorio)', '').strip()
+        elif '(no obligatorio)' in clean_line:
+            is_obligatorio = False
+            field_name = clean_line.replace('(no obligatorio)', '').strip()
+        else:
+            field_name = clean_line.strip()
+        field_constraints[field_name] = is_obligatorio
+    return field_constraints
+
+def validar_campo(validaciones_campos, nombre_campo, valor):
+    if nombre_campo in validaciones_campos:
+        config = validaciones_campos[nombre_campo]
+        regex = config["validacion"]
+        mensaje = config["mensaje_error"]
+        if re.fullmatch(regex, valor):
+            return True, None
+        else:
+            return False, mensaje
+    else:
+        return False, f"No se encontró configuración de validación para el campo: {nombre_campo}"
+
+def procesar_datos(validaciones_campos, description, datos):
+    """ Procesa los datos extraídos y valida cada campo """
+    # Obtiene los campos
+    field_constraints = extract_field_constraints(description)
+    logging.info("Campos extraídos:")
+    logging.info(json.dumps(field_constraints, indent=4))
+    for field, is_required in field_constraints.items():
+        if is_required and field not in datos:
+            logging.error(f"Falta el campo obligatorio: {field}")
+            return None
+        if field not in datos:
+            datos[field] = None
+    logging.info("Los campos estan completos.")
+    # Validar los campos extraídos
+    errores = []
+    resultado = {}
+    for campo, valor in datos.items():
+        valido, mensaje_error = validar_campo(validaciones_campos, campo, str(valor))
+        if not valido:
+            errores.append(f"Error en '{campo}': {mensaje_error}")
+        else:
+            resultado[campo] = valor
+    if errores:
+        logging.error("Errores de validación encontrados:")
+        for error in errores:
+            logging.error(error)
+        return None, error
+    else:
+        logging.info("Todos los campos validados correctamente.")
+        return resultado, None
+
+def get_struct(text):
+    json_start = text.find('{')
+    json_end = text.rfind('}') + 1
+    json_string = text[json_start:json_end]
+    return json.loads(json_string)
+
+# Efectua la inferencia del modelo.
+def call_engine(service, description, text) -> any:
+    try:
+        tmp_work_memory = []
+        system_prompt  = SYSTEM_PROMPT % description
+        tmp_work_memory.append({"role": "system", "content": system_prompt})
+        user_prompt = USER_PROMPT % text
+        tmp_work_memory.append({"role": "user", "content": user_prompt})
+        logging.info(f"Enviando solicitud al modelo...")
+        res = service.generate(tmp_work_memory)
+        result = get_struct(res)
+        logging.info(f"El model ha respondido con éxito.")
+        return result
+    except Exception as e:
+        logging.error(f"El modelo ha fallado al procesar la solicitud.")
+        logging.error(f"Error al procesar: {text}")
+        logging.error(e)
+        return None
+
+def derive(description, text) -> any:
+    result = derive(description, text)
+    if result:
+        logging.info("\n" *3)
+        logging.info(f"Descripción: {description}")
+        logging.info(f"Texto: {text}")
+        logging.info(f"Resultado:")            
+        logging.info(json.dumps(result, indent=4))
+        logging.info(f"Esperado:")
+        expected = json.loads(expected)
+        logging.info(json.dumps(expected, indent=4))
+        logging.info("\n" *3)
+        return procesar_datos(description, result)
+    return None, "no pude identificar los datos en el texto proporcionado."

{pbesa-4.0.18 → pbesa-4.0.19}/pbesa/cognitive.py

@@ -15,6 +15,7 @@
 import re
 import uuid
 import json
+import pickle
 import logging
 import traceback
 from .mas import Adm
@@ -656,7 +657,10 @@ class Dialog(ABC):
             logging.debug(iniciador.text)
         logging.debug("")
         # Set dialog state
-        self.__dfa['start'] = iniciadores
+        self.__dfa['start'] = iniciadores        
+        #filename = f'{self.__role.name}_grafo.pkl'
+        #with open(filename, 'wb') as f:
+        #    pickle.dump(grafo, f)
 
     def load_model(self, provider, config, ai_service=None, substitudes = False) -> None:
         self.__service_provider, service = define_service_provider(provider, ai_service, substitudes)
@@ -877,25 +881,57 @@ class Dialog(ABC):
         caso = celula_casos.derive(self.__ai_service, query, max_tkns=10)
         consulta = celula_consultas.derive(self.__ai_service, query, max_tkns=10)
         # Verifica si es un saludo, consulta o caso
-        es_saludo = ("SALUDO" in saludo) and ("NO_PREGUNTA" in consulta) and ("NO_QUEJA_DEMANDA" in caso) and not ("NO_SALUDO" in saludo)    
-        es_consulta = ("PREGUNTA_O_SOLICITUD" in consulta) and ("NO_QUEJA_DEMANDA" in caso) and ("NO_SALUDO" in saludo) and not ("NO_PREGUNTA" in consulta)
-        es_caso = ("QUEJA_DEMANDA" in caso) and ("NO_PREGUNTA" in consulta) and ("NO_SALUDO" in saludo) and not ("NO_QUEJA_DEMANDA" in caso)
+
+        #es_saludo = ("SALUDO" in saludo) and ("NO_PREGUNTA" in consulta) and ("NO_QUEJA_DEMANDA" in caso) and not ("NO_SALUDO" in saludo)    
+        #es_consulta = ("PREGUNTA_O_SOLICITUD" in consulta) and ("NO_QUEJA_DEMANDA" in caso) and ("NO_SALUDO" in saludo) and not ("NO_PREGUNTA" in consulta)
+        #es_caso = ("QUEJA_DEMANDA" in caso) and ("NO_PREGUNTA" in consulta) and ("NO_SALUDO" in saludo) and not ("NO_QUEJA_DEMANDA" in caso)
+        
+        es_saludo = ("SALUDO" in saludo) and not ("NO_SALUDO" in saludo)    
+        es_consulta = ("PREGUNTA_O_SOLICITUD" in consulta) and ("NO_PREGUNTA" in consulta)
+        es_caso = ("QUEJA_DEMANDA" in caso) and ("NO_SALUDO" in saludo)
+        
+        
         logging.info("\n------------------- Clase --------------------------")
         logging.info(f"[Stage-1]: Saludo({saludo}), Consulta({consulta}), Caso({caso})")                    
         logging.info(f"[Stage-1]: Es saludo({es_saludo}), Es consulta({es_consulta}), Es caso({es_caso})")
         logging.info("\n-----------------------------------------------------")
+
+        eva = 0
+        ambiguedad = False
+        eva = 1 if es_saludo else 0
+        eva += 1 if es_consulta else 0
+        eva += 1 if es_caso else 0
+        
         # Verifica los casos
-        if es_saludo or es_consulta or es_caso:
+        if eva > 0 and eva < 3:
             logging.info("[Stage-1]: Discriminador encontrado")
-            if es_saludo:
+            
+            # Casos identificables
+            if es_saludo and not es_consulta and not es_caso:
                 dicriminador = "saluda"
-            elif es_consulta:
+            elif es_consulta and not es_saludo and not es_caso:
                 dicriminador = "consulta"
-            else:
+            elif es_caso and not es_saludo and not es_consulta:
                 dicriminador = "caso"
+
+            # Casos ambiguos con saludo
+            elif es_saludo and es_consulta and not es_caso:
+                dicriminador = "consulta"
+            elif es_saludo and es_caso and not es_consulta:
+                dicriminador = "caso"
+
+            # Casos ambiguos con consulta y caso
+            elif es_consulta and es_caso and not es_saludo:
+                res = "Lo lamento, ¿Desea que le ayude con una Consulta o una Demanda?"
+            else:
+                ambiguedad = True
+
             self.notify(session_id, f"primera fase se identifica: {dicriminador}.")
             res = query
         else:
+            ambiguedad = True
+
+        if ambiguedad:    
             logging.info("[Stage-1]: Respuesta con ambiguedad")
             self.notify(session_id, "identificando ambiguedad...")
             logging.info("\n\n\n--------------ANALIZER------------------")
@@ -909,6 +945,17 @@ class Dialog(ABC):
 
         return dicriminador, res
 
+    def get_node(self, performative):
+        """ Get node method
+        :param performative: performative
+        :return: Node
+        """
+        if performative in self.__dfa:
+            return self.__dfa[performative]
+        else:
+            logging.error(f"Performativa {performative} no encontrada en el DFA")
+            return None
+        
     def transition(self, session, owner, dialog_state, query, team_source=False) -> str:
         try:
             res = ""

{pbesa-4.0.18 → pbesa-4.0.19}/pbesa.egg-info/PKG-INFO

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

{pbesa-4.0.18 → pbesa-4.0.19}/pbesa.egg-info/SOURCES.txt

@@ -78,6 +78,8 @@ pbesa/celulas/celula_expertos.py
 pbesa/celulas/celula_generar_documento.py
 pbesa/celulas/celula_preguntas.py
 pbesa/celulas/celula_saludos.py
+pbesa/celulas/celula_simulador_ciudadano.py
+pbesa/celulas/data_extraction_cel.py
 pbesa/celulas/web.py
 pbesa/kernel/__init__.py
 pbesa/kernel/adapter.py

{pbesa-4.0.18 → pbesa-4.0.19}/setup.py

@@ -4,7 +4,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='pbesa',
-    version='4.0.18',
+    version='4.0.19',
     packages=find_packages(),
     install_requires=[
         'pymongo>=4.6.3',