chatgraph 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

chatgraph/auth/credentials.py

@@ -2,28 +2,66 @@ import os
 
 
 class Credential:
-    def __init__(
-        self, username: str | None = None, password: str | None = None
-    ):
+    """
+    Classe para gerenciar credenciais de usuário e senha, com suporte a variáveis de ambiente.
+    """
+
+    def __init__(self, username: str | None = None, password: str | None = None):
+        """
+        Inicializa a classe Credential com um nome de usuário e senha.
+
+        Args:
+            username (str | None): O nome de usuário. Pode ser None se for carregado de uma variável de ambiente.
+            password (str | None): A senha do usuário. Pode ser None se for carregada de uma variável de ambiente.
+        """
         self.__username = username
         self.__password = password
 
     @property
-    def password(self):
+    def password(self) -> str:
+        """
+        Retorna a senha do usuário.
+
+        Raises:
+            ValueError: Se a senha não estiver definida.
+
+        Returns:
+            str: A senha do usuário.
+        """
         if not self.__password:
             raise ValueError('Senha vazia!')
         return self.__password
 
     @property
-    def username(self):
+    def username(self) -> str:
+        """
+        Retorna o nome de usuário.
+
+        Raises:
+            ValueError: Se o nome de usuário não estiver definido.
+
+        Returns:
+            str: O nome de usuário.
+        """
         if not self.__username:
             raise ValueError('Usuário vazio!')
         return self.__username
 
     @classmethod
-    def dot_env_credentials(
-        cls, user_env: str = 'CHATBOT_USER', pass_env: str = 'CHATBOT_PASS'
-    ) -> 'Credential':
+    def load_dotenv(cls, user_env: str = 'CHATBOT_USER', pass_env: str = 'CHATBOT_PASS') -> 'Credential':
+        """
+        Carrega as credenciais de variáveis de ambiente e retorna uma instância da classe Credential.
+
+        Args:
+            user_env (str): Nome da variável de ambiente que armazena o nome de usuário. Padrão é 'CHATBOT_USER'.
+            pass_env (str): Nome da variável de ambiente que armazena a senha. Padrão é 'CHATBOT_PASS'.
+
+        Raises:
+            ValueError: Se o nome de usuário ou a senha não estiverem definidas nas variáveis de ambiente.
+
+        Returns:
+            Credential: Uma instância da classe Credential com as credenciais carregadas.
+        """
         username = os.getenv(user_env)
         password = os.getenv(pass_env)
 

chatgraph/bot/chatbot_model.py

@@ -6,22 +6,40 @@ from logging import debug
 from ..error.chatbot_error import ChatbotError, ChatbotMessageError
 from ..messages.base_message_consumer import MessageConsumer
 from ..types.message_types import Message
+from ..types.output_state import ChatbotResponse, RedirectResponse
 from ..types.route import Route
 from ..types.user_state import UserState
 from .chatbot_router import ChatbotRouter
-from ..types.output_state import ChatbotResponse, RedirectResponse
+
 
 class ChatbotApp(ABC):
-    def __init__(
-        self,
-        user_state: UserState,
-        message_consumer: MessageConsumer,
-    ):
+    """
+    Classe principal para a aplicação do chatbot, gerencia as rotas e a lógica de processamento de mensagens.
+    """
+
+    def __init__(self, user_state: UserState, message_consumer: MessageConsumer):
+        """
+        Inicializa a classe ChatbotApp com um estado de usuário e um consumidor de mensagens.
+
+        Args:
+            user_state (UserState): O estado do usuário, que contém informações persistentes sobre as interações do usuário.
+            message_consumer (MessageConsumer): O consumidor de mensagens que lida com a entrada de mensagens no sistema.
+        """
         self.__message_consumer = message_consumer
         self.__user_state = user_state
         self.__routes = {}
-
+    
     def include_router(self, router: ChatbotRouter, prefix: str):
+        """
+        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.
+        """
         if 'START' not in router.routes.keys():
             raise ChatbotError('Erro ao incluir rota, START não encontrado!')
 
@@ -36,9 +54,20 @@ class ChatbotApp(ABC):
         self.__routes.update(prefixed_routes)
 
     def route(self, route_name: str):
-        if not 'START' in route_name:
+        """
+        Decorador para adicionar uma função como uma rota na aplicação do chatbot.
+
+        Args:
+            route_name (str): O nome da rota para a qual a função deve ser associada.
+
+        Returns:
+            function: O decorador que adiciona a função à rota especificada.
+        """
+        route_name = route_name.strip().upper()
+
+        if 'START' not in route_name:
             route_name = f'START{route_name}'
-            
+
         def decorator(func):
             params = dict()
             signature = inspect.signature(func)
@@ -53,8 +82,7 @@ class ChatbotApp(ABC):
                 params[param_type] = name
                 debug(f'Parameter: {name}, Type: {param_type}')
 
-                
-            self.__routes[route_name.strip().upper()] = {
+            self.__routes[route_name] = {
                 'function': func,
                 'params': params,
                 'return': output_param,
@@ -69,9 +97,25 @@ class ChatbotApp(ABC):
         return decorator
 
     def start(self):
+        """
+        Inicia o consumo de mensagens pelo chatbot, processando cada mensagem recebida.
+        """
         self.__message_consumer.start_consume(self.process_message)
 
     def process_message(self, message: Message):
+        """
+        Processa uma mensagem recebida, identificando a rota correspondente e executando a função associada.
+
+        Args:
+            message (Message): 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 = message.customer_id
 
         menu = self.__user_state.get_menu(customer_id)
@@ -93,7 +137,7 @@ class ChatbotApp(ABC):
             kwargs[route_state_name] = Route(menu, list(self.__routes.keys()))
 
         message_response = func(**kwargs)
-        
+
         if type(message_response) in (str, float, int):
             return message_response
         elif type(message_response) == ChatbotResponse:
@@ -106,12 +150,22 @@ class ChatbotApp(ABC):
             return self.process_message(message)
         else:
             raise ChatbotError('Tipo de retorno inválido!')
-    
-    def __adjust_route(self, route: str, absolute_route:str) -> str:
+
+    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 not 'START' in route:
-            route = absolute_route+route
-            
+
+        if 'START' not in route:
+            route = absolute_route + route
+
         return route

chatgraph/bot/chatbot_router.py

@@ -3,22 +3,40 @@ from functools import wraps
 from logging import debug
 
 from ..error.chatbot_error import ChatbotError
-from ..types.message_types import Message
 
 
 class ChatbotRouter:
+    """
+    Classe responsável por gerenciar e registrar as rotas do chatbot, associando-as a funções específicas.
+    
+    Atributos:
+        routes (dict): Um dicionário que armazena as rotas do chatbot e suas funções associadas.
+    """
+
     def __init__(self):
+        """
+        Inicializa a classe ChatbotRouter com um dicionário vazio de rotas.
+        """
         self.routes = {}
 
     def route(self, route_name: str):
-        if not 'START' in route_name:
+        """
+        Decorador para adicionar uma função como uma rota no roteador do chatbot.
+
+        Args:
+            route_name (str): O nome da rota para a qual a função deve ser associada.
+
+        Returns:
+            function: O decorador que adiciona a função à rota especificada.
+        """
+        if 'START' not in route_name:
             route_name = f'START{route_name}'
-            
+
         def decorator(func):
             params = dict()
             signature = inspect.signature(func)
             output_param = signature.return_annotation
-            
+
             for name, param in signature.parameters.items():
                 param_type = (
                     param.annotation
@@ -28,7 +46,6 @@ class ChatbotRouter:
                 params[param_type] = name
                 debug(f'Parameter: {name}, Type: {param_type}')
 
-                
             self.routes[route_name.strip().upper()] = {
                 'function': func,
                 'params': params,
@@ -44,6 +61,16 @@ class ChatbotRouter:
         return decorator
 
     def include_router(self, router: 'ChatbotRouter', prefix: str):
+        """
+        Inclui outro roteador com um prefixo nas rotas do roteador atual.
+
+        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 fornecido.
+        """
         if 'START' not in router.routes.keys():
             raise ChatbotError('Erro ao incluir rota, START não encontrado!')
 

chatgraph/error/chatbot_error.py

@@ -1,17 +1,57 @@
 class ChatbotError(Exception):
+    """
+    Exceção personalizada para erros gerais relacionados ao chatbot.
+
+    Atributos:
+        message (str): A mensagem de erro descrevendo o problema.
+    """
+
     def __init__(self, message: str):
+        """
+        Inicializa a exceção ChatbotError 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 ChatbotError.
+
+        Returns:
+            str: Uma string formatada que inclui o nome da exceção e a mensagem de erro.
+        """
         return f'ChatbotError: {self.message}'
 
 
 class ChatbotMessageError(Exception):
+    """
+    Exceção personalizada para erros relacionados a mensagens de clientes no chatbot.
+
+    Atributos:
+        customer_id (str): O ID do cliente relacionado ao erro.
+        message (str): A mensagem de erro descrevendo o problema, incluindo o ID do cliente.
+    """
+
     def __init__(self, customer_id: str, message: str):
+        """
+        Inicializa a exceção ChatbotMessageError com um ID de cliente e uma mensagem de erro.
+
+        Args:
+            customer_id (str): O ID do cliente relacionado ao erro.
+            message (str): A mensagem de erro descrevendo o problema.
+        """
         self.customer_id = customer_id
         self.message = f'{message} ID recebido: {customer_id}'
         super().__init__(self.message)
 
     def __str__(self):
-        return f'InvalidCustomerIDError: {self.message}'
+        """
+        Retorna a representação em string da exceção ChatbotMessageError.
+
+        Returns:
+            str: Uma string formatada que inclui o nome da exceção e a mensagem de erro.
+        """
+        return f'ChatbotMessageError: {self.message}'

chatgraph/error/route_error.py

@@ -1,7 +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/messages/base_message_consumer.py

@@ -3,6 +3,31 @@ from typing import Any, Callable
 
 
 class MessageConsumer(ABC):
+    """
+    Classe base abstrata para consumidores de mensagens no sistema do chatbot.
+
+    Esta classe define a interface que todos os consumidores de mensagens devem implementar para serem usados no sistema do chatbot.
+    """
+
     @abstractmethod
     def start_consume(self, process_message: Callable) -> Any:
+        """
+        Inicia o consumo de mensagens e processa cada mensagem usando a função fornecida.
+
+        Args:
+            process_message (Callable): Função de callback que processa cada mensagem recebida.
+
+        Returns:
+            Any: O resultado do processo de consumo de mensagens, dependendo da implementação concreta.
+        """
+        pass
+
+    @abstractmethod
+    def load_dotenv(self) -> 'MessageConsumer':
+        """
+        Carrega variáveis de ambiente para configurar o consumidor de mensagens.
+
+        Returns:
+            MessageConsumer: A instância do consumidor de mensagens configurado.
+        """
         pass

chatgraph/messages/rabbitMQ_message_consumer.py

@@ -1,32 +1,107 @@
 import json
 from logging import debug, info
-
+import os
 import pika
-
+from typing import Callable
 from ..auth.credentials import Credential
 from ..types.message_types import Message
 from .base_message_consumer import MessageConsumer
 
 
 class RabbitMessageConsumer(MessageConsumer):
+    """
+    Implementação de MessageConsumer para consumir mensagens de uma fila RabbitMQ.
+
+    Atributos:
+        __virtual_host (str): O host virtual usado para a conexão RabbitMQ.
+        __prefetch_count (int): O número de mensagens pré-carregadas que o consumidor pode processar.
+        __queue_consume (str): O nome da fila de consumo.
+        __amqp_url (str): A URL de conexão AMQP do RabbitMQ.
+        __credentials (pika.PlainCredentials): Credenciais do RabbitMQ para autenticação.
+    """
+
     def __init__(
         self,
+        credential: Credential,
         amqp_url: str,
         queue_consume: str,
-        credentials: Credential,
         prefetch_count: int = 1,
         virtual_host: str = '/',
     ) -> None:
+        """
+        Inicializa o consumidor de mensagens RabbitMQ com as configurações fornecidas.
+
+        Args:
+            credential (Credential): Credenciais de autenticação para o RabbitMQ.
+            amqp_url (str): A URL de conexão AMQP do RabbitMQ.
+            queue_consume (str): O nome da fila de consumo.
+            prefetch_count (int, opcional): O número de mensagens pré-carregadas. Padrão é 1.
+            virtual_host (str, opcional): O host virtual do RabbitMQ. Padrão é '/'.
+        """
         self.__virtual_host = virtual_host
         self.__prefetch_count = prefetch_count
         self.__queue_consume = queue_consume
         self.__amqp_url = amqp_url
         self.__credentials = pika.PlainCredentials(
-            credentials.username, credentials.password
+            credential.username, credential.password
         )
 
-    def start_consume(self, process_message: callable):
-        try:  # Verificar se recursão não vai estourar
+    @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',
+    ) -> 'RabbitMessageConsumer':
+        """
+        Carrega as configurações do RabbitMQ a partir de variáveis de ambiente e retorna uma instância de RabbitMessageConsumer.
+
+        Args:
+            user_env (str): Nome da variável de ambiente para o usuário do RabbitMQ. Padrão é 'RABBIT_USER'.
+            pass_env (str): Nome da variável de ambiente para a senha do RabbitMQ. Padrão é 'RABBIT_PASS'.
+            uri_env (str): Nome da variável de ambiente para a URL do RabbitMQ. Padrão é 'RABBIT_URI'.
+            queue_env (str): Nome da variável de ambiente para a fila de consumo do RabbitMQ. Padrão é 'RABBIT_QUEUE'.
+            prefetch_env (str): Nome da variável de ambiente para o prefetch count. Padrão é 'RABBIT_PREFETCH'.
+            vhost_env (str): Nome da variável de ambiente para o host virtual do RabbitMQ. Padrão é 'RABBIT_VHOST'.
+
+        Raises:
+            ValueError: Se qualquer uma das variáveis de ambiente necessárias não estiver definida.
+
+        Returns:
+            RabbitMessageConsumer: Uma instância configurada do RabbitMessageConsumer.
+        """
+        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, '/')
+
+        if not username or not password or not url or not queue:
+            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,
+        )
+
+    def start_consume(self, process_message: Callable) -> None:
+        """
+        Inicia o consumo de mensagens da fila RabbitMQ e processa cada mensagem usando a função fornecida.
+
+        Args:
+            process_message (Callable): Função de callback que processa cada mensagem recebida.
+
+        Raises:
+            pika.exceptions.StreamLostError: Se a conexão com o RabbitMQ for perdida, tentará reconectar automaticamente.
+        """
+        try:
             connection = pika.BlockingConnection(
                 pika.ConnectionParameters(
                     host=self.__amqp_url,
@@ -50,7 +125,17 @@ class RabbitMessageConsumer(MessageConsumer):
             debug(e)
             self.start_consume(process_message)
 
-    def on_request(self, ch, method, props, body, process_message):
+    def on_request(self, ch, method, props, body, process_message) -> None:
+        """
+        Processa uma mensagem recebida e publica a resposta de volta na fila especificada.
+
+        Args:
+            ch: Canal do RabbitMQ.
+            method: Método de entrega do RabbitMQ.
+            props: Propriedades da mensagem do RabbitMQ.
+            body: Corpo da mensagem recebida.
+            process_message (Callable): Função que processa a mensagem e retorna uma resposta.
+        """
         message = body.decode()
         message_json = json.loads(message)
         pure_message = self.__transform_message(message_json)
@@ -67,6 +152,15 @@ class RabbitMessageConsumer(MessageConsumer):
         ch.basic_ack(delivery_tag=method.delivery_tag)
 
     def __transform_message(self, message: dict) -> Message:
+        """
+        Transforma o dicionário JSON recebido em uma instância de Message.
+
+        Args:
+            message (dict): Dicionário contendo os dados da mensagem.
+
+        Returns:
+            Message: Uma instância da classe Message com os dados extraídos do dicionário.
+        """
         return Message(
             type=message.get('type', ''),
             text=message.get('text', ''),

chatgraph/types/message_types.py

@@ -4,6 +4,18 @@ from typing import Optional
 
 @dataclass
 class Message:
+    """
+    Representa uma mensagem recebida ou enviada pelo chatbot.
+
+    Atributos:
+        type (str): O tipo da mensagem (por exemplo, texto, imagem, etc.).
+        text (str): O conteúdo textual da mensagem.
+        customer_id (str): O ID do cliente que enviou ou recebeu a mensagem.
+        channel (str): O canal pelo qual a mensagem foi enviada ou recebida (por exemplo, WhatsApp, SMS, etc.).
+        customer_phone (str): O número de telefone do cliente.
+        company_phone (str): O número de telefone da empresa que está enviando ou recebendo a mensagem.
+        status (Optional[str]): O status da mensagem (por exemplo, enviada, recebida, lida, etc.). Este campo é opcional.
+    """
     type: str
     text: str
     customer_id: str

chatgraph/types/output_state.py

@@ -4,12 +4,39 @@ messageTypes = Union[str, float, int, None]
 
 
 class ChatbotResponse:
-    def __init__(
-        self, message: messageTypes = None, route: str = None
-    ) -> None:
+    """
+    Representa a resposta do chatbot, contendo a mensagem a ser enviada ao usuário e a rota a ser seguida.
+
+    Atributos:
+        message (messageTypes): A mensagem de resposta do chatbot. Pode ser uma string, um número, ou None.
+        route (str, opcional): A rota para a qual o chatbot deve direcionar após esta mensagem. Padrão é None.
+    """
+
+    def __init__(self, message: messageTypes = None, route: str = None) -> None:
+        """
+        Inicializa a resposta do chatbot com uma mensagem e uma rota opcional.
+
+        Args:
+            message (messageTypes, opcional): A mensagem a ser enviada ao usuário. Pode ser uma string, um número, ou None.
+            route (str, opcional): A rota para a qual o chatbot deve direcionar após esta mensagem. Padrão é None.
+        """
         self.message = message
         self.route = route
 
+
 class RedirectResponse:
+    """
+    Representa uma resposta que redireciona o fluxo do chatbot para uma nova rota.
+
+    Atributos:
+        route (str): A rota para a qual o chatbot deve redirecionar.
+    """
+
     def __init__(self, route: str) -> None:
-        self.route = route
+        """
+        Inicializa a resposta de redirecionamento com a rota especificada.
+
+        Args:
+            route (str): A rota para a qual o chatbot deve redirecionar.
+        """
+        self.route = route

chatgraph/types/route.py

@@ -2,13 +2,34 @@ from ..error.route_error import RouteError
 
 
 class Route:
+    """
+    Representa uma rota no sistema do chatbot, gerenciando a navegação entre diferentes partes do fluxo.
+
+    Atributos:
+        current (str): A rota atual.
+        routes (list[str]): A lista de todas as rotas disponíveis no fluxo.
+    """
+
     def __init__(self, current: str, routes: list[str]):
+        """
+        Inicializa a rota com a rota atual e a lista de rotas disponíveis.
+
+        Args:
+            current (str): A rota atual.
+            routes (list[str]): A lista de todas as rotas disponíveis no fluxo.
+        """
         self.current = current
         self.routes = routes
 
     def get_previous(self) -> str:
         """
         Retorna o caminho anterior ao caminho atual.
+
+        Raises:
+            RouteError: Se a rota atual for 'START', indicando que não há caminho anterior.
+
+        Returns:
+            str: O caminho anterior à rota atual.
         """
         if self.current == 'START':
             raise RouteError('Não há caminho anterior ao START')
@@ -19,6 +40,15 @@ class Route:
     def get_next(self, next_part: str) -> str:
         """
         Monta e retorna o próximo caminho com base na parte fornecida.
+
+        Args:
+            next_part (str): A parte do caminho a ser adicionada à rota atual.
+
+        Raises:
+            RouteError: Se a próxima rota montada não estiver na lista de rotas disponíveis.
+
+        Returns:
+            str: O próximo caminho construído a partir da rota atual e da parte fornecida.
         """
         next_part = next_part.strip().upper()
         next_route = f"{self.current.rstrip('/')}{next_part}"
@@ -27,7 +57,19 @@ class Route:
         return next_route
 
     def __str__(self):
+        """
+        Retorna uma representação em string da rota atual.
+
+        Returns:
+            str: A representação em string da rota atual.
+        """
         return f'Route(current={self.current})'
 
     def __repr__(self):
+        """
+        Retorna a representação oficial da rota, que é a mesma que a representação em string.
+
+        Returns:
+            str: A representação oficial da rota.
+        """
         return self.__str__()

chatgraph/types/user_state.py

@@ -2,25 +2,73 @@ from abc import ABC, abstractmethod
 
 
 class UserState(ABC):
+    """
+    Classe abstrata para gerenciar o estado do usuário no fluxo do chatbot.
+
+    Esta classe define a interface para implementar o gerenciamento de estado do usuário, incluindo métodos para obter e definir o menu atual do usuário.
+    """
+
     @abstractmethod
-    def get_menu(self, customer_id: str):
+    def get_menu(self, customer_id: str) -> str:
+        """
+        Retorna o menu atual para o ID de cliente fornecido.
+
+        Args:
+            customer_id (str): O ID do cliente.
+
+        Returns:
+            str: O menu atual associado ao cliente.
+        """
         pass
 
     @abstractmethod
-    def set_menu(self, customer_id: str, menu: str):
+    def set_menu(self, customer_id: str, menu: str) -> None:
+        """
+        Define o menu atual para o ID de cliente fornecido.
+
+        Args:
+            customer_id (str): O ID do cliente.
+            menu (str): O menu a ser definido para o cliente.
+        """
         pass
 
 
 class SimpleUserState(UserState):
+    """
+    Implementação simples de UserState que armazena o estado do usuário em um dicionário em memória.
+
+    Atributos:
+        states (dict): Dicionário que armazena o estado de menu atual para cada cliente.
+    """
+
     def __init__(self):
+        """
+        Inicializa o estado do usuário com um dicionário vazio.
+        """
         self.states = {}
 
     def get_menu(self, customer_id: str) -> str:
+        """
+        Retorna o menu atual para o ID de cliente fornecido. Se o cliente não tiver um menu definido, define 'START' como padrão.
+
+        Args:
+            customer_id (str): O ID do cliente.
+
+        Returns:
+            str: O menu atual associado ao cliente.
+        """
         menu = self.states.get(customer_id, 'START')
         if menu == 'START':
             self.set_menu(customer_id, menu)
         return menu
 
-    def set_menu(self, customer_id: str, menu: str|None=None) -> str:
+    def set_menu(self, customer_id: str, menu: str | None = None) -> None:
+        """
+        Define o menu atual para o ID de cliente fornecido. Converte o nome do menu para maiúsculas.
+
+        Args:
+            customer_id (str): O ID do cliente.
+            menu (str | None): O menu a ser definido para o cliente. Se None, não faz nenhuma alteração.
+        """
         if menu:
             self.states[customer_id] = menu.upper()

chatgraph-0.1.1.dist-info/METADATA

@@ -0,0 +1,142 @@
+Metadata-Version: 2.1
+Name: chatgraph
+Version: 0.1.1
+Summary: A user-friendly chatbot library
+Home-page: https://github.com/irissonnlima/chatgraph
+License: MIT
+Keywords: chatbot,rabbitmq,messaging,routing,chatgraph,python
+Author: Irisson N. Lima
+Author-email: irisson.lima@verdecard.com.br
+Requires-Python: >=3.12,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: pika (>=1.3.2,<2.0.0)
+Project-URL: Repository, https://github.com/irissonnlima/chatgraph
+Description-Content-Type: text/markdown
+
+# ChatGraph
+
+**ChatGraph** é uma biblioteca Python projetada para facilitar a construção e gerenciamento de chatbots com roteamento flexível. 
+
+Ela oferece uma estrutura para definir rotas de chatbot, processar mensagens e gerenciar o estado do usuário de maneira eficiente.
+
+## Instalação
+
+Você pode instalar o ChatGraph diretamente do PyPI:
+
+```bash
+pip install chatgraph
+```
+
+Link do PyPI: [ChatGraph no PyPI](https://pypi.org/project/chatgraph/)
+
+## Estrutura da Biblioteca
+
+### 1. `ChatbotApp`
+
+A classe `ChatbotApp` é o núcleo da aplicação do chatbot. Ela gerencia as rotas definidas, processa as mensagens recebidas e lida com a lógica de navegação dentro do chatbot.
+
+- **Métodos principais:**
+  - `include_router`: Inclui um conjunto de rotas (definido por `ChatbotRouter`) na aplicação.
+  - `route`: Decorador para associar funções a rotas específicas.
+  - `start`: Inicia o consumo de mensagens do RabbitMQ.
+  - `process_message`: Processa a mensagem recebida e executa a função correspondente à rota atual do usuário.
+
+### 2. `ChatbotRouter`
+
+A classe `ChatbotRouter` permite definir e agrupar rotas que podem ser facilmente incluídas na aplicação principal do chatbot.
+
+- **Métodos principais:**
+  - `route`: Decorador para adicionar uma função como uma rota no roteador.
+  - `include_router`: Inclui outro roteador dentro do roteador atual, permitindo a construção modular das rotas.
+
+### 3. `MessageConsumer` e `RabbitMessageConsumer`
+
+A classe abstrata `MessageConsumer` define a interface para consumidores de mensagens no sistema do chatbot. A implementação concreta `RabbitMessageConsumer` consome mensagens de uma fila RabbitMQ, processa essas mensagens e envia respostas de acordo.
+
+- **Métodos principais:**
+  - `start_consume`: Inicia o consumo de mensagens do RabbitMQ.
+  - `on_request`: Processa uma mensagem recebida e envia a resposta correspondente.
+  - `load_dotenv`: Carrega as configurações do RabbitMQ a partir de variáveis de ambiente.
+
+### 4. `UserState` e `SimpleUserState`
+
+A classe abstrata `UserState` define a interface para o gerenciamento do estado do usuário. A implementação `SimpleUserState` usa um dicionário em memória para armazenar o estado atual do menu para cada usuário.
+
+- **Métodos principais:**
+  - `get_menu`: Retorna o menu atual associado a um ID de cliente.
+  - `set_menu`: Define o menu atual para um ID de cliente.
+
+### 5. `Message`
+
+A classe `Message` encapsula os dados de uma mensagem enviada ou recebida pelo chatbot.
+
+- **Atributos:**
+  - `type`: Tipo da mensagem (ex. texto, imagem).
+  - `text`: Conteúdo da mensagem.
+  - `customer_id`: ID do cliente que enviou ou recebeu a mensagem.
+  - `channel`: Canal de comunicação utilizado (ex. WhatsApp, SMS).
+  - `customer_phone`: Número de telefone do cliente.
+  - `company_phone`: Número de telefone da empresa.
+  - `status`: Status da mensagem (opcional).
+
+### 6. `ChatbotResponse` e `RedirectResponse`
+
+Essas classes são usadas para definir a resposta do chatbot após o processamento de uma mensagem.
+
+- **`ChatbotResponse`**: Contém uma mensagem de resposta e uma rota opcional.
+- **`RedirectResponse`**: Define uma rota para a qual o chatbot deve redirecionar o fluxo.
+
+### 7. `Route` e `RouteError`
+
+A classe `Route` gerencia a navegação entre diferentes partes do fluxo do chatbot, permitindo obter a rota anterior e calcular a próxima rota com base na entrada do usuário.
+
+- **Métodos principais:**
+  - `get_previous`: Retorna o caminho anterior ao atual.
+  - `get_next`: Monta e retorna o próximo caminho com base em uma parte fornecida.
+
+A classe `RouteError` é uma exceção personalizada usada para indicar problemas relacionados à navegação nas rotas.
+
+## Exemplo de Uso
+
+Aqui está um exemplo básico de como configurar e utilizar o ChatGraph:
+
+```python
+from chatgraph import ChatbotApp, ChatbotRouter, SimpleUserState, RabbitMessageConsumer, ChatbotResponse
+
+# Definindo rotas com ChatbotRouter
+router = ChatbotRouter()
+
+@router.route("START")
+def say_hello():
+    return ChatbotResponse(message="Hello! How can I assist you today?", route="HELP")
+
+@router.route("/HELP")
+def provide_help():
+    return ChatbotResponse(message="Here are some things I can help with: ...")
+
+# Configurando a aplicação do chatbot
+user_state = SimpleUserState()
+message_consumer = RabbitMessageConsumer.load_dotenv()
+
+app = ChatbotApp(user_state=user_state, message_consumer=message_consumer)
+app.include_router(router, prefix="")
+
+# Iniciando o chatbot
+app.start()
+```
+
+Neste exemplo, o chatbot responde "Hello! How can I assist you today?" quando a rota `HELLO` é acessada e depois direciona o usuário para a rota `HELP`.
+
+## Contribuição
+
+Se você encontrar bugs ou tiver sugestões de melhorias, sinta-se à vontade para abrir uma issue ou enviar um pull request no repositório do projeto.
+
+## Licença
+
+Este projeto está licenciado sob a licença MIT. Consulte o arquivo LICENSE para obter mais detalhes.
+
+---
+
+Com **ChatGraph**, você tem a flexibilidade e a simplicidade necessárias para construir chatbots poderosos e altamente configuráveis, integrados, por enquanto, com RabbitMQ para um processamento robusto de mensagens.

chatgraph-0.1.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+chatgraph/__init__.py,sha256=qPA9Vw2SZivqVUlB19D-YrRuequMThR6kgO2XsZcwDc,602
+chatgraph/auth/credentials.py,sha256=xsMEpLQnc66novPjL6upocMcnUnvFJ7yxINzUenkxmc,2388
+chatgraph/bot/chatbot_model.py,sha256=D2MGguq3Fnl9xiY0frpk_-DkTNgeBV57q5w3jx8Kba4,6296
+chatgraph/bot/chatbot_router.py,sha256=CQxu7ZiLBZDzXso65f4u3jfLA8BsuTAmp_tonFhFdc0,2817
+chatgraph/error/chatbot_error.py,sha256=4sEcW8vz0eQk2QDmDygucVM4caHliZW5iH7XJvmLBuk,1897
+chatgraph/error/route_error.py,sha256=CY8m82ap7-Sr-DXPsolltRW50TqD__5RyXBmNNJCWr8,793
+chatgraph/messages/base_message_consumer.py,sha256=OSdTT4dHIzawLDOCZ-4hZ06T8UBxoJIosqvXl7gxpM0,1099
+chatgraph/messages/rabbitMQ_message_consumer.py,sha256=mRcJ1Hbd5wPFxC3v6Tj3pYvjd9yAc398Ys6cUox-CTY,7005
+chatgraph/types/message_types.py,sha256=NBuebmpO2e9ilspBoFgs9O3rY_VQ2AP_Z8Q_nC70nyM,965
+chatgraph/types/output_state.py,sha256=ZditFyycd6CEvemrW9c7mThQDP1l6tI_8p19Jgj8pbs,1471
+chatgraph/types/route.py,sha256=iSeVDMsH_1Q1n1sAyeiqFdvg2KWIY8DFdGThswwpUBw,2422
+chatgraph/types/user_state.py,sha256=0n7K5k5DGoP3ug8XNPREqdJHGHXmcOwhPrANpXJSDjU,2321
+chatgraph-0.1.1.dist-info/LICENSE,sha256=rVJozpRzDlplOpvI8A1GvmfVS0ReYdZvMWc1j2jV0v8,1090
+chatgraph-0.1.1.dist-info/METADATA,sha256=yt3nbvNpQX-gCBzx8zP9Uz6ZDPfpCml2Dpd1Z8D8KuU,5828
+chatgraph-0.1.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+chatgraph-0.1.1.dist-info/RECORD,,

chatgraph/bot/chatbot_app.py

@@ -1,155 +0,0 @@
-import inspect
-import json
-from functools import wraps
-from logging import debug
-
-import pika
-import pika.exceptions
-
-from ..auth.credentials import Credential
-from ..error.chatbot_error import ChatbotError, ChatbotMessageError
-from ..types.message_types import Message
-from ..types.user_state import SimpleUserState, UserState
-from .chatbot_router import ChatbotRouter
-
-
-class ChatbotApp:
-    def __init__(
-        self,
-        amqp_url: str,
-        queue_consume: str,
-        credentials: Credential,
-        user_state: UserState,
-        prefetch_count: int = 1,
-        virtual_host: str = '/',
-    ):
-        self.__virtual_host = virtual_host
-        self.__prefetch_count = prefetch_count
-        self.__user_state = user_state
-        self.__queue_consume = queue_consume
-        self.__amqp_url = amqp_url
-        self.__credentials = pika.PlainCredentials(
-            credentials.username, credentials.password
-        )
-        self.__routes = {}
-
-    def include_router(self, router: ChatbotRouter, prefix: str):
-        if 'START' not in router.routes.keys():
-            raise ChatbotError('Erro ao incluir rota, START não encontrado!')
-
-        prefixed_routes = {
-            (
-                f'START{prefix.upper()}'
-                if key.upper() == 'START'
-                else f'START{prefix.upper()}{key.upper()}'
-            ): value
-            for key, value in router.routes.items()
-        }
-        self.__routes.update(prefixed_routes)
-
-    def route(self, state: str, default_message: str):
-        def decorator(func):
-            params = dict()
-            signature = inspect.signature(func)
-            output_param = signature.return_annotation
-
-            for name, param in signature.parameters.items():
-                param_type = (
-                    param.annotation
-                    if param.annotation != inspect.Parameter.empty
-                    else 'Any'
-                )
-                params[param_type] = name
-                debug(f'Parameter: {name}, Type: {param_type}')
-
-            if Message not in params.keys():
-                raise ChatbotError(
-                    'Função não recebe Message, parâmetro obrigatório!'
-                )
-
-            self.__routes[state.upper()] = {
-                'function': func,
-                'default_message': default_message,
-                'params': params,
-                'return': output_param,
-            }
-
-            @wraps(func)
-            def wrapper(*args, **kwargs):
-                return func(*args, **kwargs)
-
-            return wrapper
-
-        return decorator
-
-    def start(self):
-        try:  # Verificar se recursão não vai estourar
-            connection = pika.BlockingConnection(
-                pika.ConnectionParameters(
-                    host=self.__amqp_url,
-                    virtual_host=self.__virtual_host,
-                    credentials=self.__credentials,
-                )
-            )
-            channel = connection.channel()
-
-            channel.basic_qos(prefetch_count=self.__prefetch_count)
-            channel.basic_consume(
-                queue=self.__queue_consume,
-                on_message_callback=self.on_request,
-            )
-
-            debug('[x] Aguardando solicitações RPC')
-            channel.start_consuming()
-        except pika.exceptions.StreamLostError as e:
-            debug(e)
-            self.start()
-
-    def on_request(self, ch, method, props, body):
-        message = body.decode()
-        response = self.process_message(message)
-
-        ch.basic_publish(
-            exchange='',
-            routing_key=props.reply_to,
-            properties=pika.BasicProperties(
-                correlation_id=props.correlation_id
-            ),
-            body=str(response),
-        )
-        ch.basic_ack(delivery_tag=method.delivery_tag)
-
-    def process_message(self, message: str):
-        data = json.loads(message)
-        message_imported = self.__transform_message(data)
-
-        customer_id = message_imported.customer_id
-
-        menu = self.__user_state.get_menu(customer_id)
-        handler = self.__routes.get(menu, None)
-
-        if not handler:
-            raise ChatbotMessageError(
-                customer_id, f'Rota não encontrada para {menu}!'
-            )
-        func = handler['function']
-        message_name = handler['params'].get(Message)
-        user_state_name = handler['params'].get(UserState, None)
-
-        kwargs = {message_name: message_imported}
-        if user_state_name:
-            kwargs[user_state_name] = SimpleUserState(
-                menu, list(self.__routes.keys())
-            )
-        return func(**kwargs)
-
-    def __transform_message(self, message: dict) -> Message:
-        return Message(
-            type=message.get('type', ''),
-            text=message.get('text', ''),
-            customer_id=message.get('customer_id', ''),
-            channel=message.get('channel', ''),
-            customer_phone=message.get('customer_phone', ''),
-            company_phone=message.get('company_phone', ''),
-            status=message.get('status'),
-        )

chatgraph/messages/__init__.py

@@ -1,5 +0,0 @@
-from .base_message_consumer import MessageConsumer
-
-__all__ = [
-    'MessageConsumer',
-]

chatgraph-0.1.0.dist-info/METADATA

@@ -1,15 +0,0 @@
-Metadata-Version: 2.1
-Name: chatgraph
-Version: 0.1.0
-Summary: A user-friendly chatbot library
-Author: Irisson N. Lima
-Author-email: irisson.lima@verdecard.com.br
-Requires-Python: >=3.12,<4.0
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: pika (>=1.3.2,<2.0.0)
-Description-Content-Type: text/markdown
-
-# chatgraph
-ChatGraph is a user-friendly chatbot library that offers seamless integration with RabbitMQ. It is designed to simplify the development process by providing intuitive interfaces and robust messaging capabilities, making it easy to build and deploy chatbots leveraging RabbitMQ's powerful messaging infrastructure.
-

chatgraph-0.1.0.dist-info/RECORD

@@ -1,18 +0,0 @@
-chatgraph/__init__.py,sha256=qPA9Vw2SZivqVUlB19D-YrRuequMThR6kgO2XsZcwDc,602
-chatgraph/auth/credentials.py,sha256=tc8FvjWu-cFdx9ChzxkSDXX04g3eSPE6FcsRW0xg40k,917
-chatgraph/bot/chatbot_app.py,sha256=Uix25rT8gCoCKYziSW0WrBsQzs4DU_L0GSHwdgu4et0,5263
-chatgraph/bot/chatbot_model.py,sha256=QqnCZvEOfp--zn-mnEXL3p5pqxPN_ztnhXdfNEeDnHk,4102
-chatgraph/bot/chatbot_router.py,sha256=48AiRaXtlCtad2imuUA-uK_ppxUwa6GEkPv8YXTB29g,1836
-chatgraph/error/chatbot_error.py,sha256=rTBPDPB2CNoZDKfL5PgWtj36jdoepe_gO6Opb5kd3mA,545
-chatgraph/error/route_error.py,sha256=jEi621zHJbB3LnwvbtP_o9u0AkoddrHoGo1OKAPLMWk,213
-chatgraph/messages/__init__.py,sha256=lKpQI7FXjSJuwcV9ItX6ZJditEm6kQpGSPoTuOtMHy4,94
-chatgraph/messages/base_message_consumer.py,sha256=hpoLLqxk5mQXRnS3s_lkOPosgwfMmvxAOftkt8P0Qvc,203
-chatgraph/messages/rabbitMQ_message_consumer.py,sha256=z4RQ21N1aUwx9OOrkQRd04fSTHfw3uzPsOlKyLGKO5c,2753
-chatgraph/types/message_types.py,sha256=pTUIGOiNdoYg7i8zNXRdGSg4z86bJZWjYbn3cII0eI0,249
-chatgraph/types/output_state.py,sha256=cBdZXnsyEVwmxno5De_vHUwh9cPokPvFpeiLM_3VkZQ,357
-chatgraph/types/route.py,sha256=818fovzJZyjPl27ZAvCZpZNUCccyO_6ciyLJxOHI1JI,1034
-chatgraph/types/user_state.py,sha256=3kAyAUue7KTi-Rvf-cYDzX3L-PMa4POmRFgAUvS9fTo,669
-chatgraph-0.1.0.dist-info/LICENSE,sha256=rVJozpRzDlplOpvI8A1GvmfVS0ReYdZvMWc1j2jV0v8,1090
-chatgraph-0.1.0.dist-info/METADATA,sha256=VNDKsd2e0HPI_RN6tuFUEvKBKyeJgokmJujlqw5z74k,695
-chatgraph-0.1.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-chatgraph-0.1.0.dist-info/RECORD,,