chatgraph 0.4.2__tar.gz → 0.5.1__tar.gz

{chatgraph-0.4.2 → chatgraph-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: chatgraph
-Version: 0.4.2
+Version: 0.5.1
 Summary: A user-friendly chatbot library
 Home-page: https://github.com/irissonnlima/chatgraph
 License: MIT

{chatgraph-0.4.2 → chatgraph-0.5.1}/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-0.4.2 → chatgraph-0.5.1}/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-0.5.1/chatgraph/gRPC/gRPCCall.py

@@ -0,0 +1,137 @@
+import os
+import grpc
+import json
+
+import chatgraph.pb.router_pb2 as chatbot_pb2
+import chatgraph.pb.router_pb2_grpc as chatbot_pb2_grpc
+
+
+class RouterServiceClient:
+    def __init__(self, grpc_uri=None):
+        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 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)
+
+    def insert_update_user_state(self, user_state_data):
+        request = chatbot_pb2.UserState(**user_state_data)
+        try:
+            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 chamar InsertUpdateUserState: {e}")
+            return None
+
+    def delete_user_state(self, chat_id_data):
+        request = chatbot_pb2.ChatID(**chat_id_data)
+        try:
+            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 chamar DeleteUserState: {e}")
+            return None
+
+    def get_user_state(self, chat_id_data):
+        request = chatbot_pb2.ChatID(**chat_id_data)
+        try:
+            response = self.user_state_stub.GetUserState(request)
+            return response
+        except grpc.RpcError as e:
+            print(f"Erro ao chamar GetUserState: {e}")
+            return None
+
+    def send_message(self, message_data):
+        # print(json.dumps(message_data))
+        
+        request = chatbot_pb2.Message(**message_data)
+        
+        try:
+            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 chamar SendMessage: {e}")
+            return None
+
+    def transfer_to_human(self, transfer_request_data):
+        request = chatbot_pb2.TransferToHumanRequest(**transfer_request_data)
+        try:
+            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 chamar TransferToHuman: {e}")
+            return None
+
+    def transfer_to_menu(self, transfer_request_data):
+        request = chatbot_pb2.TransferToMenuRequest(**transfer_request_data)
+        try:
+            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 chamar TransferToMenu: {e}")
+            return None
+
+    def end_chat(self, end_chat_request_data):
+        request = chatbot_pb2.EndChatRequest(**end_chat_request_data)
+        try:
+            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 chamar EndChat: {e}")
+            return None
+
+    def get_campaign_id(self, campaign_name):
+        request = chatbot_pb2.CampaignName(**campaign_name)
+        try:
+            response = self.transfer_stub.GetCampaignID(request)
+            return response
+        except grpc.RpcError as e:
+            print(f"Erro ao chamar GetCampaignID: {e}")
+            return None
+
+    def get_all_campaigns(self):
+        request = chatbot_pb2.Void()
+        try:
+            response = self.transfer_stub.GetAllCampaigns(request)
+            return response
+        except grpc.RpcError as e:
+            print(f"Erro ao chamar GetAllCampaigns: {e}")
+            return None
+
+    def get_tabulation_id(self, tabulation_name):
+        request = chatbot_pb2.TabulationName(**tabulation_name)
+        try:
+            response = self.end_chat_stub.GetTabulationID(request)
+            return response
+        except grpc.RpcError as e:
+            print(f"Erro ao chamar GetTabulationID: {e}")
+            return None
+
+    def get_all_tabulations(self):
+        request = chatbot_pb2.Void()
+        try:
+            response = self.end_chat_stub.GetAllTabulations(request)
+            return response
+        except grpc.RpcError as e:
+            print(f"Erro ao chamar GetAllTabulations: {e}")
+            return None

chatgraph-0.5.1/chatgraph/messages/message_consumer.py

@@ -0,0 +1,150 @@
+import json
+import asyncio
+from logging import debug, info
+import os
+import aio_pika
+from typing import Callable
+from ..auth.credentials import Credential
+from ..types.request_types import UserCall, UserState, ChatID
+from rich.console import Console
+from rich.table import Table
+from rich.text import Text
+from rich.panel import Panel
+from urllib.parse import quote
+
+class MessageConsumer:
+    def __init__(
+        self,
+        credential: Credential,
+        amqp_url: str,
+        grpc_uri: str,
+        queue_consume: str,
+        prefetch_count: int = 1,
+        virtual_host: str = "/",
+    ) -> None:
+        self.__virtual_host = virtual_host
+        self.__prefetch_count = prefetch_count
+        self.__queue_consume = queue_consume
+        self.__amqp_url = amqp_url
+        self.__grpc_uri = grpc_uri
+        self.__credentials = credential
+
+    @classmethod
+    def load_dotenv(
+        cls,
+        user_env: str = "RABBIT_USER",
+        pass_env: str = "RABBIT_PASS",
+        uri_env: str = "RABBIT_URI",
+        queue_env: str = "RABBIT_QUEUE",
+        prefetch_env: str = "RABBIT_PREFETCH",
+        vhost_env: str = "RABBIT_VHOST",
+        grpc_uri: str = "GRPC_URI",
+    ) -> "MessageConsumer":
+        username = os.getenv(user_env)
+        password = os.getenv(pass_env)
+        url = os.getenv(uri_env)
+        queue = os.getenv(queue_env)
+        prefetch = os.getenv(prefetch_env, 1)
+        vhost = os.getenv(vhost_env, "/")
+        grpc = os.getenv(grpc_uri)
+
+        if not username or not password or not url or not queue or not grpc:
+            raise ValueError("Corrija as variáveis de ambiente!")
+
+        return cls(
+            credential=Credential(username=username, password=password),
+            amqp_url=url,
+            queue_consume=queue,
+            prefetch_count=int(prefetch),
+            virtual_host=vhost,
+            grpc_uri=grpc,
+        )
+
+    async def start_consume(self, process_message: Callable):
+        try:
+            user = quote(self.__credentials.username)
+            pwd = quote(self.__credentials.password)
+            vhost = quote(self.__virtual_host)
+            uri = self.__amqp_url
+            amqp_url = f"amqp://{user}:{pwd}@{uri}/{vhost}"
+            connection = await aio_pika.connect_robust(amqp_url)
+
+            async with connection:
+                channel = await connection.channel()
+                await channel.set_qos(prefetch_count=self.__prefetch_count)
+                
+                try:
+                    queue = await channel.get_queue(self.__queue_consume, ensure=True)
+                except aio_pika.exceptions.ChannelNotFoundEntity:
+                    arguments = {
+                        "x-dead-letter-exchange": "log_error",  # Dead Letter Exchange
+                        "x-expires": 86400000,                 # Expiração da fila (em milissegundos)
+                        "x-message-ttl": 300000                # Tempo de vida das mensagens (em milissegundos)
+                    }
+                    queue = await channel.declare_queue(self.__queue_consume, durable=True, arguments=arguments)
+                
+                info("[x] Server inicializado! Aguardando solicitações RPC")
+
+                async for message in queue:
+                    async with message.process():
+                        await self.on_request(message.body, process_message)
+        except Exception as e:
+            print(f"Erro durante o consumo de mensagens: {e}")
+            # Reiniciar a conexão em caso de falha
+            # await self.start_consume(process_message)
+
+    async def on_request(self, body: bytes, process_message: Callable):
+        try:
+            message = body.decode()
+            message_json = json.loads(message)
+            pure_message = self.__transform_message(message_json)
+            await process_message(pure_message)
+        except Exception as e:
+            print(f"Erro ao processar mensagem: {e}")
+
+    def __transform_message(self, message: dict) -> UserCall:
+        user_state = message.get("user_state", {})
+        observation = user_state.get("observation", {})
+        if isinstance(observation, str):
+            observation = json.loads(observation)
+
+        usercall = UserCall(
+            user_state=UserState(
+                chatID=ChatID(
+                    user_id=user_state['chat_id'].get("user_id", ""),
+                    company_id=user_state['chat_id'].get("company_id", ""),
+                ),
+                menu=user_state.get("menu", ""),
+                route=user_state.get("route", ""),
+                protocol=user_state.get("protocol", ""),
+                observation=observation,
+            ),
+            type_message=message.get("type_message", ""),
+            content_message=message.get("content_message", ""),
+            grpc_uri=self.__grpc_uri,
+        )
+        
+        return usercall
+
+    def reprer(self):
+        console = Console()
+
+        title_text = Text("ChatGraph", style="bold red", justify="center")
+        title_panel = Panel.fit(title_text, title=" ", border_style="bold red", padding=(1, 4))
+
+        separator = Text("🐇🐇🐇 RabbitMessageConsumer 📨📨📨", style="cyan", justify="center")
+
+        table = Table(show_header=True, header_style="bold magenta", title="RabbitMQ Consumer")
+        table.add_column("Atributo", justify="center", style="cyan", no_wrap=True)
+        table.add_column("Valor", justify="center", style="magenta")
+
+        table.add_row("Virtual Host", self.__virtual_host)
+        table.add_row("Prefetch Count", str(self.__prefetch_count))
+        table.add_row("Queue Consume", self.__queue_consume)
+        table.add_row("AMQP URL", self.__amqp_url)
+        table.add_row("Username", self.__credentials.username)
+        table.add_row("Password", "******")
+
+        console.print(title_panel, justify="center")
+        console.print(separator, justify="center")
+        console.print(table, justify="center")

chatgraph-0.5.1/chatgraph/pb/router.proto

@@ -0,0 +1,127 @@
+syntax = "proto3";
+
+package chatbot;
+
+option go_package = "./chatbot";
+
+///// Serviços de Estado do Usuário /////
+service UserStateService {
+    rpc InsertUpdateUserState(UserState) returns (RequestStatus);
+    rpc DeleteUserState(ChatID) returns (RequestStatus);
+    rpc GetUserState(ChatID) returns (UserState);
+    rpc GetAllUserStates(Void) returns (UserStateList);
+}
+
+///// Serviços de Mensagens /////
+service SendMessage {
+    rpc SendMessage(Message) returns (RequestStatus);
+}
+
+///// Serviços de Transfer /////
+service Transfer {
+    rpc GetAllCampaigns(Void) returns (CampaignsList);
+    rpc GetCampaignID(CampaignName) returns (CampaignDetails);
+    rpc TransferToHuman(TransferToHumanRequest) returns (RequestStatus);
+    rpc TransferToMenu(TransferToMenuRequest) returns (RequestStatus);
+}
+
+///// Serviços de EndChat /////
+service EndChat {
+    rpc GetAllTabulations(Void) returns (TabulationsList);
+    rpc GetTabulationID(TabulationName) returns (TabulationDetails);
+    rpc EndChat(EndChatRequest) returns (RequestStatus);
+}
+
+///// Mensagens Compartilhadas /////
+message Void {}
+
+message RequestStatus {
+    bool status = 1;
+    string message = 2;
+}
+
+message ChatID {
+    string user_id = 1;
+    string company_id = 2;
+}
+///// Mensagens para Estado do Usuário /////
+message UserState {
+    ChatID chat_id = 1;
+    string menu = 2;
+    string route = 3;
+    string protocol = 4;
+    string observation = 5;
+}
+
+message UserStateList {
+    repeated UserState user_states = 1;
+}
+
+///// Mensagens para Serviços de Mensagens /////
+message TextMessage {
+    string type = 1;
+    string url = 2;
+    string filename = 3;
+    string title = 4;
+    string detail = 5;
+    string caption = 6;
+}
+
+message Button{
+    string type = 1;
+    string title = 2;
+    string detail = 3;
+}
+
+message Message {
+    ChatID chat_id = 1;
+    TextMessage message = 2;
+    repeated Button buttons = 3;
+    Button display_button = 4;
+}
+
+///// Mensagens para Serviços de Transfer /////
+message TransferToHumanRequest{
+    ChatID chat_id = 1;
+    string campaign_id = 2;
+}
+
+message TransferToMenuRequest{
+    ChatID chat_id = 1;
+    string menu = 2;
+    string user_message = 3;
+}
+
+message TabulationName{
+    string name = 1;
+}
+
+message TabulationDetails{
+    string id = 1;
+    string name = 2;
+    string last_update = 3;
+}
+
+message TabulationsList{
+    repeated TabulationDetails tabulations = 1;
+}
+
+///// Serviços de EndChat /////
+message EndChatRequest {
+    ChatID chat_id = 1;
+    string tabulation_id = 2;
+}
+
+message CampaignName {
+    string name = 1;
+}
+
+message CampaignDetails {
+    string id = 1;
+    string name = 2;
+    string last_update = 3;
+}
+
+message CampaignsList {
+    repeated CampaignDetails campaigns = 1;
+}