chatgraph 0.6.4__py3-none-any.whl

chatgraph/services/router_http_client.py

@@ -0,0 +1,451 @@
+from typing import Any, Dict, Optional
+
+import httpx
+
+from ..models.userstate import UserState, ChatID
+from ..models.message import Message, File
+from ..models.actions import EndAction
+
+
+class RouterHTTPClient:
+    """
+    Cliente HTTP para serviços de roteamento de mensagens.
+
+    Utiliza httpx.AsyncClient para comunicação assíncrona com o backend
+    do sistema de chatbot, incluindo envio de mensagens, gerenciamento
+    de estado e transferências de chat.
+    """
+
+    def __init__(
+        self,
+        base_url: str,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+        timeout: float = 30.0,
+    ):
+        """
+        Inicializa o cliente HTTP.
+
+        Args:
+            base_url: URL base da API (ex: "https://api.example.com")
+            username: Nome de usuário para autenticação (opcional)
+            password: Senha para autenticação (opcional)
+            timeout: Timeout para requisições em segundos (padrão: 30.0)
+        """
+        self.base_url = base_url.rstrip('/')
+        self.timeout = timeout
+
+        # Configurar autenticação básica se fornecida
+        auth = None
+        if username and password:
+            auth = httpx.BasicAuth(username, password)
+
+        # Criar cliente assíncrono
+        self._client = httpx.AsyncClient(
+            base_url=self.base_url,
+            auth=auth,
+            timeout=httpx.Timeout(timeout),
+            headers={
+                'Accept': 'application/json',
+                # 'Content-Type': 'application/json',
+            },
+            verify=False,
+            trust_env=True,
+            follow_redirects=True,
+        )
+
+    async def close(self):
+        """Fecha a conexão do cliente HTTP."""
+        await self._client.aclose()
+
+    async def __aenter__(self):
+        """Context manager entry."""
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit."""
+        await self.close()
+
+    # Sessions Methods
+    async def get_all_sessions(self) -> list[UserState]:
+        """
+        Obtém todas as sessões ativas.
+
+        Returns:
+            Lista de UserState com todas as sessões ativas.
+
+        Raises:
+            Exception: Se houver erro na comunicação.
+        """
+        endpoint = '/session/'
+
+        response = await self._client.get(endpoint)
+        response.raise_for_status()
+        response_data = response.json()
+        status = response_data.get('status')
+        message = response_data.get('message')
+        sessions_data = response_data.get('data', [])
+
+        if not status:
+            raise Exception(f'Erro ao buscar as Sessões: {message}')
+
+        sessions = [UserState.from_dict(item) for item in sessions_data]
+        return sessions
+
+    async def get_session_by_chat_id(
+        self,
+        chat_id: ChatID,
+    ) -> Optional[UserState]:
+        endpoint = '/session/'
+        params = {
+            'user_id': chat_id.user_id,
+            'company_id': chat_id.company_id,
+        }
+
+        response = await self._client.get(endpoint, params=params)
+        response.raise_for_status()
+        response_data = response.json()
+        status = response_data.get('status')
+        message = response_data.get('message')
+        session_data = response_data.get('data')
+
+        if not status:
+            raise Exception(f'Erro ao buscar a Sessão: {message}')
+
+        return UserState.from_dict(session_data)
+
+    async def start_session(self, user_state: UserState) -> Any:
+        """
+        Inicia uma nova sessão de chat.
+
+        Args:
+            user_state: Estado inicial do usuário.
+
+        Returns:
+            Objeto de resposta com atributo 'status' indicando sucesso/falha.
+
+        Raises:
+            Exception: Se houver erro na comunicação.
+        """
+        endpoint = '/session/start/'
+
+        response = await self._client.post(
+            endpoint,
+            json=user_state.to_dict(),
+        )
+        response.raise_for_status()
+        response_data = response.json()
+        status = response_data.get('status')
+        message = response_data.get('message')
+
+        if not status:
+            raise Exception(f'Erro ao iniciar sessão: {message}')
+
+        return response_data
+
+    async def set_session_route(self, chat_id: ChatID, route: str) -> Any:
+        """
+        Atualiza a rota da sessão de chat.
+
+        Args:
+            chat_id: Identificador do chat.
+            route: Nova rota para a sessão.
+
+        Returns:
+            Objeto de resposta com atributo 'status' indicando sucesso/falha.
+
+        Raises:
+            Exception: Se houver erro na comunicação.
+        """
+        endpoint = '/session/route/'
+
+        payload = {
+            'chat_id': chat_id.to_dict(),
+            'route': route,
+        }
+
+        response = await self._client.post(
+            endpoint,
+            json=payload,
+        )
+        response.raise_for_status()
+        response_data = response.json()
+        status = response_data.get('status')
+        message = response_data.get('message')
+
+        if not status:
+            raise Exception(f'Erro ao atualizar rota da sessão: {message}')
+
+        return response_data
+
+    async def update_session_observation(
+        self,
+        chat_id: ChatID,
+        observation: str,
+    ) -> Any:
+        """
+        Atualiza a observação da sessão de chat.
+
+        Args:
+            chat_id: Identificador do chat.
+            observation: Nova observação para a sessão.
+
+        Returns:
+            Objeto de resposta com atributo 'status' indicando sucesso/falha.
+
+        Raises:
+            Exception: Se houver erro na comunicação.
+        """
+        endpoint = '/session/observation/'
+
+        payload = {
+            'chat_id': chat_id.to_dict(),
+            'observation': observation,
+        }
+
+        response = await self._client.post(
+            endpoint,
+            json=payload,
+        )
+        response.raise_for_status()
+        response_data = response.json()
+        status = response_data.get('status')
+        message = response_data.get('message')
+
+        if not status:
+            raise Exception(
+                f'Erro ao atualizar observação da sessão: {message}'
+            )
+
+        return response_data
+
+    # Messages Methods
+    async def send_message(
+        self,
+        message_data: Message,
+        user_state: UserState,
+    ) -> Any:
+        """
+        Envia uma mensagem de texto ao usuário.
+
+        Args:
+            message_data: Dicionário contendo os dados da mensagem:
+                - chat_id: ID do chat (user_id, company_id)
+                - type: Tipo da mensagem
+                - detail: Conteúdo da mensagem
+
+        Returns:
+            Objeto de resposta com atributo 'status' indicando sucesso/falha.
+
+        Raises:
+            Exception: Se houver erro na comunicação.
+        """
+        endpoint = '/messages/send/'
+
+        payload = {
+            'message': message_data.to_dict(),
+            'user_state': user_state.to_dict(),
+        }
+        response = await self._client.post(
+            endpoint,
+            json=payload,
+        )
+        response.raise_for_status()
+        response_data = response.json()
+        status = response_data.get('status')
+        message = response_data.get('message')
+
+        if not status:
+            raise Exception(f'Erro ao enviar mensagem: {message}')
+
+        return response_data
+
+    # Files Methods
+    async def get_file(self, file_id: str) -> File:
+        """
+        Obtém um arquivo (imagem) pelo ID.
+
+        Args:
+            file_id: ID único do arquivo.
+
+        Returns:
+            Objeto de resposta com atributos 'status' e 'file_content'.
+
+        Raises:
+            Exception: Se houver erro na comunicação.
+        """
+        endpoint = f'/files/{file_id}/'
+
+        response = await self._client.get(endpoint)
+        response.raise_for_status()
+        response_data = response.json()
+        status = response_data.get('status')
+        message = response_data.get('message')
+        file_data = response_data.get('data')
+
+        if not status:
+            raise Exception(f'Erro ao buscar arquivo: {message}')
+
+        return File.from_dict(file_data)
+
+    async def upload_file(self, file_data: bytes) -> File:
+        """
+        Faz upload de um arquivo (imagem) para o servidor.
+
+        Args:
+            file_data: Dicionário contendo os dados do arquivo:
+                - file_type: Tipo do arquivo ("file" ou "link")
+                - file_content: Bytes do arquivo (se type="file")
+                - file_extension: Extensão do arquivo (se type="file")
+                - file_url: URL do arquivo (se type="link")
+                - expiration: Data de expiração (opcional)
+
+        Returns:
+            Objeto de resposta com atributo 'status' indicando sucesso/falha.
+
+        Raises:
+            Exception: Se houver erro na comunicação.
+        """
+        endpoint = '/files/upload/'
+
+        payload = {
+            'content': file_data,
+        }
+        response = await self._client.post(
+            endpoint,
+            files=payload,
+        )
+        response.raise_for_status()
+        response_data = response.json()
+        status = response_data.get('status')
+        message = response_data.get('message')
+        response_data = response_data.get('data')
+
+        if not status:
+            raise Exception(f'Erro ao fazer upload do arquivo: {message}')
+
+        file = File.from_dict(response_data)
+        return file
+
+    async def delete_file(self, file_id: str) -> Any:
+        """
+        Deleta um arquivo (imagem) pelo ID.
+
+        Args:
+            file_id: ID único do arquivo.
+
+        Returns:
+            Objeto de resposta com atributo 'status' indicando sucesso/falha.
+
+        Raises:
+            Exception: Se houver erro na comunicação.
+        """
+        endpoint = f'/files/{file_id}'
+
+        response = await self._client.delete(endpoint)
+        response.raise_for_status()
+        response_data = response.json()
+        status = response_data.get('status')
+        message = response_data.get('message')
+
+        if not status:
+            raise Exception(f'Erro ao deletar arquivo: {message}')
+
+        return response_data
+
+    # EndAction Methods
+    async def end_chat(
+        self,
+        chat_id: ChatID,
+        end_action: EndAction,
+        origin: str,
+    ) -> Any:
+        """
+        Encerra o atendimento com tabulação.
+
+        Args:
+            end_data: Dicionário contendo:
+                - chat_id: ID do chat (user_id, company_id)
+                - end_action: ID da tabulação de encerramento
+                - observation: Observação sobre o encerramento
+
+        Returns:
+            Objeto de resposta com atributo 'status' indicando sucesso/falha.
+
+        Raises:
+            Exception: Se houver erro na comunicação.
+        """
+        endpoint = '/session/end/'
+        payload = {
+            'chat_id': chat_id.to_dict(),
+            'end_action': end_action.to_dict(),
+            'origin': origin,
+        }
+
+        response = await self._client.post(
+            endpoint,
+            json=payload,
+        )
+        response.raise_for_status()
+        response_data = response.json()
+        status = response_data.get('status')
+        message = response_data.get('message')
+
+        if not status:
+            raise Exception(f'Erro ao encerrar chat: {message}')
+
+        return response_data
+
+    async def get_end_action(
+        self,
+        end_action_id: str = '',
+        end_action_name: str = '',
+    ) -> Any:
+        """
+        Obtém uma ação de encerramento pelo ID.
+
+        Args:
+            end_action_id: ID único da ação de encerramento.
+
+        Returns:
+            Objeto de resposta com atributos 'status' e 'end_action'.
+
+        Raises:
+            Exception: Se houver erro na comunicação.
+        """
+        endpoint = '/end_actions/'
+        params = {
+            'id': end_action_id,
+            'name': end_action_name,
+        }
+
+        response = await self._client.get(endpoint, params=params)
+        response.raise_for_status()
+        response_data = response.json()
+        status = response_data.get('status')
+        message = response_data.get('message')
+        end_action_data = response_data.get('data')
+
+        if not status:
+            raise Exception(f'Erro ao buscar ação de encerramento: {message}')
+
+        return EndAction.from_dict(end_action_data)
+
+    # ToDo Methods
+    async def transfer_to_menu(self, transfer_data: Dict[str, Any]) -> Any:
+        """
+        Transfere o chat para outro menu do fluxo.
+
+        Args:
+            transfer_data: Dicionário contendo:
+                - chat_id: ID do chat (user_id, company_id)
+                - menu: Nome do menu de destino
+                - user_message: Mensagem do usuário
+
+        Returns:
+            Objeto de resposta com atributo 'status' indicando sucesso/falha.
+
+        Raises:
+            Exception: Se houver erro na comunicação.
+        """
+        pass

chatgraph/types/background_task.py

@@ -0,0 +1,27 @@
+import asyncio
+from typing import Any, Callable
+import threading
+
+class BackgroundTask:
+    def __init__(self, func: Callable, *args: Any, **kwargs: Any) -> None:
+        """
+        Inicia uma função de forma assíncrona em segundo plano e printa sua saída.
+        
+        Args:
+            func (Callable): A função a ser executada.
+            args (Any): Argumentos posicionais a serem passados para a função.
+            kwargs (Any): Argumentos nomeados a serem passados para a função.
+        """
+        
+        if not asyncio.iscoroutinefunction(func):
+            raise TypeError("A função fornecida deve ser uma coroutine (async def).")
+        
+        self.args = args
+        self.kwargs = kwargs
+        self.func = func
+
+    async def run(self):
+        """
+        Executa a função em segundo plano.
+        """
+        return await self.func(*self.args, **self.kwargs)

chatgraph/types/end_types.py

@@ -0,0 +1,75 @@
+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:
+        """
+        Inicializa a resposta de redirecionamento com a rota especificada.
+
+        Args:
+            route (str): A rota para a qual o chatbot deve redirecionar.
+        """
+        self.route = route
+
+
+class EndChatResponse:
+    """
+    Representa uma resposta que indica o fim do chatbot.
+
+    Atributos:
+        end_chat_id (str): O ID do fim do chatbot.
+        end_chat_name (str): O nome da ação de encerramento.
+        observations (str): As observações finais do chatbot.
+    """
+
+    def __init__(
+        self,
+        end_chat_id: str,
+        end_chat_name: str = '',
+        observations: str = '',
+    ) -> None:
+        """
+        Finzaliza e tabula as informações do chatbot.
+        """
+        if not end_chat_id and not end_chat_name:
+            raise ValueError('end_chat_id or end_chat_name must be provided.')
+
+        self.end_chat_id = end_chat_id
+        self.end_chat_name = end_chat_name
+        self.observations = observations
+
+
+class TransferToHuman:
+    """
+    Representa uma transferencia para um atendente humano.
+    """
+
+    def __init__(
+        self,
+        campaign_id: str | None = None,
+        campaign_name: str | None = None,
+        observations: str | None = None,
+    ) -> None:
+        """
+        Finzaliza e tabula as informações do chatbot.
+        """
+        self.campaign_id = campaign_id
+        self.campaign_name = campaign_name
+        self.observations = observations
+
+
+class TransferToMenu:
+    """
+    Representa uma transferencia para outro Menu.
+    """
+
+    def __init__(self, menu: str, user_message: str) -> None:
+        """
+        Finzaliza e tabula as informações do chatbot.
+        """
+        self.menu = menu.lower()
+        self.user_message = user_message

chatgraph/types/route.py

@@ -0,0 +1,104 @@
+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] | None = None,
+        separator: 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.
+            separator (str): O separador de partes de rota. Padrão é '.'.
+        """
+        self.current = current
+        self.routes = routes
+        self.separator = separator
+
+    @property
+    def previous(self) -> 'Route':
+        """
+        Retorna a rota anterior a atual do usuário
+        """
+        return self.get_previous()
+
+    @property
+    def current_node(self) -> str:
+        """
+        Retorna o nó atual do usuário
+        """
+        return self.current.split(self.separator)[-1]
+
+    def get_previous(self) -> 'Route':
+        """
+        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':
+            return Route(self.current, self.routes, self.separator)
+
+        rotas_dedup = self.separator.join(
+            dict.fromkeys(self.current.split(self.separator))
+        )
+
+        previous_route = self.separator.join(
+            rotas_dedup.split(self.separator)[:-1]
+        )
+
+        return Route(previous_route, self.routes, self.separator)
+
+    def get_next(self, next_part: str) -> 'Route':
+        """
+        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:
+            Route: O próximo caminho montado.
+        """
+        next_part = next_part.strip().lower()
+        next_route = f'{self.current.rstrip(self.separator)}.{next_part}'
+        if next_part not in self.routes:
+            raise RouteError(f'Rota não encontrada: {next_part}')
+
+        return Route(next_route, self.routes, self.separator)
+
+    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__()