chatgraph 0.4.2__py3-none-any.whl → 0.5.1__py3-none-any.whl

chatgraph/__init__.py

@@ -2,10 +2,11 @@ from .auth.credentials import Credential
 from .bot.chatbot_model import ChatbotApp
 from .bot.chatbot_router import ChatbotRouter
 from .messages.message_consumer import MessageConsumer
-from .types.request_types import UserCall, UserState
+from .types.request_types import UserCall, UserState, ChatID
 from .types.end_types import RedirectResponse, EndChatResponse, TransferToHuman
-from .types.message_types import Message, Button, ListElements
+from .types.message_types import Message, Button
 from .types.route import Route
+from .types.background_task import BackgroundTask
 
 __all__ = [
     'ChatbotApp',
@@ -18,8 +19,9 @@ __all__ = [
     'Route',
     'EndChatResponse',
     'TransferToHuman',
+    'ChatID',
     'UserState',
     'Message',
     'Button',
-    'ListElements'
+    'BackgroundTask',
 ]

chatgraph/bot/chatbot_model.py

@@ -1,13 +1,12 @@
 import inspect
 from functools import wraps
-from logging import debug
-import json
-from logging import error
+from logging import debug, error
+import asyncio
 
-from ..error.chatbot_error import ChatbotError, ChatbotMessageError
+from ..error.chatbot_error import ChatbotMessageError
 from ..messages.message_consumer import MessageConsumer
 from ..types.request_types import UserCall
-from ..types.message_types import messageTypes, Message, Button, ListElements
+from ..types.message_types import Message, Button
 from ..types.end_types import RedirectResponse, EndChatResponse, TransferToHuman
 from ..types.route import Route
 from .chatbot_router import ChatbotRouter
@@ -27,20 +26,16 @@ class ChatbotApp:
         """
         if not message_consumer:
             message_consumer = MessageConsumer.load_dotenv()
-            
+
         self.__message_consumer = message_consumer
         self.__routes = {}
-    
+
     def include_router(self, router: ChatbotRouter):
         """
         Inclui um roteador de chatbot com um prefixo nas rotas da aplicação.
 
         Args:
             router (ChatbotRouter): O roteador contendo as rotas a serem adicionadas.
-            prefix (str): O prefixo a ser adicionado às rotas do roteador.
-
-        Raises:
-            ChatbotError: Se a rota 'start' não for encontrada no roteador.
         """
         self.__routes.update(router.routes)
 
@@ -57,7 +52,7 @@ class ChatbotApp:
         route_name = route_name.strip().lower()
 
         def decorator(func):
-            params = dict()
+            params = {}
             signature = inspect.signature(func)
             output_param = signature.return_annotation
 
@@ -65,20 +60,20 @@ class ChatbotApp:
                 param_type = (
                     param.annotation
                     if param.annotation != inspect.Parameter.empty
-                    else 'Any'
+                    else "Any"
                 )
                 params[param_type] = name
-                debug(f'Parameter: {name}, Type: {param_type}')
+                debug(f"Parameter: {name}, Type: {param_type}")
 
             self.__routes[route_name] = {
-                'function': func,
-                'params': params,
-                'return': output_param,
+                "function": func,
+                "params": params,
+                "return": output_param,
             }
 
             @wraps(func)
-            def wrapper(*args, **kwargs):
-                return func(*args, **kwargs)
+            async def wrapper(*args, **kwargs):
+                return await func(*args, **kwargs)
 
             return wrapper
 
@@ -89,103 +84,102 @@ class ChatbotApp:
         Inicia o consumo de mensagens pelo chatbot, processando cada mensagem recebida.
         """
         self.__message_consumer.reprer()
-        self.__message_consumer.start_consume(self.process_message)
-    
-    def process_message(self, userCall: UserCall):
+        asyncio.run(self.__message_consumer.start_consume(self.process_message))
+
+    async def process_message(self, userCall: UserCall):
         """
         Processa uma mensagem recebida, identificando a rota correspondente e executando a função associada.
 
         Args:
-            userCall (Message): A mensagem a ser processada.
+            userCall (UserCall): A mensagem a ser processada.
 
         Raises:
             ChatbotMessageError: Se nenhuma rota for encontrada para o menu atual do usuário.
-            ChatbotError: Se o tipo de retorno da função associada à rota for inválido.
-
-        Returns:
-            str: A resposta gerada pela função da rota, que pode ser uma mensagem ou o resultado de uma redireção.
         """
-        customer_id = userCall.customer_id
+        user_id = userCall.user_id
         route = userCall.route.lower()
-        route_handler = route.split('.')[-1]
-        menu = userCall.menu.lower()
-        obs = userCall.obs
+        route_handler = route.split(".")[-1]
+
         handler = self.__routes.get(route_handler, None)
 
         if not handler:
-            raise ChatbotMessageError(
-                customer_id, f'Rota não encontrada para {route}!'
-            )
-            
-        func = handler['function']
-        userCall_name = handler['params'].get(UserCall, None)
-        route_state_name = handler['params'].get(Route, None)
+            raise ChatbotMessageError(user_id, f"Rota não encontrada para {route}!")
+
+        func = handler["function"]
+        userCall_name = handler["params"].get(UserCall, None)
+        route_state_name = handler["params"].get(Route, None)
 
-        kwargs = dict()
+        kwargs = {}
         if userCall_name:
             kwargs[userCall_name] = userCall
         if route_state_name:
             kwargs[route_state_name] = Route(route, list(self.__routes.keys()))
 
-        userCall_response = func(**kwargs)
-        
+        if asyncio.iscoroutinefunction(func):
+            userCall_response = await func(**kwargs)
+        else:
+            loop = asyncio.get_running_loop()
+            userCall_response = await loop.run_in_executor(None, lambda: func(**kwargs))
+
         if isinstance(userCall_response, (list, tuple)):
             for response in userCall_response:
-                self.__process_func_response(response, userCall, route=route)
+                await self.__process_func_response(response, userCall, route=route)
         else:
-            self.__process_func_response(userCall_response, userCall, route=route)
+            await self.__process_func_response(userCall_response, userCall, route=route)
+
+    async def __process_func_response(
+        self, userCall_response, userCall: UserCall, route: str
+    ):
+        """
+        Processa a resposta de uma função associada a uma rota, enviando mensagens ou ajustando estados.
+
+        Args:
+            userCall_response: A resposta gerada pela função da rota.
+            userCall (UserCall): O objeto UserCall associado à mensagem processada.
+            route (str): O nome da rota atual.
+        """
+        loop = asyncio.get_running_loop()
 
-    def __process_func_response(self, userCall_response, userCall: UserCall, route: str):
-        
         if isinstance(userCall_response, (str, float, int)):
-            userCall.send(Message(text=userCall_response))
+            # Envia o resultado como mensagem (executando a chamada síncrona no executor)
+            await loop.run_in_executor(None, userCall.send, Message(userCall_response))
             return
 
         elif isinstance(userCall_response, Route):
             userCall.route = userCall_response.current
             return
-            
-        elif isinstance(userCall_response, (Message, Button, ListElements)):
-            userCall.send(userCall_response)
-            
+
+        elif isinstance(userCall_response, (Message, Button)):
+            # Envia o objeto Message ou Button
+            await loop.run_in_executor(None, userCall.send, userCall_response)
             return
 
         elif isinstance(userCall_response, EndChatResponse):
-            userCall.end_chat(userCall_response.observations, userCall_response.tabulation_id)
+            await loop.run_in_executor(
+                None,
+                userCall.end_chat,
+                userCall_response.observations,
+                userCall_response.tabulation_id,
+            )
             return
-        
+
         elif isinstance(userCall_response, TransferToHuman):
-            userCall.transfer_to_human(userCall_response.observations, userCall_response.campaign_id)
+            await loop.run_in_executor(
+                None,
+                userCall.transfer_to_human,
+                userCall_response.observations,
+                userCall_response.campaign_id,
+            )
             return
 
         elif isinstance(userCall_response, RedirectResponse):
-            route = route + '.' + userCall_response.route
+            route = route + "." + userCall_response.route
             userCall.route = route
-            return self.process_message(userCall)
+            await self.process_message(userCall)
 
         elif not userCall_response:
             return
 
         else:
-            error('Tipo de retorno inválido!')
+            error("Tipo de retorno inválido!")
             return None
-        
-
-    def __adjust_route(self, route: str, absolute_route: str) -> str:
-        """
-        Ajusta a rota fornecida para incluir o prefixo necessário, se não estiver presente.
-
-        Args:
-            route (str): A rota que precisa ser ajustada.
-            absolute_route (str): A rota completa atual, usada como referência.
-
-        Returns:
-            str: A rota ajustada.
-        """
-        if not route:
-            return absolute_route
-
-        if 'start' not in route:
-            route = absolute_route + route
-
-        return route

chatgraph/gRPC/gRPCCall.py

@@ -1,210 +1,137 @@
 import os
 import grpc
-import chatgraph.pb.userstate_pb2 as userstate_pb2
-import chatgraph.pb.userstate_pb2_grpc as userstate_pb2_grpc
+import json
 
-import chatgraph.pb.voll_pb2 as whatsapp_pb2
-import chatgraph.pb.voll_pb2_grpc as whatsapp_pb2_grpc
+import chatgraph.pb.router_pb2 as chatbot_pb2
+import chatgraph.pb.router_pb2_grpc as chatbot_pb2_grpc
 
-class WhatsappServiceClient:
+
+class RouterServiceClient:
     def __init__(self, grpc_uri=None):
-        
-        self.grpc_uri = grpc_uri
-        
-        if not grpc_uri:
-            self.grpc_uri = os.getenv('GRPC_URI')
-        
+        self.grpc_uri = grpc_uri or os.getenv("GRPC_URI")
+
         if not self.grpc_uri:
             raise ValueError("A variável de ambiente 'GRPC_URI' não está definida.")
-        
+
         # Cria o canal gRPC
         self.channel = grpc.insecure_channel(self.grpc_uri)
-        
-        # Cria o stub (client) para o serviço gRPC
-        self.stub = whatsapp_pb2_grpc.MessageServiceStub(self.channel)
-        self.actions_stub = whatsapp_pb2_grpc.ActionsServiceStub(self.channel)
-
-    def send_button(self, message_data):
-        # Cria o request para o método SendButton
-        request = whatsapp_pb2.MessageRequest(**message_data)
-
-        # Faz a chamada ao serviço gRPC
-        try:
-            response = self.stub.SendButton(request)
-            return response
-        except grpc.RpcError as e:
-            print(f"Erro ao fazer a requisição gRPC SendButton: {e}")
-            return None
 
-    def send_list(self, message_data):
-        # Cria o request para o método SendList
-        request = whatsapp_pb2.MessageRequest(**message_data)
+        # Cria os stubs para os serviços gRPC
+        self.user_state_stub = chatbot_pb2_grpc.UserStateServiceStub(self.channel)
+        self.send_message_stub = chatbot_pb2_grpc.SendMessageStub(self.channel)
+        self.transfer_stub = chatbot_pb2_grpc.TransferStub(self.channel)
+        self.end_chat_stub = chatbot_pb2_grpc.EndChatStub(self.channel)
 
-        # Faz a chamada ao serviço gRPC
+    def insert_update_user_state(self, user_state_data):
+        request = chatbot_pb2.UserState(**user_state_data)
         try:
-            response = self.stub.SendList(request)
+            response = self.user_state_stub.InsertUpdateUserState(request)
+            if not response.status:
+                print(f"Erro ao chamar SendMessage: {response.message}")
             return response
         except grpc.RpcError as e:
-            print(f"Erro ao fazer a requisição gRPC SendList: {e}")
+            print(f"Erro ao chamar InsertUpdateUserState: {e}")
             return None
 
-    def send_text(self, message_data):
-        # Cria o request para o método SendText
-        request = whatsapp_pb2.MessageRequest(**message_data)
-
-        # Faz a chamada ao serviço gRPC
+    def delete_user_state(self, chat_id_data):
+        request = chatbot_pb2.ChatID(**chat_id_data)
         try:
-            response = self.stub.SendText(request)
+            response = self.user_state_stub.DeleteUserState(request)
+            if not response.status:
+                print(f"Erro ao chamar SendMessage: {response.message}")
             return response
         except grpc.RpcError as e:
-            print(f"Erro ao fazer a requisição gRPC SendText: {e}")
+            print(f"Erro ao chamar DeleteUserState: {e}")
             return None
-    
-    def transfer_to_human(self, message_data):
-        # Cria o request para o método TransferToHuman
-        request = whatsapp_pb2.MessageRequest(**message_data)
 
-        # Faz a chamada ao serviço gRPC
+    def get_user_state(self, chat_id_data):
+        request = chatbot_pb2.ChatID(**chat_id_data)
         try:
-            response = self.stub.TransferToHuman(request)
+            response = self.user_state_stub.GetUserState(request)
             return response
         except grpc.RpcError as e:
-            print(f"Erro ao fazer a requisição gRPC TransferToHuman: {e}")
+            print(f"Erro ao chamar GetUserState: {e}")
             return None
-    
-    def end_chat(self, message_data):
-        # Cria o request para o método EndChat
-        request = whatsapp_pb2.MessageRequest(**message_data)
 
-        # Faz a chamada ao serviço gRPC
-        try:
-            response = self.stub.EndChat(request)
-            return response
-        except grpc.RpcError as e:
-            print(f"Erro ao fazer a requisição gRPC EndChat: {e}")
-            return None
-    
-    def get_campaign_id(self, campaign_name):
-        # Cria o request para o método GetCampaignID
-        request = whatsapp_pb2.CampaignName(campaign_name=campaign_name)
-
-        # Faz a chamada ao serviço gRPC
-        try:
-            response = self.actions_stub.GetCampaignID(request)
-            return response
-        except grpc.RpcError as e:
-            print(f"Erro ao fazer a requisição gRPC GetCampaignID: {e}")
-            return None
+    def send_message(self, message_data):
+        # print(json.dumps(message_data))
+        
+        request = chatbot_pb2.Message(**message_data)
         
-    def get_tabulation_id(self, tabulation_name):
-        # Cria o request para o método GetTabulationID
-        request = whatsapp_pb2.TabulationName(tabulation_name=tabulation_name)
-
-        # Faz a chamada ao serviço gRPC
         try:
-            response = self.actions_stub.GetTabulationID(request)
+            response = self.send_message_stub.SendMessage(request)
+            if not response.status:
+                print(f"Erro ao chamar SendMessage: {response.message}")
             return response
         except grpc.RpcError as e:
-            print(f"Erro ao fazer a requisição gRPC GetTabulationID: {e}")
+            print(f"Erro ao chamar SendMessage: {e}")
             return None
 
-    def get_all_campaigns(self):
-        # Cria o request para o método GetAllCampaigns
-        request = whatsapp_pb2.Void()
-
-        # Faz a chamada ao serviço gRPC
+    def transfer_to_human(self, transfer_request_data):
+        request = chatbot_pb2.TransferToHumanRequest(**transfer_request_data)
         try:
-            response = self.actions_stub.GetCampaignsList(request)
+            response = self.transfer_stub.TransferToHuman(request)
+            if not response.status:
+                print(f"Erro ao chamar SendMessage: {response.message}")
             return response
         except grpc.RpcError as e:
-            print(f"Erro ao fazer a requisição gRPC GetAllCampaigns: {e}")
+            print(f"Erro ao chamar TransferToHuman: {e}")
             return None
-    
-    def get_all_tabulations(self):
-        # Cria o request para o método GetAllTabulations
-        request = whatsapp_pb2.Void()
 
-        # Faz a chamada ao serviço gRPC
+    def transfer_to_menu(self, transfer_request_data):
+        request = chatbot_pb2.TransferToMenuRequest(**transfer_request_data)
         try:
-            response = self.actions_stub.GetTabulationsList(request)
+            response = self.transfer_stub.TransferToMenu(request)
+            if not response.status:
+                print(f"Erro ao chamar SendMessage: {response.message}")
             return response
         except grpc.RpcError as e:
-            print(f"Erro ao fazer a requisição gRPC GetAllTabulations: {e}")
+            print(f"Erro ao chamar TransferToMenu: {e}")
             return None
 
-class UserStateServiceClient:
-    def __init__(self, grpc_uri=None):
-        
-        self.grpc_uri = grpc_uri
-        
-        if not grpc_uri:
-            self.grpc_uri = os.getenv('GRPC_URI')
-        
-        if not self.grpc_uri:
-            raise ValueError("A variável de ambiente 'GRPC_URI' não está definida.")
-        
-        # Cria o canal gRPC
-        self.channel = grpc.insecure_channel(self.grpc_uri)
-        
-        # Cria o stub (client) para o serviço gRPC
-        self.stub = userstate_pb2_grpc.UserStateServiceStub(self.channel)
-
-    def select_user_state(self, user_id):
-        # Cria o request para o método SelectUserState
-        request = userstate_pb2.UserStateId(user_id=user_id)
-
-        # Faz a chamada ao serviço gRPC
+    def end_chat(self, end_chat_request_data):
+        request = chatbot_pb2.EndChatRequest(**end_chat_request_data)
         try:
-            response = self.stub.SelectUserState(request)
+            response = self.end_chat_stub.EndChat(request)
+            if not response.status:
+                print(f"Erro ao chamar SendMessage: {response.message}")
             return response
         except grpc.RpcError as e:
-            print(f"Erro ao fazer a requisição gRPC SelectUserState: {e}")
+            print(f"Erro ao chamar EndChat: {e}")
             return None
 
-    def insert_user_state(self, user_state_data):
-        # Cria o request para o método InsertUserState
-        request = userstate_pb2.UserState(**user_state_data)
-
-        # Faz a chamada ao serviço gRPC
+    def get_campaign_id(self, campaign_name):
+        request = chatbot_pb2.CampaignName(**campaign_name)
         try:
-            response = self.stub.InsertUserState(request)
+            response = self.transfer_stub.GetCampaignID(request)
             return response
         except grpc.RpcError as e:
-            print(f"Erro ao fazer a requisição gRPC InsertUserState: {e}")
+            print(f"Erro ao chamar GetCampaignID: {e}")
             return None
 
-    def update_user_state(self, user_state_data):
-        # Cria o request para o método UpdateUserState
-        request = userstate_pb2.UserState(**user_state_data)
-
-        # Faz a chamada ao serviço gRPC
+    def get_all_campaigns(self):
+        request = chatbot_pb2.Void()
         try:
-            response = self.stub.UpdateUserState(request)
+            response = self.transfer_stub.GetAllCampaigns(request)
             return response
         except grpc.RpcError as e:
-            print(f"Erro ao fazer a requisição gRPC UpdateUserState: {e}")
+            print(f"Erro ao chamar GetAllCampaigns: {e}")
             return None
 
-    def delete_user_state(self, user_id):
-        # Cria o request para o método DeleteUserState
-        request = userstate_pb2.UserStateId(user_id=user_id)
-
-        # Faz a chamada ao serviço gRPC
+    def get_tabulation_id(self, tabulation_name):
+        request = chatbot_pb2.TabulationName(**tabulation_name)
         try:
-            response = self.stub.DeleteUserState(request)
+            response = self.end_chat_stub.GetTabulationID(request)
             return response
         except grpc.RpcError as e:
-            print(f"Erro ao fazer a requisição gRPC DeleteUserState: {e}")
+            print(f"Erro ao chamar GetTabulationID: {e}")
             return None
-    
-    def get_all_user_states(self):
-        # Cria o request para o método GetAllUserStates
-        request = userstate_pb2.Void()
 
-        # Faz a chamada ao serviço gRPC
+    def get_all_tabulations(self):
+        request = chatbot_pb2.Void()
         try:
-            response = self.stub.GetAllUserStates(request)
+            response = self.end_chat_stub.GetAllTabulations(request)
             return response
         except grpc.RpcError as e:
-            print(f"Erro ao fazer a requisição gRPC GetAllUserStates: {e}")
-            return None
+            print(f"Erro ao chamar GetAllTabulations: {e}")
+            return None