pbesa 4.0.2__tar.gz → 4.0.4__tar.gz

{pbesa-4.0.2 → pbesa-4.0.4}/PKG-INFO

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

{pbesa-4.0.2 → pbesa-4.0.4}/pbesa/cognitive.py

@@ -13,7 +13,8 @@
 # Define resources
 # --------------------------------------------------------
 
-import re
+import json
+import logging
 import traceback
 from pydantic import BaseModel
 from typing import List, Optional
@@ -263,7 +264,7 @@ class AugmentedGeneration(ABC):
         """ Reset method """
         self.__work_memory = []
         # Set up model
-        self.set_up_model()
+        self.setup_world()
 
     def derive(self, query) -> str:
         """ Generate method
@@ -275,7 +276,7 @@ class AugmentedGeneration(ABC):
             instantane_memory = self.__work_memory.copy()
             instantane_memory.append({"role": "user", "content": prompt})
             text = self.__ai_service.generate(instantane_memory)
-            print("Pensamiento:", text)
+            logging.info(f"Thought: {text}")
             if self.__def_tool_dict:
                 tool = self.__def_tool_dict.get(self.__role.tool)
                 if tool:
@@ -285,6 +286,10 @@ class AugmentedGeneration(ABC):
             return text
         except Exception as e:
             traceback.print_exc()
+
+            logging.info(f"------------RESET---------------")
+            self.reset()
+
             return "Lo lamento, no puedo responder en este momento"
 
     def get_role(self) -> Role:
@@ -461,13 +466,24 @@ class Dialog(ABC):
         # Define deep
         self.__deep_count = 0
         self.__deep_limit = 3
+        # Define knowledge
+        self.knowledge = None
 
     def setup_world(self):
         """ Set up model method """
         # Define role
-        self.__work_memory.append({"role": "user", "content": self.__role.objective})
-        self.__work_memory.append({"role": "user", "content": self.__role.arquetype})
-        self.__work_memory.append({"role": "user", "content": self.__role.example})
+        instrucciones = f"Instrucciones:\n{self.__role.description}\n Tu tarea: {self.__role.objective}\n"
+        requisitos = f"Requisitos:\n{self.__role.arquetype}\n"
+        ejemplo = f"Ejemplo:\n{self.__role.example}\n"
+        if self.knowledge:
+            conocimiento = f"Conocimiento:\n{self.knowledge}\n"
+        continuar = "Ahora, evalúa el siguiente caso:\n"
+        self.__work_memory.append({"role": "user", "content": instrucciones})
+        self.__work_memory.append({"role": "user", "content": requisitos})
+        self.__work_memory.append({"role": "user", "content": ejemplo})
+        if self.knowledge:
+            self.__work_memory.append({"role": "user", "content": conocimiento})
+        self.__work_memory.append({"role": "user", "content": continuar})
         
     def get_model(self) -> any:
         """ Get model method 
@@ -502,29 +518,29 @@ class Dialog(ABC):
         self.setup_world()
         interations = agent_metadata.role.interactions
         grafo = recorrer_interacciones(interations)
-        print("")
+        logging.info("")
         # Si el grafo es una lista de nodos, lo imprimimos cada uno
         if isinstance(grafo, list):
             for nodo in grafo:
                 imprimir_grafo(nodo)
         else:
             imprimir_grafo(grafo)
-        print("")
+        logging.info("")
         # Ejemplo de uso:
         self.__dfa = extraer_diccionario_nodos(grafo)
         # Mostrar el diccionario
         for clave, valor in self.__dfa.items():
-            print(f"{clave}: {valor.text}")
-        print("")
+            logging.info(f"{clave}: {valor.text}")
+        logging.info("")
         iniciadores = []
         for item in interations:
             for clave, valor in self.__dfa.items():
                 if valor.text == item['texto']:
                     iniciadores.append(valor)
-        print("Iniciadores:")
+        logging.info("Iniciadores:")
         for iniciador in iniciadores:
-            print(iniciador.text)
-        print("")
+            logging.info(iniciador.text)
+        logging.info("")
         # Set dialog state
         self.__dfa['start'] = iniciadores
 
@@ -544,7 +560,7 @@ class Dialog(ABC):
         """ Reset method """
         self.__work_memory = []
         # Set up model
-        self.set_up_model()
+        self.setup_world()
 
     def team_inquiry(self, team, data, operation, session_flag) -> str:
         canales = self.state['canales']
@@ -559,15 +575,11 @@ class Dialog(ABC):
             }
         else:
             if session_flag:
-                pass
-                #session_id = self.state['session_id']
-                #print("=> session_flag -> " + session_id)
-                #dto = {
-                #    "data": {
-                #        'text': data,
-                #        'session_id': session_id
-                #    },
-                #}
+                logging.info(f"Session flag: {session_flag}")
+                logging.info(f"------------RESET--------------- {data}")
+                self.reset()
+                return data
+                
             else:
                 dto = {
                     "data": {
@@ -577,63 +589,75 @@ class Dialog(ABC):
         response = canal.post(team.lower(), dto)
         if response['status']:
             return response['message']['response']
+        
+        logging.info(f"------------RESET---------------")
+        self.reset()
         return "Lo lamento, no puedo responder en este momento"
     
-    def get_text(self, inputs) -> str:
-        matches = re.findall(r'<\|im_start\|>(user|assistant)\n(.*?)<\|im_end\|>', inputs, re.DOTALL)
-        if matches:
-            messages = []
-            for speaker, text in matches:
-                messages.append({
-                    "Assistant": speaker.capitalize(),
-                    "User": text.strip()
-                })
-            if len(messages) > 0:
-                return messages[-1]["Assistant"]
-            else:
-                return messages[-1]["User"]
-        return inputs
+    def get_text(self, mensaje) -> str:
+        mensaje_limpio = mensaje.replace("<|im_start|>user<|im_sep|>", "").replace("<|im_start|>system<|im_sep|>", "")
+        mensaje_limpio = mensaje_limpio.replace("<|im_start|>", "").replace("<|im_sep|>", "").replace("<|im_end|>", "")
+        mensaje_limpio = mensaje_limpio.replace("[Usuario]: ", "").replace("[Sistema]: ", "")
+        return mensaje_limpio.strip()
 
     def transition(self, owner, dialog_state, query, team_source=False) -> str:
+        logging.info(f"Transition: {owner} -> {dialog_state}, Team: {team_source}, Query: {query}")
         text = ""
+
+        # Verifica que exista la performativa
+        if not dialog_state in self.__dfa:
+            logging.warning(f"------------Performativa no existe---------------")
+            self.reset()
+            return "Web", DialogState.START, "Lo lamento, no puedo responder en este momento", "Web"
+
         node = self.__dfa[dialog_state]
         if not isinstance(node, list):
             node = node.children
-        options = ""
-        cont = 1
-        for item in node:
-            options += f"{cont}) {item.text}\n"
-            cont += 1
-        prompt = CLASSIFICATION_PROMPT % (query, options)
-        print("Query:", query, "\n", "Options:", options)
-        self.__meta_work_memory.append({"role": "user", "content": prompt})
-        text = self.__ai_service.generate(self.__meta_work_memory)
-        self.__meta_work_memory = []
-        print("Pensamiento:", text)
-
-        select_node = None
-        for option in range(1, cont):
-            if str(option) in text:
-                select_node = node[option-1]
-                break
-        if not select_node:
-            print("=> No se seleccionó ninguna opción")
-            print("=> Node:", node)
-            print("=> len node:", len(node))
-            if node and len(node)> 0: 
+        
+        # Flujo de selección
+        if node and len(node)> 1:
+            logging.info(f"--> Más de una opción.")
+            options = ""
+            cont = 1
+            for item in node:
+                options += f"{cont}) {item.text}\n"
+                cont += 1
+            prompt = CLASSIFICATION_PROMPT % (query, options)
+            logging.info(f"Query: {query},\n Options:\n{options}")
+            self.__meta_work_memory.append({"role": "user", "content": prompt})
+            text = self.__ai_service.generate(self.__meta_work_memory)
+            logging.info(f"Thought: {text}")
+            self.__meta_work_memory = []
+            text = self.get_text(text)
+            select_node = None
+            for option in range(1, cont):
+                if str(option) in text:
+                    select_node = node[option-1]
+                    logging.info(f"Select node: {select_node.text}")
+                    break
+            if not select_node:
+                logging.info("=> No se seleccionó ninguna opción")
+                logging.info(f"=> Node: {node}")
+                logging.info(f"=> len node: {len(node)}")
                 select_node = node[0]
-                print(select_node.text)
-            text = "Lo lamento, no puedo responder en este momento"
-            print("???> text:", text)
+                logging.info(f"=> Selecciona el primer nodo: {select_node.text}")               
+        elif node and len(node) == 1:
+            logging.info(f"--> Una opción.")
+            select_node = node[0]
+        else:
+            logging.info(f"------------RESET---------------")
+            self.reset()
+            logging.info(f"???> text: {text} es terminal")
             text = self.get_text(text)
             return owner, DialogState.START, text, owner
-        
+
+        # Flujo normal
+        logging.info(f"Flujo normal: {select_node.text}")
         if team_source:
             self.__work_memory.append({"role": "user", "content": select_node.text})
         else:
             self.__work_memory.append({"role": "user", "content": query})
             self.__work_memory.append({"role": "user", "content": select_node.text})  
-
         new_owner, new_dialog_state, text, team = self.do_transition(owner, select_node.children[0], query)
         text = self.get_text(text)
         return new_owner, new_dialog_state, text, team
@@ -643,7 +667,7 @@ class Dialog(ABC):
         :return: str
         """          
         if isinstance(node, DeclarativeNode):
-            print("-> node:", node.text)
+            logging.info(f"D -> node: {node.text}")
             self.__work_memory.append({"role": "user", "content": node.text})
         elif isinstance(node, ActionNode):
 
@@ -651,76 +675,109 @@ class Dialog(ABC):
             # Accion
             #------------------------------
 
-            print("-> node action:", node.action)
+            logging.info(f"-> node action: {node.action}")
             if node.tool and not node.tool == "Ninguno":
-                print("-> node tool:", node.tool)
-                self.__work_memory.append({"role": "user", "content": node.text})            
+                logging.info(f"-> node tool: {node.tool}")
+                self.__work_memory.append({"role": "user", "content": node.text})
+                logging.info("-----")
+                logging.info("\n%s", json.dumps(self.__work_memory, indent=4))
+                logging.info("-----")         
                 res = self.__ai_service.generate(self.__work_memory)
-
+                logging.info(f"-> node tool: {res}")
+                res = self.get_text(res)
                 # Check if res is empty
                 if not res or res == "":
+                    logging.info("1 -> res vacio")
                     res = "Lo lamento, no puedo responder en este momento"
-                    return owner, DialogState.START, res, owner
 
-                print("-> node tool: envia", res)
+                    logging.info(f"------------RESET---------------")
+                    self.reset()
 
+                    return owner, DialogState.START, res, owner
+                logging.info(f"-> node tool: envia -> {res}")
                 text = self.team_inquiry(node.team, res, node.tool, False)   
             else:
-
                 #------------------------------
                 # Lllamada
                 #------------------------------
-
-                print("-> node team:", node.team)
+                logging.info(f"-> node team: {node.team}")
                 # Verifica si el nodo es termianl ya que significa
                 # que el dialogo cambia de agente
                 if node.is_terminal:
-                    print("-> node team -> es terminal -> " + node.text)
+                    logging.info(f"-> node team -> es terminal -> {node.text}")
                     self.__work_memory.append({"role": "user", "content": node.text})
+                    logging.info("-----")
+                    logging.info("\n%s", json.dumps(self.__work_memory, indent=4))
+                    logging.info("-----")
                     res = self.__ai_service.generate(self.__work_memory)
                     res = self.get_text(res)
                     self.__work_memory.append({"role": "system", "content": res})
-
                     # Check if res is empty
                     if not res or res == "":
+                        logging.info("2 -> res vacio")
                         res = "Lo lamento, no puedo responder en este momento"
+                        logging.info(f"------------RESET---------------")
+                        self.reset()
                         return owner, DialogState.START, res, owner
-
-                    print("-> node team -> envia:", res)
-                    #text = self.team_inquiry(node.team, res, None, True)
+                    logging.info(f"-> node team -> envia: {res}")
+                    text = self.team_inquiry(node.team, res, None, True)
                     return node.team, DialogState.START, res, node.team
                 else:
-                    print("-> node team -> continua")
+                    logging.info("-> node team -> continua")
                     self.__work_memory.append({"role": "user", "content": node.text})
-                    print("-> node team -> envia:", query)
+                    logging.info(f"-> node team -> envia: {query}")
                     text = self.team_inquiry(node.team, query, node.tool, False)
-
+                logging.info(f"-> node team -> text: {text}")
+                if text:
+                    logging.info(f"-> Adicion WM node team -> text: {text}")
+                    self.__work_memory.append({"role": "system", "content": text})
             self.__deep_count += 1
             if self.__deep_count < self.__deep_limit:
                 return self.transition(owner, node.performative, text, True)
             else:
                 self.__deep_count = 0
+                logging.info("-> node team -> deep limit")
+
+                logging.info(f"------------RESET---------------")
+                self.reset()
+
                 return "Web", DialogState.START, "Lo lamento me he perdido, ¿podrías repetir la pregunta?"
         else:
-            print("!!!!!!!!!!!!!!!!!!!!!!!> Otro tipo de nodo:", node.text)
+            logging.info(f"!!!!!!!!!!!!!!!!!!!!!!!> Otro tipo de nodo: {node.text}")
 
+        logging.info(f"=> !!!!: {query}")
+        logging.info("-----")
+        logging.info("\n%s", json.dumps(self.__work_memory, indent=4))
+        logging.info("-----")
         res = self.__ai_service.generate(self.__work_memory)
+        logging.info(f"=> res: {res}")
         res = self.get_text(res)
         self.__work_memory.append({"role": "system", "content": res})
-
         # Check if res is empty
         if not res or res == "":
+            logging.info("3 -> res vacio")
+
+            logging.info(f"------------RESET---------------")
+            self.reset()
+
             res = "Lo lamento, no puedo responder en este momento"
             return owner, DialogState.START, res, owner
 
-        print("=> Pensamiento DEEP:", res)
+        logging.info(f"=> Thought DEEP: {res}")
 
         new_dialog_state = node.performative
         if not node.is_terminal:
-            print("=> new_owner:", owner, "new_dialog_state:", new_dialog_state)
+            logging.info(f"=> new_owner: {owner} new_dialog_state: {new_dialog_state}")
             return owner, new_dialog_state, res, owner
         
-        print(f"Tipe node: {type(node)}")
+        logging.info(f"Tipe node: {type(node)}")
 
-        print("$$$> new_owner:", owner, "new_dialog_state:", new_dialog_state)
+        logging.info(f"$$$> new_owner: {owner} new_dialog_state: {new_dialog_state}")
         return owner, new_dialog_state, res, owner
+
+    def set_knowledge(self, knowledge) -> str:
+        """ Set knowledge method
+        :param query: query
+        :return: str
+        """
+        self.knowledge = knowledge

{pbesa-4.0.2 → pbesa-4.0.4}/pbesa/social/collaborative_team.py

@@ -33,6 +33,7 @@ clear and unified results.
 # Define resources
 # --------------------------------------------------------
 
+import logging
 from threading import Timer
 from abc import abstractmethod
 from ..kernel.agent import Agent
@@ -94,7 +95,7 @@ class DelegateAction(Action):
         self.agent.reset()
         self.delegate(data['dto'])
         
-    def activeTimeout(self, time:int) -> None:
+    def active_timeout(self, time:int) -> None:
         """ Active timeout
         @param time: Time
         """
@@ -109,6 +110,27 @@ class DelegateAction(Action):
             self.adm.send_event(ag, 'task', data)
         else:
             raise CollaborativeException('[Warn, toAssign]: The number of data packets exceeds the number of agents')
+        
+    def get_list_agents(self) -> list:
+        """ Get list of agents
+        @return: List of agents
+        """
+        return self.agent.get_free_list()
+    
+    def to_individual_assign(self, ag_id, data:any) -> bool:
+        """ Assign data to an agent
+        @param data: Data
+        """
+        if len(self.agent.get_free_list()) > 0:
+            index = self.agent.get_free_list().index(ag_id)
+            if index >= 0:
+                self.agent.get_free_list().pop(index)
+                self.adm.send_event(ag_id, 'task', data)
+            else:
+                return False
+        else:
+            raise CollaborativeException('[Warn, toAssign]: The number of data packets exceeds the number of agents')
+        return True
 
     @abstractmethod
     def delegate(self, data:any) -> None:
@@ -129,17 +151,24 @@ class ResponseAction(Action):
         @param data: Event data
         """
         if 'timeout' == data:
+            logging.info('Stopping timeout')
             results = {}
             for key, res in self.agent.get_check_dict().items():
                 results[key] = res
             self.end_of_process(results, True)
         else:
+            logging.info("Response received")
+            logging.info(data)
             result = 'None'
             agentID = data['source']
-            if data['result']:
+            if 'result' in data and data['result']:
                 result =  data['result']
-            self.agent.get_check_dict()[agentID] = result
+                self.agent.get_check_dict()[agentID] = result
+            else:
+                logging.warning(f"No result received for agent {agentID}")
+                self.agent.get_check_dict()[agentID] = "None"
             if self.check():
+                logging.info("All agents have responded")
                 results = {}
                 for key, res in self.agent.get_check_dict().items():
                     results[key] = res

{pbesa-4.0.2 → pbesa-4.0.4}/pbesa/social/dispatcher_team.py

@@ -33,8 +33,8 @@ operate in an agile and effective manner.
 # Define resources
 # --------------------------------------------------------
 
+import logging
 from abc import abstractmethod
-
 from .worker import Task, Worker
 from ..kernel.agent import Queue
 from ..kernel.agent import Agent
@@ -56,54 +56,28 @@ class DispatcherException(Exception):
 class Delegate(Action):
     """ An action is a response to the occurrence of an event """
 
-    def execute(self, data: any) -> None:
-        """ 
-        Response.
-        @param data Event data 
+    def active_timeout(self, ag, time: int) -> None:
+        """ Active timeout
+        @param time: Time
         """
-        ag = self.agent.get_free_queue().get()
-        self.agent.get_request_dict()[ag] = {
-            'gateway': data['gateway'],
-            'dtoList': []
-        }
-        self.adm.send_event(ag, 'task', data['dto'])
-
-# --------------------------------------------------------
-# Define DelegateAction
-# --------------------------------------------------------
-
-class DelegateAction(Action):
-    """ An action is a response to the occurrence of an event """
+        logging.info(f"[Delegate] Send event timeout {time}")
+        self.adm.send_event(ag, 'timeout', {'time': time, 'command': 'start'})
 
     def execute(self, data: any) -> None:
         """ 
         Response.
         @param data Event data 
         """
-        self.delegate(data)
-    
-    def active_timeout(self, time: int) -> None:
-        """ Active timeout
-        @param time: Time
-        """
-        self.adm.send_event(self.agent.id, 'timeout', {'time': time, 'dto': None})
-
-    def to_assign(self, data: any) -> None:
-        """ Assign
-        @param data: Data
-        """
         ag = self.agent.get_free_queue().get()
         self.agent.get_request_dict()[ag] = {
+            'gateway': data['gateway'],
             'dtoList': []
         }
-        self.adm.send_event(ag, 'task', data)
-
-    @abstractmethod
-    def delegate(self, data: any) -> None:
-        """ Delegate
-        @param data: Data
-        """
-        pass
+        self.adm.send_event(ag, 'task', data['dto'])
+        if 'timeout' in self.agent.state:
+            self.active_timeout(ag, self.agent.state['timeout'])
+        else:
+            raise DispatcherException('[Delegate]: Timeout not defined in the state as "timeout" key')
 
 # --------------------------------------------------------
 # Define Action
@@ -141,11 +115,13 @@ class ResponseAction(Action):
         """
         request = self.agent.get_request_dict()[data['source']]
         if 'timeout' in data:
-            self.send_response(request)
+            logging.info(f"[ResponseAction][{self.agent.id}]: Timeout ******************")
+            request['gateway'].put("TIMEOUT")
         else:
             request['dtoList'].append(data['result'])
             if len(request['dtoList']) >= self.agent.get_buffer_size():
                 self.send_response(request)
+                self.adm.send_event(data['source'], 'timeout', {'command': 'stop'})
 
 # --------------------------------------------------------
 # Define component

{pbesa-4.0.2 → pbesa-4.0.4}/pbesa/social/selected_dispatcher_team.py

@@ -34,16 +34,14 @@ operate in an agile and effective manner.
 # Define resources
 # --------------------------------------------------------
 
+import logging
 from abc import abstractmethod
-
-from pbesa.cognitive import AugmentedGeneration, Dialog
-from pbesa.mas import Directory
-
 from .worker import Task, Worker
 from ..kernel.agent import Queue
 from ..kernel.agent import Agent
 from ..kernel.agent import Action
 from ..kernel.util import generate_short_uuid
+from pbesa.cognitive import AugmentedGeneration, Dialog
 
 # ----------------------------------------------------------
 # Defines system component exceptions
@@ -82,19 +80,22 @@ class DelegateAction(Action):
         """ Assign
         @param data: Data
         """
-        print('Assign to agent')
+        logging.info('Assign to agent...')
         ag = self.agent.get_free_queue().get()
         agent_obj = self.adm.get_agent(ag)
-        agent_count = len(self.agent.get_agent_list()) 
+        agent_count = len(self.agent.get_agent_list())
+        logging.info('List of agents: ' + str(self.agent.get_agent_list()))
         if operation:
-            print(f'With operation {operation}')
+            logging.info(f'With operation {operation}')
             exit = False
             while not exit:
                 # Chec if the agent is instance of AugmentedGeneration
                 if isinstance(agent_obj, AugmentedGeneration) or isinstance(agent_obj, Dialog):
                     # Get the role
                     role = agent_obj.get_role()
+                    logging.info(f"Comparing {role.tool} with {operation}")
                     if role.tool == operation:
+                        logging.info('The agent is operational')
                         self.agent.get_request_dict()[ag] = {
                             'gateway': data['gateway'],
                             'dtoList': []
@@ -103,25 +104,27 @@ class DelegateAction(Action):
                         self.__rewier[ag] = 0
                         exit = True
                     else:
-                        print('The agent is not available')
+                        logging.info('The agent is not available')
                         self.adm.send_event(agent_obj.get_controller(), 'notify', ag)
                         if ag in self.__rewier:
                             self.__rewier[ag] = self.__rewier[ag] + 1
                         else:
                             self.__rewier[ag] = 0
                         if self.__rewier[ag] >= agent_count * 3:
+                            data['gateway'].put('ERROR')
                             raise SelectedDispatcherException('[Error, toAssign]: The agent is not available')
                 else:
-                    print('The agent is operational')
+                    logging.info('The agent is operational')
                     self.adm.send_event(agent_obj.get_controller(), 'notify', ag)
                     if ag in self.__rewier:
                         self.__rewier[ag] = self.__rewier[ag] + 1
                     else:
                         self.__rewier[ag] = 0
                     if self.__rewier[ag] >= agent_count * 3:
+                        data['gateway'].put('ERROR')
                         raise SelectedDispatcherException('[Error, toAssign]: The agent is not available')
         else:
-            print('Without operation')
+            logging.info('Without operation')
             self.agent.get_request_dict()[ag] = {
                 'gateway': data['gateway'],
                 'dtoList': []

{pbesa-4.0.2 → pbesa-4.0.4}/pbesa/social/worker.py

@@ -13,6 +13,7 @@
 # Define resources
 # --------------------------------------------------------
 
+import logging
 from threading import Timer
 from abc import abstractmethod
 from ..kernel.agent import Agent
@@ -35,24 +36,39 @@ class WorkerException(Exception):
 # ----------------------------------------------------------
 
 class TimeoutAction(Action):
-    """
-    @See Action
-    """
+    """ Represents the action that manages the timeout """
+
+    def __init__(self) -> None:
+        """ Constructor """
+        self.__timer = None
+        super().__init__()
 
     def handler(self) -> None:
         """ Timeout handler """
         if self.agent.is_timeout():
             self.agent.set_timeout(False)
-            self.adm.send_event(self.agent.id, 'response', 'timeout')
+            response = {
+                'timeout': True,
+                'source': self.agent.id
+            }
+            self.adm.send_event(self.agent.get_controller(), 'response', response)
 
     def execute(self, data:any) -> None:
-        """ Execute
-        @param data: Data
+        """ Execute the action
+        @param data: Event data
         """
-        if not self.agent.is_timeout():
-            self.agent.set_timeout(True)
-            r = Timer(data['time'], self.handler)
-            r.start()
+        logging.info(f"[TimeoutAction][{self.agent.id}]: Execute {data}")
+        if data['command'] == 'start':
+            if not self.agent.is_timeout():
+                self.agent.set_timeout(True)
+                self.__timer = Timer(data['time'], self.handler)
+                self.__timer.start()
+                logging.info(f"[TimeoutAction][{self.agent.id}]: Timer started")
+        else:
+            if self.__timer:
+                self.__timer.cancel()
+                self.__timer = None
+                logging.info(f"[TimeoutAction][{self.agent.id}]: Timer stopped")
 
 # --------------------------------------------------------
 # Define Task Action
@@ -126,6 +142,7 @@ class Worker(Agent):
         @param agent_id: Agent ID
         """
         self.__task_list = []
+        self.__timeout = False
         self.__controller = None
         self.__controller_type = None    
         super().__init__(agent_id)
@@ -158,6 +175,18 @@ class Worker(Agent):
             action.set_is_pool(False)
             action.set_enable_response(True)
 
+    def is_timeout(self) -> bool:
+        """ Check if the controller has a timeout
+        @return: True if the controller has a timeout, False otherwise
+        """
+        return self.__timeout
+
+    def set_timeout(self, timeout:bool) -> None:
+        """ Set timeout
+        @param timeout: Timeout
+        """
+        self.__timeout = timeout
+
     @abstractmethod
     def build(self) -> None:
         """ Build """

{pbesa-4.0.2 → pbesa-4.0.4}/pbesa.egg-info/PKG-INFO

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

{pbesa-4.0.2 → pbesa-4.0.4}/setup.py

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