chatgraph 0.4.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

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/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
@@ -88,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):
         """
@@ -105,16 +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
+        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']
@@ -138,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

chatgraph/gRPC/gRPCCall.py

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

chatgraph/messages/message_consumer.py

@@ -1,27 +1,18 @@
 import json
+import asyncio
 from logging import debug, info
 import os
-import pika
+import aio_pika
 from typing import Callable
 from ..auth.credentials import Credential
-from ..types.request_types import UserCall, UserState
+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:
-    """
-    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,
@@ -29,65 +20,36 @@ class MessageConsumer:
         grpc_uri: str,
         queue_consume: str,
         prefetch_count: int = 1,
-        virtual_host: str = '/',
+        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.__grpc_uri = grpc_uri
-        self.__credentials = pika.PlainCredentials(
-            credential.username, credential.password
-        )
+        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':
-        """
-        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.
-        """
+        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, '/')
+        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!')
+            raise ValueError("Corrija as variáveis de ambiente!")
 
         return cls(
             credential=Credential(username=username, password=password),
@@ -98,105 +60,80 @@ class MessageConsumer:
             grpc_uri=grpc,
         )
 
-    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.
-        """
+    async def start_consume(self, process_message: Callable):
         try:
-            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=lambda c, m, p, b: self.on_request(
-                    c, m, p, b, process_message
-                ),
-            )
-
-            info('[x] Server inicializado! Aguardando solicitações RPC')
-            channel.start_consuming()
-        except pika.exceptions.StreamLostError as e:
-            debug(e)
-            self.start_consume(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)
-        process_message(pure_message)
-
-        ch.basic_ack(delivery_tag=method.delivery_tag)
+            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:
-        """
-        Transforma o dicionário JSON recebido em uma instância de Message.
-
-        Args:
-            message (dict): Dicionário contendo os dados da mensagem.
+        user_state = message.get("user_state", {})
+        observation = user_state.get("observation", {})
+        if isinstance(observation, str):
+            observation = json.loads(observation)
 
-        Returns:
-            Message: Uma instância da classe Message com os dados extraídos do dicionário.
-        """
-        
-        user_state = message.get('user_state', {})
-        obs = user_state.get('obs', {})
-        if isinstance(obs, str):
-            obs = json.loads(obs)
-            
-        return UserCall(
-            type=message.get('type', ''),
-            text=message.get('text', ''),
+        usercall = UserCall(
             user_state=UserState(
-                customer_id=user_state.get('customer_id', ''),
-                menu=user_state.get('menu', ''),
-                route=user_state.get('route', ''),
-                lst_update=user_state.get('lst_update', ''),
-                direction_in=user_state.get('direction_in', ''),
-                voll_id=user_state.get('voll_id', ''),
-                platform=user_state.get('platform', ''),
-                obs=obs,
+                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,
             ),
-            channel=message.get('channel', ''),
-            customer_phone=message.get('customer_phone', ''),
-            company_phone=message.get('company_phone', ''),
-            status=message.get('status'),
+            type_message=message.get("type_message", ""),
+            content_message=message.get("content_message", ""),
             grpc_uri=self.__grpc_uri,
         )
+        
+        return usercall
 
     def reprer(self):
         console = Console()
 
-        # Título "ChatGraph" destacado em vermelho e negrito dentro de um painel
         title_text = Text("ChatGraph", style="bold red", justify="center")
         title_panel = Panel.fit(title_text, title=" ", border_style="bold red", padding=(1, 4))
 
-        # Linha separadora com emojis
         separator = Text("🐇🐇🐇 RabbitMessageConsumer 📨📨📨", style="cyan", justify="center")
 
-        # Criação da tabela com os atributos
         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")
@@ -206,9 +143,8 @@ class MessageConsumer:
         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", "******")  # Oculta a senha
+        table.add_row("Password", "******")
 
-        # Imprime o título, separador e a tabela centralizada
         console.print(title_panel, justify="center")
         console.print(separator, justify="center")
         console.print(table, justify="center")