chatgraph 0.6.4__py3-none-any.whl

chatgraph/__init__.py

@@ -0,0 +1,35 @@
+from .auth.credentials import Credential
+from .bot.chatbot_model import ChatbotApp
+from .bot.chatbot_router import ChatbotRouter
+from .messages.message_consumer import MessageConsumer
+from .models.userstate import UserState, Menu
+from .models.message import Message, Button, File, TextMessage
+from .types.usercall import UserCall
+from .types.end_types import (
+    RedirectResponse,
+    EndChatResponse,
+    TransferToHuman,
+    TransferToMenu,
+)
+from .types.route import Route
+from .types.background_task import BackgroundTask
+
+__all__ = [
+    "ChatbotApp",
+    "Credential",
+    "UserCall",
+    "ChatbotRouter",
+    "RedirectResponse",
+    "MessageConsumer",
+    "Route",
+    "EndChatResponse",
+    "TransferToHuman",
+    "TransferToMenu",
+    "UserState",
+    "Menu",
+    "Message",
+    "Button",
+    "File",
+    "TextMessage",
+    "BackgroundTask",
+]

chatgraph/auth/credentials.py

@@ -0,0 +1,71 @@
+import os
+
+
+class Credential:
+    """
+    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) -> 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) -> 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 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)
+
+        if not username or not password:
+            raise ValueError('Corrija as variáveis de ambiente!')
+
+        return cls(username=username, password=password)

chatgraph/bot/chatbot_model.py

@@ -0,0 +1,238 @@
+import asyncio
+import inspect
+import re
+from functools import wraps
+from logging import debug, error
+from typing import Optional, Callable
+
+from ..error.chatbot_error import ChatbotMessageError
+from ..messages.message_consumer import MessageConsumer
+from ..models.message import MessageTypes, Message, File
+from ..types.usercall import UserCall
+from ..types.end_types import (
+    RedirectResponse,
+    EndChatResponse,
+    TransferToMenu,
+)
+from ..types.route import Route
+from .chatbot_router import ChatbotRouter
+from ..types.background_task import BackgroundTask
+from .default_functions import voltar
+
+DEFAULT_FUNCTION: dict[str, Callable] = {
+    r'^\s*(voltar)\s*$': voltar,
+}
+
+
+class ChatbotApp:
+    """
+    Classe principal para a aplicação do chatbot, gerencia as rotas e a lógica de processamento de mensagens.
+    """
+
+    def __init__(
+        self,
+        message_consumer: Optional[MessageConsumer] = None,
+        default_functions: dict[str, Callable] = DEFAULT_FUNCTION,
+    ):
+        """
+        Inicializa a classe ChatbotApp com um estado de usuário e um consumidor de mensagens.
+
+        Args:
+            message_consumer (MessageConsumer): O consumidor de mensagens que lida com a entrada de mensagens no sistema.
+            default_functions (dict[str, callable]): Dicionário de funções padrão que podem ser usadas antes das rotas.
+        """
+        if not message_consumer:
+            message_consumer = MessageConsumer.load_dotenv()
+
+        self.default_functions = default_functions
+        self.__message_consumer = message_consumer
+        self.__routes = {}
+
+    def include_router(self, router: ChatbotRouter) -> None:
+        """
+        Inclui um roteador de chatbot com um prefixo nas rotas da aplicação.
+
+        Args:
+            router (ChatbotRouter): O roteador contendo as rotas a serem adicionadas.
+        """
+        self.__routes.update(router.routes)
+
+    def route(self, route_name: str) -> Callable:
+        """
+        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().lower()
+
+        def decorator(func):
+            params = {}
+            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}')
+
+            self.__routes[route_name] = {
+                'function': func,
+                'params': params,
+                'return': output_param,
+            }
+
+            @wraps(func)
+            async def wrapper(*args, **kwargs):
+                return await func(*args, **kwargs)
+
+            return wrapper
+
+        return decorator
+
+    def start(self):
+        """
+        Inicia o consumo de mensagens pelo chatbot,
+        processando cada mensagem recebida.
+        """
+        self.__message_consumer.reprer()
+        asyncio.run(
+            self.__message_consumer.start_consume(self.process_message)
+        )
+
+    async def process_message(self, usercall: UserCall) -> None:
+        """
+        Processa uma mensagem recebida, identificando a rota correspondente
+        e executando a função associada.
+
+        Args:
+            usercall (UserCall): A mensagem a ser processada.
+
+        Raises:
+            ChatbotMessageError: Se nenhuma rota for encontrada para
+            o menu atual do usuário.
+        """
+        user_id = usercall.user_id
+        route = usercall.route.lower()
+        route_handler = route.split('.')[-1]
+
+        matchDefault = False
+
+        for regex, func in self.default_functions.items():
+            if re.match(regex, usercall.content_message):
+                matchDefault = True
+                debug(
+                    f'Função padrão encontrada: {func.__name__} para a rota {route}'
+                )
+                handler = {
+                    'function': func,
+                    'params': {UserCall: 'usercall', Route: 'route'},
+                }
+                break
+
+        if not matchDefault:
+            handler = self.__routes.get(route_handler, None)
+
+        if not handler:
+            raise ChatbotMessageError(
+                user_id, f'Rota não encontrada para {route}!'
+            )
+
+        func = handler['function']
+        usercall_name = handler['params'].get(UserCall, None)
+        route_state_name = handler['params'].get(Route, None)
+
+        kwargs = {}
+        if usercall_name:
+            kwargs[usercall_name] = usercall
+        if route_state_name:
+            kwargs[route_state_name] = Route(route, list(self.__routes.keys()))
+
+        if asyncio.iscoroutinefunction(func):
+            usercall_response = await func(**kwargs)
+        else:
+            loop = asyncio.get_running_loop()
+            usercall_response = await loop.run_in_executor(
+                None, lambda: func(**kwargs)
+            )
+
+        if matchDefault:
+            usercall.content_message = ''
+
+        if isinstance(usercall_response, (list, tuple)):
+            for response in usercall_response:
+                await self.__process_func_response(
+                    response, usercall, route=route
+                )
+        else:
+            await self.__process_func_response(
+                usercall_response, usercall, route=route
+            )
+
+    async def __process_func_response(
+        self,
+        usercall_response,
+        usercall: UserCall,
+        route: str,
+    ) -> None:
+        """
+        Processa a resposta de uma função associada a uma rota,
+        enviando mensagens ou ajustando estados.
+
+        Args:
+            usercall_response:
+                A resposta gerada pela função da rota.
+            usercall (UserCall):
+                O objeto UserCall associado à mensagem processada.
+            route (str):
+                O nome da rota atual.
+        """
+        loop = asyncio.get_running_loop()
+
+        if isinstance(usercall_response, (MessageTypes, Message, File)):
+            # Envia o resultado como mensagem (executando a chamada síncrona no executor)
+            await usercall.send(usercall_response)
+            return
+
+        if isinstance(usercall_response, Route):
+            await usercall.set_route(usercall_response.current)
+            return
+
+        if isinstance(usercall_response, EndChatResponse):
+            await usercall.end_chat(
+                usercall_response.end_chat_id,
+                end_action_name=usercall_response.end_chat_name,
+            )
+            return
+
+        if isinstance(usercall_response, TransferToMenu):
+            await usercall.transfer_to_menu(
+                usercall_response.menu,
+                usercall_response.user_message,
+            )
+            return
+
+        if isinstance(usercall_response, RedirectResponse):
+            await usercall.set_route(usercall_response.route)
+            await self.process_message(usercall)
+            return
+
+        if not usercall_response:
+            route = route + '.' + route.split('.')[-1]
+            await usercall.set_route(route)
+            return
+
+        if isinstance(usercall_response, BackgroundTask):
+            response = await usercall_response.run()
+            await self.__process_func_response(response, usercall, route=route)
+            return
+
+        error('Tipo de retorno inválido!')
+        return None

chatgraph/bot/chatbot_router.py

@@ -0,0 +1,85 @@
+
+import inspect
+from functools import wraps
+from logging import debug
+
+from ..error.chatbot_error import ChatbotError
+
+
+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 = {}
+    
+    @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):
+        """
+        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.
+        """
+
+        route_name = route_name.strip().lower()
+
+        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}')
+
+            self.__routes[route_name] = {
+                'function': func,
+                'params': params,
+                'return': output_param,
+            }
+
+            @wraps(func)
+            def wrapper(*args, **kwargs):
+                return func(*args, **kwargs)
+
+            return wrapper
+
+        return decorator
+
+    def include_router(self, router: 'ChatbotRouter'):
+        """
+        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.
+        """
+        self.__routes.update(router.__routes)

chatgraph/bot/default_functions.py

@@ -0,0 +1,24 @@
+from ..types.usercall import UserCall
+from ..models.message import Message, Button
+from ..types.end_types import (
+    RedirectResponse,
+    EndChatResponse,
+    TransferToHuman,
+    TransferToMenu,
+)
+from ..types.route import Route
+
+
+async def voltar(route: Route, userCall: UserCall) -> RedirectResponse:
+    """
+    Função para voltar à rota anterior.
+    Args:
+        route (Route): A rota atual do chatbot.
+        usercall (UserCall): O objeto UserCall associado à chamada do usuário.
+    """
+
+    previous = route.get_previous()
+    userCall.console.print(
+        f"Voltando rota. ({route.current}) -> ({previous.current})", style="bold yellow"
+    )
+    return RedirectResponse(previous.current_node)

chatgraph/cli/__init__.py

@@ -0,0 +1,187 @@
+import typer
+from rich.console import Console
+from rich.table import Table
+from dotenv import load_dotenv
+from ..gRPC.gRPCCall import WhatsappServiceClient, UserStateServiceClient
+import os, re
+
+load_dotenv()
+app = typer.Typer()
+
+@app.command()
+def configs():
+    """Recupera os IDs necessários."""
+    console = Console()
+    
+    username = os.getenv('RABBIT_USER')
+    password = os.getenv('RABBIT_PASS')
+    url = os.getenv('RABBIT_URI')
+    queue = os.getenv('RABBIT_QUEUE')
+    prefetch = os.getenv('RABBIT_PREFETCH', 1)
+    vhost = os.getenv('RABBIT_VHOST', '/')
+    grpc = os.getenv('GRPC_URI')
+
+    
+    tableRabbit = Table(show_header=True, header_style="bold magenta", title="RabbitMQ Consumer")
+    tableRabbit.add_column("Atributo", justify="center", style="cyan", no_wrap=True)
+    tableRabbit.add_column("Valor", justify="center", style="magenta")
+
+    tableRabbit.add_row("Virtual Host", vhost)
+    tableRabbit.add_row("Prefetch Count", str(prefetch))
+    tableRabbit.add_row("Queue Consume", queue)
+    tableRabbit.add_row("AMQP URL", url)
+    tableRabbit.add_row("Username", username)
+    tableRabbit.add_row("Password", "******")
+    
+    
+    tableGRPC = Table(show_header=True, header_style="bold magenta", title="gRPC Consumer")
+    tableGRPC.add_column("Atributo", justify="center", style="cyan", no_wrap=True)
+    tableGRPC.add_column("Valor", justify="center", style="magenta")
+    
+    tableGRPC.add_row("URI", grpc)
+    
+    console.print(tableGRPC, justify="center")
+    console.print(tableRabbit, justify="center")
+
+@app.command()
+def campaigns(regex: str = typer.Option(None, "--regex", "-r", help="Filtro regex para campanhas.")):
+    """Recupera as campanhas cadastradas."""
+    grpc = os.getenv('GRPC_URI')
+    
+    wwp = WhatsappServiceClient(grpc)
+    campaigns = wwp.get_all_campaigns()
+    
+    console = Console()
+    tableGRPC = Table(show_header=True, header_style="bold magenta", title="Campaigns")
+    tableGRPC.add_column("campaign_id", justify="center", style="cyan", no_wrap=True)
+    tableGRPC.add_column("campaign_name", justify="center", style="magenta")
+    tableGRPC.add_column("last_update", justify="center", style="magenta")
+    
+    # Aplicar filtro de regex, se fornecido
+    filtered_campaigns = campaigns.campaigns
+    if regex:
+        pattern = re.compile(regex, re.IGNORECASE)
+        filtered_campaigns = [
+            campaign for campaign in campaigns.campaigns
+            if pattern.search(campaign.campaign_name)
+        ]
+    
+    for campaign in filtered_campaigns:
+        tableGRPC.add_row(campaign.campaign_id, campaign.campaign_name, campaign.last_update)
+    
+    console.print(tableGRPC, justify="center")
+    
+@app.command()
+def tabulations(
+    regex: str = typer.Option(None, "--regex", "-r", help="Filtro regex para as tabulações.")
+):
+    """Recupera as tabulações cadastradas."""
+    grpc = os.getenv('GRPC_URI')
+    
+    wwp = WhatsappServiceClient(grpc)
+    tabulations = wwp.get_all_tabulations()
+    
+    console = Console()
+    tableGRPC = Table(show_header=True, header_style="bold magenta", title="Tabulations")
+    tableGRPC.add_column("tabulation_id", justify="center", style="cyan", no_wrap=True)
+    tableGRPC.add_column("tabulation_name", justify="center", style="magenta")
+    tableGRPC.add_column("tabulation_type", justify="center", style="magenta")
+    tableGRPC.add_column("group_name", justify="center", style="magenta")
+    tableGRPC.add_column("customer_service_survey_id", justify="center", style="magenta")
+    tableGRPC.add_column("last_update", justify="center", style="magenta")
+    
+    # Aplicar filtro de regex, se fornecido
+    filtered_tabulations = tabulations.tabulations
+    if regex:
+        pattern = re.compile(regex, re.IGNORECASE)
+        filtered_tabulations = [
+            tabulation for tabulation in tabulations.tabulations
+            if (
+                pattern.search(tabulation.tabulation_id) or
+                pattern.search(tabulation.tabulation_name) or
+                pattern.search(tabulation.tabulation_type) or
+                pattern.search(tabulation.group_name) or
+                (tabulation.customer_service_survey_id and pattern.search(tabulation.customer_service_survey_id)) or
+                pattern.search(tabulation.last_update)
+            )
+        ]
+    
+    for tabulation in filtered_tabulations:
+        tableGRPC.add_row(
+            tabulation.tabulation_id,
+            tabulation.tabulation_name,
+            tabulation.tabulation_type,
+            tabulation.group_name,
+            tabulation.customer_service_survey_id or "N/A",
+            tabulation.last_update,
+        )
+    
+    console.print(tableGRPC, justify="center")
+
+
+@app.command("ustate")
+def user_state(
+    regex: str = typer.Option(None, "--regex", "-r", help="Filtro regex para os estados do usuário.")
+):
+    """Recupera os UserState em operação no momento."""
+    grpc = os.getenv('GRPC_URI')
+    
+    ustate = UserStateServiceClient(grpc)
+    userstates = ustate.get_all_user_states()
+    
+    console = Console()
+    tableGRPC = Table(show_header=True, header_style="bold magenta", title="User States")
+    tableGRPC.add_column("user_id", justify="center", style="cyan", no_wrap=True)
+    tableGRPC.add_column("menu_id", justify="center", style="magenta")
+    tableGRPC.add_column("route", justify="center", style="magenta")
+    tableGRPC.add_column("obs", justify="center", style="magenta")
+    tableGRPC.add_column("date", justify="center", style="magenta")
+    tableGRPC.add_column("direction", justify="center", style="magenta")
+    
+    # Aplicar filtro de regex, se fornecido
+    filtered_user_states = userstates.user_states
+    if regex:
+        pattern = re.compile(regex, re.IGNORECASE)
+        filtered_user_states = [
+            userstate for userstate in userstates.user_states
+            if (
+                pattern.search(userstate.user_id) or
+                pattern.search(userstate.menu_id) or
+                pattern.search(userstate.route) or
+                pattern.search(userstate.obs) or
+                pattern.search(userstate.date) or
+                pattern.search(str(userstate.direction))
+            )
+        ]
+    
+    for userstate in filtered_user_states:
+        tableGRPC.add_row(
+            userstate.user_id,
+            userstate.menu_id,
+            userstate.route,
+            userstate.obs,
+            userstate.date,
+            str(userstate.direction),
+        )
+    
+    console.print(tableGRPC, justify="center")
+
+@app.command("del-ustate")
+def delete_user_state(user_id: str = typer.Argument(..., help="ID do UserState a ser deletado.")):
+    """Deleta um UserState em operação no momento."""
+    grpc = os.getenv('GRPC_URI')
+    
+    ustate = UserStateServiceClient(grpc)
+    
+    # Chama o método para deletar o UserState usando o ID fornecido
+    try:
+        success = ustate.delete_user_state(user_id)
+        if success:
+            typer.echo(f"UserState com ID '{user_id}' deletado com sucesso.")
+        else:
+            typer.echo(f"Falha ao deletar UserState com ID '{user_id}'.", err=True)
+    except Exception as e:
+        typer.echo(f"Erro ao tentar deletar UserState: {e}", err=True)
+    
+def main():
+    app()

chatgraph/error/chatbot_error.py

@@ -0,0 +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):
+        """
+        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}'