pbesa 4.0.38__tar.gz → 4.0.40__tar.gz

{pbesa-4.0.38 → pbesa-4.0.40}/PKG-INFO

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

pbesa-4.0.40/pbesa/celulas/celula_demanda.py

@@ -0,0 +1,56 @@
+import logging
+
+SYSTEM_PROMPT = """
+Eres un clasificador de texto altamente especializado. Tu única función es analizar un texto y responder con una de dos posibles palabras: DEMANDA o INDEFINIDO.
+
+Al usuario se le ha hecho la siguiente pregunta: "¿Desea que le ayude con una consulta o una demanda?"
+
+**Reglas de Clasificación:**
+1.  Si el texto del usuario expresa una intención clara de iniciar una demanda, clasifícalo como **DEMANDA**.
+2.  Para cualquier otro caso (consultas, dudas, respuestas confusas, o cualquier texto que no sea una afirmación clara de querer demandar), clasifícalo como **INDEFINIDO**.
+
+**Formato de Respuesta Obligatorio:**
+-   Tu respuesta debe contener **únicamente** la palabra DEMANDA o la palabra INDEFINIDO.
+-   No agregues explicaciones, comentarios, puntuación ni ningún otro carácter. Tu respuesta debe ser una sola palabra.
+
+**Ejemplos:**
+-   Texto: "demanda"
+    Respuesta: DEMANDA
+
+-   Texto: "Quiero poner una demanda"
+    Respuesta: DEMANDA
+
+-   Texto: "Es una consulta"
+    Respuesta: INDEFINIDO
+
+-   Texto: "No estoy seguro"
+    Respuesta: INDEFINIDO
+
+"""
+
+USER_PROMPT = """
+
+Texto: "%s"
+
+Respuesta:
+
+"""
+
+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[Celula][Saludos][Proceso]: {text}")        
+        logging.info(f"[Celula][Saludos][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.38 → pbesa-4.0.40}/pbesa/cognitive.py

@@ -29,7 +29,7 @@ from pbesa.social.dialog import (
 from .celulas import (celula_casos, celula_consultas, celula_saludos, celula_datos_identificables,
                       celula_generar_documento, celula_expertos, celula_pertinencia, celula_extraccion,
                       celula_evaluador, celula_respuesta, celula_conversador, celula_parafraseo, celula_cuestionador,
-                      celula_instruccion, celula_generar_caso)
+                      celula_instruccion, celula_generar_caso, celula_demanda)
 from pbesa.social.prompts import ANALIZER_PROMPT, CLASSIFICATION_PROMPT, DERIVE_PROMPT, RECOVERY_PROMPT, ADAPT_PROMPT, SINTETIZER_PROMPT
 
 # --------------------------------------------------------
@@ -830,94 +830,88 @@ class Dialog(ABC):
             msg = DialogState.ERROR
             return "Web", DialogState.START, msg, "Web"
     
-        
-    def stage_one_classification(self, session_id, messages, attemps, query):
-        """ Stage one classification """
-        res = ""
 
-        dicriminador = None
-        logging.info(f"------------Flujo de excepcion---------------")
-        self.notify(session_id, "identificando intención...")        
-        logging.info(f"Intento: {attemps}") 
-            
-        self.__analaizer_work_memory:list = [{"role": "system", "content": ANALIZER_PROMPT}]
-        
-        #es_verificacion = False
-        #if len(messages) >= 3:
-        #    last_message = messages[-2]['text']
-        #    es_verificacion = '¿Desea que le ayude con una consulta o una demanda?' in last_message
-        
-        #if attemps == 2:
-        #    saludo = "NO_SALUDO"
-        #    consulta = celula_consultas.derive(self.__ai_service, query, max_tkns=10)
+    def stage_one_check(self, session_id, messages, attemps, query):
+        aclaracion_fired = False
+        for message in messages:
+            if not message['user'] and '¿Desea que le ayude con una consulta o una demanda?' in message['text']:
+                aclaracion_fired = True
+                break
+        return aclaracion_fired
 
-        if attemps >= 2:# or es_verificacion:
-            rectificacion_consulta = 0
+    def stage_one_analizer(self, session_id, messages, attemps, query):
+        self.__analaizer_work_memory:list = [{"role": "system", "content": ANALIZER_PROMPT}]
+        user_prompt = f"""
+        user: {query}Texto: 
+        "%s"
 
-            consulta = celula_consultas.derive(self.__ai_service, query, max_tkns=10)
-            es_consulta = ("PREGUNTA_O_SOLICITUD" in consulta) and not ("NO_PREGUNTA" in consulta)
-            if es_consulta:
-                rectificacion_consulta += 1
-            
-            saludo = "NO_SALUDO"
-            self.__sintetizer_work_memory:list = [{"role": "system", "content": SINTETIZER_PROMPT}]
-
-            cont = 0
-            for message in messages:
-                if message['user']:
-                    self.__analaizer_work_memory.append({"role": "user", "content": message['text']})
-                    
-                    if cont == 0:
-                        msg = f"""
-                        Texto: 
-                        "%s"
+        Respuesta:        
+        """
+        self.__analaizer_work_memory.append({"role": "user", "content": user_prompt})
+
+        logging.info("\n\n\n--------------ANALIZER------------------")
+        logging.info("\n%s", json.dumps(self.__analaizer_work_memory, indent=4))
+        logging.info("------------------------------------------\n\n\n")
+        res = self.__ai_service.generate(self.__analaizer_work_memory, max_tokens=50)
+        logging.info(f"[Stage-1][Thought]: {res}")
+        self.__analaizer_work_memory.append({"role": "assistant", "content": res})                
+        self.__sintetizer_work_memory.append({"role": "assistant", "content": res})
+        return res
+
+    def stage_one_sintetizer(self, session_id, messages, attemps, query, es_demanda):
+        
+        self.__sintetizer_work_memory:list = [{"role": "system", "content": SINTETIZER_PROMPT}]
 
-                        Respuesta:
-                        """ % message['text']
-                    else:
-                        msg = message['text']
+        cont = 0
+        for message in messages:
+            if message['user']:
+                self.__analaizer_work_memory.append({"role": "user", "content": message['text']})
+                
+                if cont == 0:
+                    msg = f"""
+                    Texto: 
+                    "%s"
 
-                    self.__sintetizer_work_memory.append({"role": "user", "content": msg})
+                    Respuesta:
+                    """ % message['text']
                 else:
-                    self.__analaizer_work_memory.append({"role": "assistant", "content": message['text']})
-                    self.__sintetizer_work_memory.append({"role": "assistant", "content": message['text']})
+                    msg = message['text']
 
-            logging.info("\n\n\n--------------SINTETIZER------------------")
-            logging.info("\n%s", json.dumps(self.__sintetizer_work_memory, indent=4))
-            logging.info("\n\n\n")
-            res = self.__ai_service.generate(self.__sintetizer_work_memory, max_tokens=50)
-            res = self.get_text(res)
-            logging.info(f"[Stage-1][Sintetizer][Thought]: {res}")
+                self.__sintetizer_work_memory.append({"role": "user", "content": msg})
+            else:
+                self.__analaizer_work_memory.append({"role": "assistant", "content": message['text']})
+                self.__sintetizer_work_memory.append({"role": "assistant", "content": message['text']})
 
+        logging.info("\n\n\n--------------SINTETIZER------------------")
+        logging.info("\n%s", json.dumps(self.__sintetizer_work_memory, indent=4))
+        logging.info("\n\n\n")
+        res = self.__ai_service.generate(self.__sintetizer_work_memory, max_tokens=50)
+        res = self.get_text(res)
+        logging.info(f"[Stage-1][Sintetizer][Thought]: {res}")
+
+        if es_demanda:
+            return res
+        else:
             consulta = celula_consultas.derive(self.__ai_service, res, max_tkns=10)
             es_consulta = ("PREGUNTA_O_SOLICITUD" in consulta) and not ("NO_PREGUNTA" in consulta)
             if es_consulta:
-                rectificacion_consulta += 1
-            
-            if not rectificacion_consulta == 2:
-                query = res
-                logging.info("[Stage-1][Sintetizer][Thought]: Se sustituye el query por el pensamiento.")
+                logging.info("[Stage-1][Sintetizer][Thought]: Se mantiene la consulta inicial.")        
+                return query
             else:
-                logging.info("[Stage-1][Sintetizer][Thought]: Se mantiene la consulta inicial.")
-                        
-        else:
-            saludo = celula_saludos.derive(self.__ai_service, query, max_tkns=10)
-            consulta = celula_consultas.derive(self.__ai_service, res, max_tkns=10)
-
-            user_prompt = f"""
-            user: {query}Texto: 
-            "%s"
-
-            Respuesta:        
-            """
-            self.__analaizer_work_memory.append({"role": "user", "content": user_prompt})
-            
+                logging.info("[Stage-1][Sintetizer][Thought]: Se sustituye el query por el pensamiento.")
+                return res
 
+    def stage_one_evaluate(self, session_id, messages, attemps, query, es_demanda):
         #----------------------------------
         # Verifica si es una consulta o un caso
+        if attemps == 1:
+            saludo = celula_saludos.derive(self.__ai_service, query, max_tkns=10)
+        else:
+            saludo = "NO_SALUDO"
+
+        consulta = celula_consultas.derive(self.__ai_service, query, max_tkns=10)
         caso = celula_casos.derive(self.__ai_service, query, max_tkns=10)
         
-
         # Verifica si es un saludo, consulta o caso        
         es_saludo = ("SALUDO" in saludo) and not ("NO_SALUDO" in saludo)    
         es_consulta = ("PREGUNTA_O_SOLICITUD" in consulta) and not ("NO_PREGUNTA" in consulta)
@@ -929,7 +923,9 @@ class Dialog(ABC):
         logging.info("\n-----------------------------------------------------")
 
         eva = 0
+        res = None
         ambiguedad = False
+        dicriminador = None
         eva = 1 if es_saludo else 0
         eva += 1 if es_consulta else 0
         eva += 1 if es_caso else 0
@@ -976,9 +972,15 @@ class Dialog(ABC):
 
             # Casos ambiguos con consulta y caso
             elif es_consulta and es_caso and not es_saludo:
-                res = "¿Desea que le ayude con una consulta o una demanda?"
+                if es_demanda:
+                    dicriminador = "caso"
+                    res = query
+                    ambiguedad = False
+                else:
+                    res = "¿Desea que le ayude con una consulta o una demanda?"
             else:
                 ambiguedad = True
+                query = self.stage_one_sintetizer(session_id, messages, attemps, query, es_demanda)
                 per_res = celula_pertinencia.derive(self.__ai_service, query, max_tkns=10)
                 if per_res and not per_res == "":
                     if "ABSURDO" in per_res:
@@ -991,34 +993,66 @@ class Dialog(ABC):
                 res = query
         else:
             ambiguedad = True
+            query = self.stage_one_sintetizer(session_id, messages, attemps, query, es_demanda)
             per_res = celula_pertinencia.derive(self.__ai_service, query, max_tkns=10)
             if per_res and not per_res == "":
                 if "ABSURDO" in per_res:
                     dicriminador = None
                     res = msg
                     ambiguedad = False
+        return dicriminador, ambiguedad, res
 
-        if ambiguedad:
-            logging.info("[Stage-1]: Respuesta con ambiguedad")
-            self.notify(session_id, "identificando ambiguedad...")
-            
-            aclaracion_fired = False
-            for message in messages:
+
+    def stage_one_classification(self, session_id, messages, attemps, query):
+        """ Stage one classification """
+        res = ""
+
+        dicriminador = None
+        logging.info(f"------------Flujo de excepcion---------------")
+        self.notify(session_id, "identificando intención...")        
+        logging.info(f"Intento de dialogo: {attemps}") 
+        
+        for internal_attemp in range(2):
+            logging.info(f"Intento de reflexion: {internal_attemp + 1}")
+
+            es_demanda = False
+            if len(messages) > 1:
+                message = messages[-2]
                 if not message['user'] and '¿Desea que le ayude con una consulta o una demanda?' in message['text']:
-                    aclaracion_fired = True
+                    demanda = celula_demanda.derive(self.__ai_service, query, max_tkns=10)
+                    es_demanda = ("DEMANDA" in demanda) and not ("INDEFINIDO" in demanda)
+                    if es_demanda:
+                        res = self.stage_one_sintetizer(session_id, messages, attemps, query, es_demanda)
+                        dicriminador = "caso"
+                        return dicriminador, res
+
+            dicriminador, ambiguedad, res = self.stage_one_evaluate(session_id, messages, attemps, query, es_demanda)
+
+            if dicriminador == 'consulta':
+                aclaracion_fired = self.stage_one_check(session_id, messages, attemps, query)           
+                if aclaracion_fired:
+                    new_query = self.stage_one_sintetizer(session_id, messages, attemps, query, es_demanda)
+                    if not new_query == query:
+                        query = new_query
+                        continue
+                else:
+                    res = "¿Desea que le ayude con una consulta o una demanda?"
+                    dicriminador = None
+                    break
+
+            if ambiguedad:
+                logging.info("[Stage-1]: Respuesta con ambiguedad")
+                self.notify(session_id, "identificando ambiguedad...")
+                
+                aclaracion_fired = self.stage_one_check(session_id, messages, attemps, query)           
+                if aclaracion_fired:
+                    query = self.stage_one_sintetizer(session_id, messages, attemps, query, es_demanda)
+                else:
+                    res = "¿Desea que le ayude con una consulta o una demanda?"
                     break
-            
-            if aclaracion_fired:
-                logging.info("\n\n\n--------------ANALIZER------------------")
-                logging.info("\n%s", json.dumps(self.__analaizer_work_memory, indent=4))
-                logging.info("------------------------------------------\n\n\n")
-                res = self.__ai_service.generate(self.__analaizer_work_memory, max_tokens=50)
-                logging.info(f"[Stage-1][Thought]: {res}")
-                self.__analaizer_work_memory.append({"role": "assistant", "content": res})                
-                self.__sintetizer_work_memory.append({"role": "assistant", "content": res})
             else:
-                res = "¿Desea que le ayude con una consulta o una demanda?"
-        
+                break
+            
         return dicriminador, res
 
     def get_node(self, performative):

{pbesa-4.0.38 → pbesa-4.0.40}/pbesa/social/sel_dispatcher_team.py

@@ -92,6 +92,8 @@ class BufferDispatcher(Action):
                     for item in item_list:                        
                         data = item['data']
                         mayor_ag_id = item['mayor_ag_id']
+                        session_id = item['session_id']
+
                         free_dict = self.agent.get_free_dict()
 
 
@@ -110,6 +112,8 @@ class BufferDispatcher(Action):
                                 'dtoList': []
                             }
                             self.adm.send_event(agent_id, 'task', data['dto'])
+                            # Registra la sesion
+                            self.agent.planilla[session_id] = mayor_ag_id
                             # Remove the item from the hold dict
                             self.agent.hold_dict[key].remove(item)
                             if len(self.agent.hold_dict[key]) == 0:
@@ -190,13 +194,13 @@ class SelectedDispatcher(Action):
                 mayor_ag_id = self.agent.planilla[session_id]
                 logging.info('The session is already assigned')
                 logging.info(f'The agent {mayor_ag_id} will be assigned')
-                self.agent.add_to_hold(data, mayor_ag_id)
+                self.agent.add_to_hold(data, mayor_ag_id, session_id)
             else:
                 score_mayor = 0 
                 mayor_ag = self.manual_selection(data['dto'])
                 if mayor_ag:
                     logging.info(f'The agent {mayor_ag.id} will be assigned')
-                    self.agent.add_to_hold(data, mayor_ag_id)
+                    self.agent.add_to_hold(data, mayor_ag_id, session_id)
                 else:
                     roles = []
                     # Get the agent asocciated with the data.
@@ -222,7 +226,7 @@ class SelectedDispatcher(Action):
                     # Check if the mayor agent is the same as the agent        
                     if mayor_ag:
                         logging.info(f'The agent {mayor_ag.id} will be assigned')
-                        self.agent.add_to_hold(data, mayor_ag.id)
+                        self.agent.add_to_hold(data, mayor_ag.id, session_id)
                     else:
                         logging.error('[Error, toAssign]: No agent found for the request')
                         data['gateway'].put('ERROR')
@@ -430,14 +434,15 @@ class DispatcherController(Agent):
         diferencia_tiempo = current - item["lasttime"]
         return diferencia_tiempo < self.umbral_cinco_minutos
 
-    def add_to_hold(self, data, mayor_ag_id):
+    def add_to_hold(self, data, mayor_ag_id, session_id):
         text = data['dto']['text']
         if not self.check_hold(data):
             self.hold_dict[hash(text)] = []
         self.hold_dict[hash(text)].append({
             "data": data,
             "lasttime": datetime.now(),
-            "mayor_ag_id": mayor_ag_id
+            "mayor_ag_id": mayor_ag_id,
+            "session_id": session_id
         })
         logging.info(f"[Select]:[Dispacher]: Se asigan en el hold la consulta {data['dto']['text']}")
     

{pbesa-4.0.38 → pbesa-4.0.40}/pbesa.egg-info/PKG-INFO

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

{pbesa-4.0.38 → pbesa-4.0.40}/pbesa.egg-info/SOURCES.txt

@@ -76,6 +76,7 @@ pbesa/celulas/celula_consultas.py
 pbesa/celulas/celula_conversador.py
 pbesa/celulas/celula_cuestionador.py
 pbesa/celulas/celula_datos_identificables.py
+pbesa/celulas/celula_demanda.py
 pbesa/celulas/celula_evaluador.py
 pbesa/celulas/celula_expertos.py
 pbesa/celulas/celula_extraccion.py

{pbesa-4.0.38 → pbesa-4.0.40}/setup.py

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