chatgraph 0.3.16__tar.gz → 0.5.0__tar.gz

{chatgraph-0.3.16 → chatgraph-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: chatgraph
-Version: 0.3.16
+Version: 0.5.0
 Summary: A user-friendly chatbot library
 Home-page: https://github.com/irissonnlima/chatgraph
 License: MIT
@@ -13,6 +13,8 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: grpcio (>=1.67.0,<2.0.0)
 Requires-Dist: grpcio-tools (>=1.67.0,<2.0.0)
+Requires-Dist: matplotlib (>=3.10.0,<4.0.0)
+Requires-Dist: networkx (>=3.4.2,<4.0.0)
 Requires-Dist: pika (>=1.3.2,<2.0.0)
 Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
 Requires-Dist: rich (>=13.8.1,<14.0.0)

{chatgraph-0.3.16 → chatgraph-0.5.0}/chatgraph/__init__.py

@@ -2,9 +2,9 @@ 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
 
 __all__ = [
@@ -18,8 +18,9 @@ __all__ = [
     'Route',
     'EndChatResponse',
     'TransferToHuman',
+    'ChatID',
     'UserState',
     'Message',
     'Button',
-    'ListElements'
+    
 ]

{chatgraph-0.3.16 → chatgraph-0.5.0}/chatgraph/bot/chatbot_model.py

@@ -2,12 +2,13 @@ import inspect
 from functools import wraps
 from logging import debug
 import json
+import asyncio
 from logging import error
 
-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
@@ -31,7 +32,7 @@ class ChatbotApp:
         self.__message_consumer = message_consumer
         self.__routes = {}
     
-    def include_router(self, router: ChatbotRouter, prefix: str):
+    def include_router(self, router: ChatbotRouter):
         """
         Inclui um roteador de chatbot com um prefixo nas rotas da aplicação.
 
@@ -42,18 +43,7 @@ class ChatbotApp:
         Raises:
             ChatbotError: Se a rota 'start' não for encontrada no roteador.
         """
-        if 'start' not in router.routes.keys():
-            raise ChatbotError('Erro ao incluir rota, start não encontrado!')
-
-        prefixed_routes = {
-            (
-                f'start{prefix.lower()}'
-                if key.lower() == 'start'
-                else f'start{prefix.lower()}{key.lower().replace("start", "")}'
-            ): value
-            for key, value in router.routes.items()
-        }
-        self.__routes.update(prefixed_routes)
+        self.__routes.update(router.routes)
 
     def route(self, route_name: str):
         """
@@ -67,9 +57,6 @@ class ChatbotApp:
         """
         route_name = route_name.strip().lower()
 
-        if 'start' not in route_name:
-            route_name = f'start{route_name}'
-
         def decorator(func):
             params = dict()
             signature = inspect.signature(func)
@@ -102,8 +89,10 @@ 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)
+        asyncio.run(self.__message_consumer.start_consume(self.process_message))
     
     def process_message(self, userCall: UserCall):
         """
@@ -119,15 +108,16 @@ class ChatbotApp:
         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
-        handler = self.__routes.get(route, None)
+        observation = userCall.observation
+        handler = self.__routes.get(route_handler, None)
 
         if not handler:
             raise ChatbotMessageError(
-                customer_id, f'Rota não encontrada para {route}!'
+                user_id, f'Rota não encontrada para {route}!'
             )
             
         func = handler['function']
@@ -151,14 +141,14 @@ class ChatbotApp:
     def __process_func_response(self, userCall_response, userCall: UserCall, route: str):
         
         if isinstance(userCall_response, (str, float, int)):
-            userCall.send(Message(text=userCall_response))
+            userCall.send(Message(userCall_response))
             return
 
         elif isinstance(userCall_response, Route):
             userCall.route = userCall_response.current
             return
             
-        elif isinstance(userCall_response, (Message, Button, ListElements)):
+        elif isinstance(userCall_response, (Message, Button)):
             userCall.send(userCall_response)
             
             return
@@ -172,7 +162,7 @@ class ChatbotApp:
             return
 
         elif isinstance(userCall_response, RedirectResponse):
-            route = self.__adjust_route(userCall_response.route, route)
+            route = route + '.' + userCall_response.route
             userCall.route = route
             return self.process_message(userCall)
 

{chatgraph-0.3.16 → chatgraph-0.5.0}/chatgraph/bot/chatbot_router.py

@@ -18,7 +18,17 @@ class ChatbotRouter:
         """
         Inicializa a classe ChatbotRouter com um dicionário vazio de rotas.
         """
-        self.routes = {}
+        self.__routes = {}
+    
+    @property
+    def routes(self):
+        """
+        Retorna as rotas registradas no roteador.
+
+        Returns:
+            dict: Um dicionário contendo as rotas e funções associadas.
+        """
+        return self.__routes
 
     def route(self, route_name: str):
         """
@@ -30,15 +40,14 @@ class ChatbotRouter:
         Returns:
             function: O decorador que adiciona a função à rota especificada.
         """
-        if 'start' not in route_name:
-            route_name = f'start{route_name}'
+
+        route_name = route_name.strip().lower()
 
         def decorator(func):
             params = dict()
             signature = inspect.signature(func)
             output_param = signature.return_annotation
 
-            # Itera sobre os parâmetros da função e extrai seus tipos
             for name, param in signature.parameters.items():
                 param_type = (
                     param.annotation
@@ -48,8 +57,7 @@ class ChatbotRouter:
                 params[param_type] = name
                 debug(f'Parameter: {name}, Type: {param_type}')
 
-            # Adiciona a função e seus parâmetros à rota especificada
-            self.routes[route_name.strip().lower()] = {
+            self.__routes[route_name] = {
                 'function': func,
                 'params': params,
                 'return': output_param,
@@ -63,7 +71,7 @@ class ChatbotRouter:
 
         return decorator
 
-    def include_router(self, router: 'ChatbotRouter', prefix: str):
+    def include_router(self, router: 'ChatbotRouter'):
         """
         Inclui outro roteador com um prefixo nas rotas do roteador atual.
 
@@ -74,16 +82,4 @@ class ChatbotRouter:
         Raises:
             ChatbotError: Se a rota 'start' não for encontrada no roteador fornecido.
         """
-        if 'start' not in router.routes.keys():
-            raise ChatbotError('Erro ao incluir rota, start não encontrado!')
-
-        # Adiciona prefixo às rotas do roteador incluído
-        prefixed_routes = {
-            (
-                f'{prefix.lower()}'
-                if key.lower() == 'start'
-                else f'start{prefix.lower()}{key.lower().replace("start", "")}'
-            ): value
-            for key, value in router.routes.items()
-        }
-        self.routes.update(prefixed_routes)
+        self.__routes.update(router.__routes)

chatgraph-0.5.0/chatgraph/gRPC/gRPCCall.py

@@ -0,0 +1,126 @@
+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)
+            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)
+            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)
+            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)
+            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)
+            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)
+            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)
+            print(response)
+            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.0/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.0/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;
+}