chatgraph 0.6.4__py3-none-any.whl

chatgraph/error/route_error.py

@@ -0,0 +1,26 @@
+class RouteError(Exception):
+    """
+    Exceção personalizada para erros relacionados a rotas no sistema do chatbot.
+
+    Atributos:
+        message (str): A mensagem de erro descrevendo o problema.
+    """
+
+    def __init__(self, message: str):
+        """
+        Inicializa a exceção RouteError com uma mensagem de erro.
+
+        Args:
+            message (str): A mensagem de erro descrevendo o problema.
+        """
+        self.message = message
+        super().__init__(self.message)
+
+    def __str__(self):
+        """
+        Retorna a representação em string da exceção RouteError.
+
+        Returns:
+            str: Uma string formatada que inclui o nome da exceção e a mensagem de erro.
+        """
+        return f'RouteError: {self.message}'

chatgraph/gRPC/gRPCCall.py

@@ -0,0 +1,189 @@
+import os
+import grpc
+import json
+from rich.console import Console
+
+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)
+
+        self.console = Console()
+
+    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:
+                self.console.print(
+                    f"Erro ao chamar InsertUpdateUserState: {response.message}",
+                    style="bold red",
+                )
+            return response
+        except grpc.RpcError as e:
+            self.console.print(
+                f"Erro ao chamar InsertUpdateUserState: {e}", style="bold red"
+            )
+            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:
+                self.console.print(
+                    f"Erro ao chamar SendMessage: {response.message}", style="bold red"
+                )
+            return response
+        except grpc.RpcError as e:
+            self.console.print(f"Erro ao chamar DeleteUserState: {e}", style="bold red")
+            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:
+            self.console.print(f"Erro ao chamar GetUserState: {e}", style="bold red")
+            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:
+                self.console.print(
+                    f"Erro ao chamar SendMessage: {response.message}", style="bold red"
+                )
+            return response
+        except grpc.RpcError as e:
+            self.console.print(f"Erro ao chamar SendMessage: {e}", style="bold red")
+            return None
+
+    def send_image(self, message_data):
+        # print(json.dumps(message_data))
+
+        request = chatbot_pb2.FileMessage(**message_data)
+
+        try:
+            response = self.send_message_stub.SendImage(request)
+            if not response.status and response.message != "arquivo não encontrado":
+                self.console.print(
+                    f"Erro ao chamar SendImage: {response.message}", style="bold red"
+                )
+            elif response.message == "arquivo não encontrado":
+                print("Arquivo não encontrado, Carregando arquivo...")
+            return response
+        except grpc.RpcError as e:
+            self.console.print(f"Erro ao chamar SendImage: {e}", style="bold red")
+            return None
+
+    def upload_file(self, file_data):
+        request = chatbot_pb2.UploadFileRequest(**file_data)
+        try:
+            response = self.send_message_stub.UploadFile(request)
+            if not response.status:
+                self.console.print(
+                    f"Erro ao chamar UploadFile: {response.message}", style="bold red"
+                )
+            return response
+        except grpc.RpcError as e:
+            self.console.print(f"Erro ao chamar UploadFile: {e}", style="bold red")
+            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:
+                self.console.print(
+                    f"Erro ao chamar SendMessage: {response.message}", style="bold red"
+                )
+            return response
+        except grpc.RpcError as e:
+            self.console.print(f"Erro ao chamar TransferToHuman: {e}", style="bold red")
+            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:
+                self.console.print(
+                    f"Erro ao chamar TransferToMenu: {response.message}",
+                    style="bold red",
+                )
+            return response
+        except grpc.RpcError as e:
+            self.console.print(f"Erro ao chamar TransferToMenu: {e}", style="bold red")
+            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:
+                self.console.print(
+                    f"Erro ao chamar SendMessage: {response.message}", style="bold red"
+                )
+            return response
+        except grpc.RpcError as e:
+            self.console.print(f"Erro ao chamar EndChat: {e}", style="bold red")
+            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:
+            self.console.print(f"Erro ao chamar GetCampaignID: {e}", style="bold red")
+            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:
+            self.console.print(f"Erro ao chamar GetAllCampaigns: {e}", style="bold red")
+            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:
+            self.console.print(f"Erro ao chamar GetTabulationID: {e}", style="bold red")
+            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:
+            self.console.print(
+                f"Erro ao chamar GetAllTabulations: {e}", style="bold red"
+            )
+            return None

chatgraph/messages/message_consumer.py

@@ -0,0 +1,212 @@
+import json
+from logging import info
+import os
+import aio_pika
+from typing import Callable
+from ..auth.credentials import Credential
+from ..models.message import Message
+from ..models.userstate import UserState
+from ..services.router_http_client import RouterHTTPClient
+from ..types.usercall import UserCall
+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,
+        router_url: str,
+        router_token: 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.__router_url = router_url
+        self.__router_token = router_token
+        self.__credentials = credential
+        self.__router_client = None
+
+    @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',
+        router_env: str = 'ROUTER_URL',
+        router_token_env: str = 'ROUTER_TOKEN',
+    ) -> '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, '/')
+        router_url = os.getenv(router_env)
+        router_token = os.getenv(router_token_env)
+
+        envs_essentials = {
+            username: user_env,
+            password: pass_env,
+            url: uri_env,
+            queue: queue_env,
+            router_url: router_env,
+            router_token: router_token_env,
+        }
+
+        if None in envs_essentials:
+            envs_missing = [v for k, v in envs_essentials.items() if k is None]
+            raise ValueError(
+                f'Corrija as variáveis de ambiente: {envs_missing}'
+            )
+
+        return cls(
+            credential=Credential(username=username, password=password),
+            amqp_url=url,
+            queue_consume=queue,
+            prefetch_count=int(prefetch),
+            virtual_host=vhost,
+            router_url=router_url,
+            router_token=router_token,
+        )
+
+    async def __initialize_router(self) -> RouterHTTPClient:
+        """Inicializa o cliente HTTP apenas uma vez (singleton)."""
+        if self.__router_client is None:
+            self.__router_client = RouterHTTPClient(
+                base_url=self.__router_url,
+                username='chatgraph',
+                password=self.__router_token,
+            )
+        return self.__router_client
+
+    async def start_consume(self, process_message: Callable):
+        try:
+            # Inicializar cliente HTTP uma única vez
+            await self.__initialize_router()
+
+            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)
+        finally:
+            # Fechar cliente HTTP quando o consumer parar
+            await self.cleanup()
+
+    async def on_request(self, body: bytes, process_message: Callable):
+        try:
+            message = body.decode()
+            message_json = json.loads(message)
+            pure_message = await self.__transform_message(message_json)
+            await process_message(pure_message)
+        except Exception as e:
+            print(f'Erro ao processar mensagem: {e}')
+
+    async def __transform_message(self, message: dict) -> UserCall:
+        user_state = message.get('user_state', {})
+        message_data = message.get('message', {})
+        observation = user_state.get('observation', {})
+
+        if isinstance(observation, str):
+            observation = json.loads(observation)
+
+        user_state_models = UserState.from_dict(user_state)
+        message_models = Message.from_dict(message_data)
+
+        # Reutilizar o mesmo cliente para todas as mensagens
+        router_client = await self.__initialize_router()
+
+        usercall = UserCall(
+            user_state=user_state_models,
+            message=message_models,
+            router_client=router_client,
+        )
+
+        return usercall
+
+    async def cleanup(self):
+        """Libera recursos do cliente HTTP."""
+        if self.__router_client:
+            await self.__router_client.close()
+            self.__router_client = None
+            print('✓ RouterHTTPClient fechado')
+
+    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('Rabbit Username', self.__credentials.username)
+        table.add_row('Rabbit Password', '******')
+        table.add_row('Router URL', self.__router_url)
+
+        console.print(title_panel, justify='center')
+        console.print(separator, justify='center')
+        console.print(table, justify='center')

chatgraph/models/actions.py

@@ -0,0 +1,138 @@
+"""
+Modelos de dados para ações do chatbot.
+
+Este módulo contém as dataclasses e enums para representar ações
+como transferências e encerramentos de chat.
+"""
+
+from dataclasses import dataclass
+from enum import Enum
+
+
+class ActionType(Enum):
+    """
+    Tipo de ação no sistema.
+
+    Attributes:
+        TRANSFER: Transferência para atendimento humano
+        END_CHAT: Encerramento de chat
+        MESSAGE: Mensagem
+    """
+
+    TRANSFER = "TRANSFER"
+    END_CHAT = "END_CHAT"
+    MESSAGE = "MESSAGE"
+
+    @classmethod
+    def from_string(cls, value: str) -> "ActionType":
+        """
+        Cria ActionType a partir de string.
+
+        Args:
+            value: String representando o tipo
+
+        Returns:
+            ActionType correspondente
+
+        Raises:
+            ValueError: Se o valor não for válido
+        """
+        try:
+            return cls(value.upper())
+        except ValueError:
+            raise ValueError(f"invalid action type: {value}")
+
+
+@dataclass
+class EndAction:
+    """
+    Ação de encerramento de chat.
+
+    Attributes:
+        id: ID único da ação
+        name: Nome da ação/tabulação
+        department_id: ID do departamento
+        observation: Observação sobre o encerramento
+        last_update: Data/hora de última atualização (ISO 8601)
+    """
+
+    id: str = ""
+    name: str = ""
+    department_id: int = 0
+    observation: str = ""
+    last_update: str = ""
+
+    def is_empty(self) -> bool:
+        """Verifica se a ação está vazia."""
+        return not self.id and not self.name
+
+    def to_dict(self) -> dict:
+        """Converte para dicionário."""
+        return {
+            "id": self.id,
+            "name": self.name,
+            "department_id": self.department_id,
+            "observation": self.observation,
+            "last_update": self.last_update,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "EndAction":
+        """Cria instância a partir de dicionário."""
+        return cls(
+            id=data.get("id", ""),
+            name=data.get("name", ""),
+            department_id=data.get("department_id", 0),
+            observation=data.get("observation", ""),
+            last_update=data.get("last_update", ""),
+        )
+
+
+@dataclass
+class TransferToHumanAction:
+    """
+    Ação de transferência para atendimento humano.
+
+    Attributes:
+        id: ID único da ação
+        name: Nome da campanha/fila
+        department_id: ID do departamento
+        observation: Observação sobre a transferência
+        last_update: Data/hora de última atualização (ISO 8601)
+    """
+
+    id: int = 0
+    name: str = ""
+    department_id: int = 0
+    observation: str = ""
+    last_update: str = ""
+
+    def is_empty(self) -> bool:
+        """Verifica se a ação está vazia."""
+        return not self.id and not self.name
+
+    def to_dict(self) -> dict:
+        """Converte para dicionário."""
+        return {
+            "id": self.id,
+            "name": self.name,
+            "department_id": self.department_id,
+            "observation": self.observation,
+            "last_update": self.last_update,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "TransferToHumanAction":
+        """Cria instância a partir de dicionário."""
+        return cls(
+            id=data.get("id", 0),
+            name=data.get("name", ""),
+            department_id=data.get("department_id", 0),
+            observation=data.get("observation", ""),
+            last_update=data.get("last_update", ""),
+        )
+
+
+# Instâncias vazias para comparação
+EMPTY_END_ACTION = EndAction()
+EMPTY_TRANSFER_TO_HUMAN_ACTION = TransferToHumanAction()