chatgraph 0.6.4__py3-none-any.whl

chatgraph/models/message.py

@@ -0,0 +1,350 @@
+"""
+Modelos de dados para mensagens do chatbot.
+
+Este módulo contém as dataclasses e enums para representar mensagens,
+botões, arquivos e seus tipos no sistema de chatbot.
+"""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from typing import List, Optional, Union
+import httpx
+import os
+import hashlib
+
+MessageTypes = Union[str, float, int]
+
+
+@dataclass
+class File:
+    """
+    Representa um arquivo no sistema.
+
+    Attributes:
+        id: ID único do arquivo
+        url: URL do arquivo
+        name: Nome do arquivo (ex: "document.pdf")
+        mime_type: Tipo MIME do arquivo
+        size: Tamanho em bytes
+        object_key: Chave do objeto no storage
+        created_at: Data/hora de criação (ISO 8601)
+        expires_after_days: Dias até expiração
+        actualized_at: Data/hora de última atualização (ISO 8601)
+    """
+
+    id: str = ''
+    url: str = ''
+    name: str = ''
+    mime_type: str = ''
+    size: int = 0
+    object_key: str = ''
+    created_at: str = ''
+    expires_after_days: int = 0
+    actualized_at: str = ''
+    bytes_data: Optional[bytes] = None
+    hash_id: Optional[str] = ''
+
+    def is_empty(self) -> bool:
+        """Verifica se o arquivo está vazio."""
+        return not self.id and not self.url and not self.name
+
+    def extension(self) -> str:
+        """
+        Retorna a extensão do arquivo em minúsculas.
+
+        Returns:
+            Extensão do arquivo (ex: ".pdf")
+        """
+        if not self.name or '.' not in self.name:
+            return ''
+        return self.name[self.name.rfind('.') :].lower()
+
+    def to_dict(self) -> dict:
+        """Converte para dicionário."""
+        data = {
+            'id': self.id,
+            'url': self.url,
+            'name': self.name,
+            'mime_type': self.mime_type,
+            'size': self.size,
+            'object_key': self.object_key,
+            'created_at': self.created_at,
+            'expires_after_days': self.expires_after_days,
+            'actualized_at': self.actualized_at,
+        }
+
+        return data
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'File':
+        """Cria instância a partir de dicionário."""
+
+        return cls(
+            id=data.get('id', ''),
+            url=data.get('url', ''),
+            name=data.get('name', ''),
+            mime_type=data.get('mime_type', ''),
+            size=data.get('size', 0),
+            object_key=data.get('object_key', ''),
+            created_at=data.get('created_at', ''),
+            expires_after_days=data.get('expires_after_days', 0),
+            actualized_at=data.get('actualized_at', ''),
+        )
+
+    @classmethod
+    def from_path(cls, path: str) -> 'File':
+        """Cria instância a partir de um caminho de arquivo."""
+        return cls(
+            name=path,
+        )
+
+    async def __check_file_exists(self) -> bool:
+        if os.path.isfile(self.name):
+            return True
+        return False
+
+    async def __deal_with_url(self) -> bytes:
+        async with httpx.AsyncClient() as client:
+            response = await client.get(self.url)
+            response.raise_for_status()
+            return response.content
+
+    async def __deal_with_path(self) -> bytes:
+        """Lê os bytes de um arquivo dado seu caminho."""
+        if not await self.__check_file_exists():
+            raise ValueError('Arquivo não encontrado para envio.')
+
+        with open(self.name, 'rb') as file:
+            self.bytes_data = file.read()
+        return self.bytes_data
+
+    async def __make_file_hash(
+        self,
+    ) -> str:
+        """Gera hash SHA-256 de bytes do arquivo."""
+        if not self.bytes_data:
+            raise ValueError('Dados do arquivo não carregados para hash.')
+
+        self.hash_id = hashlib.sha256(self.bytes_data).hexdigest()
+        return self.hash_id
+
+    async def load_file(self):
+        if not self.name and not self.url:
+            raise ValueError(
+                'Nenhum dado de arquivo fornecido para carregamento.'
+            )
+
+        try:
+            if self.url:
+                self.bytes_data = await self.__deal_with_url()
+            else:
+                self.bytes_data = await self.__deal_with_path()
+            if not self.hash_id and self.bytes_data:
+                self.hash_id = await self.__make_file_hash()
+
+        except Exception as e:
+            raise ValueError(f'Erro ao carregar arquivo: {e}')
+
+
+class ButtonType(Enum):
+    """
+    Tipo de botão de mensagem.
+
+    Attributes:
+        POSTBACK: Botão que envia dados de volta ao sistema
+        URL: Botão que abre um link externo
+    """
+
+    POSTBACK = 'postback'
+    URL = 'url'
+
+    @classmethod
+    def from_string(cls, value: str) -> 'ButtonType':
+        """
+        Cria ButtonType a partir de string.
+
+        Args:
+            value: String representando o tipo ("postback" ou "url")
+
+        Returns:
+            ButtonType correspondente
+
+        Raises:
+            ValueError: Se o valor não for válido
+        """
+        try:
+            return cls(value.lower())
+        except ValueError:
+            raise ValueError(f'invalid button type: {value}')
+
+
+@dataclass
+class TextMessage:
+    """
+    Mensagem de texto.
+
+    Attributes:
+        id: ID único da mensagem
+        title: Título da mensagem
+        detail: Conteúdo detalhado da mensagem
+        caption: Legenda da mensagem
+        mentioned_ids: IDs de usuários mencionados
+    """
+
+    id: str = ''
+    title: str = ''
+    detail: str = ''
+    caption: str = ''
+    mentioned_ids: List[str] = field(default_factory=list)
+
+    def to_dict(self) -> dict:
+        """Converte para dicionário."""
+        return {
+            'id': self.id,
+            'title': self.title,
+            'detail': self.detail,
+            'caption': self.caption,
+            'mentioned_ids': self.mentioned_ids,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'TextMessage':
+        """Cria instância a partir de dicionário."""
+        return cls(
+            id=data.get('id', ''),
+            title=data.get('title', ''),
+            detail=data.get('detail', ''),
+            caption=data.get('caption', ''),
+            mentioned_ids=data.get('mentioned_ids', []),
+        )
+
+
+@dataclass
+class Button:
+    """
+    Botão de mensagem interativa.
+
+    Attributes:
+        type: Tipo do botão (POSTBACK ou URL)
+        title: Título do botão
+        detail: Detalhe/payload do botão
+    """
+
+    title: str = ''
+    detail: str = ''
+    type: ButtonType = ButtonType.POSTBACK
+
+    def to_dict(self) -> dict:
+        """Converte para dicionário."""
+        return {
+            'type': self.type.value,
+            'title': self.title,
+            'detail': self.detail,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'Button':
+        """Cria instância a partir de dicionário."""
+        button_type = ButtonType.from_string(data.get('type', 'postback'))
+        return cls(
+            type=button_type,
+            title=data.get('title', ''),
+            detail=data.get('detail', ''),
+        )
+
+
+@dataclass
+class Message:
+    """
+    Mensagem completa com texto, botões e anexos.
+
+    Attributes:
+        text_message: Conteúdo textual da mensagem
+        buttons: Lista de botões interativos
+        display_button: Botão de exibição principal
+        date_time: Data e hora da mensagem
+        file: Arquivo anexado (opcional)
+    """
+
+    text_message: TextMessage = field(default_factory=TextMessage)
+    buttons: List[Button] = field(default_factory=list)
+    display_button: Optional[Button] = None
+    date_time: datetime = field(default_factory=datetime.now)
+    file: Optional[File] = field(default_factory=File)
+
+    def __init__(
+        self,
+        text_message: TextMessage | str = '',
+        buttons: List[Button] = [],
+        display_button: Optional[Button] = None,
+        file: Optional[File | str] = None,
+        date_time: Optional[datetime] = None,
+    ):
+        self.buttons = buttons
+        self.display_button = display_button
+        self.date_time = date_time if date_time is not None else datetime.now()
+
+        self.__load_text_message(text_message)
+        self.__load_file(file)
+
+    def has_buttons(self) -> bool:
+        """Verifica se a mensagem possui botões."""
+        return len(self.buttons) > 0
+
+    def has_file(self) -> bool:
+        """Verifica se a mensagem possui arquivo anexado."""
+        return self.file is not None and not self.file.is_empty()
+
+    def __load_file(self, file: Optional[File | str]) -> None:
+        if isinstance(file, str):
+            self.file = File(name=file)
+        else:
+            self.file = file
+
+    def __load_text_message(self, text_message: TextMessage | str) -> None:
+        if isinstance(text_message, str):
+            self.text_message = TextMessage(detail=text_message)
+        else:
+            self.text_message = text_message
+
+    def to_dict(self) -> dict:
+        """Converte para dicionário."""
+        data = {
+            'text_message': self.text_message.to_dict(),
+            'buttons': [btn.to_dict() for btn in self.buttons],
+            'date_time': self.date_time.isoformat(),
+        }
+
+        if self.display_button:
+            data['display_button'] = self.display_button.to_dict()
+        if self.file:
+            data['file'] = self.file.to_dict()
+
+        return data
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'Message':
+        """Cria instância a partir de dicionário."""
+        text_message_data = data.get('text_message', {})
+        buttons_data = data.get('buttons', [])
+        display_button_data = data.get('display_button')
+
+        date_time = datetime.now()
+        if 'date_time' in data:
+            try:
+                date_time = datetime.fromisoformat(data['date_time'])
+            except (ValueError, TypeError):
+                pass
+
+        return cls(
+            text_message=TextMessage.from_dict(text_message_data),
+            buttons=[Button.from_dict(btn) for btn in buttons_data],
+            display_button=(
+                Button.from_dict(display_button_data)
+                if display_button_data
+                else None
+            ),
+            date_time=date_time,
+            file=data.get('file'),
+        )

chatgraph/models/userstate.py

@@ -0,0 +1,214 @@
+"""
+Modelos de dados para gerenciamento de estado de usuário.
+
+Este módulo contém as dataclasses que representam o estado do usuário
+no sistema de chatbot, incluindo identificação, informações pessoais,
+menu atual e metadados da sessão.
+"""
+
+import json
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class ChatID:
+    """
+    Identificador único do chat.
+
+    Attributes:
+        user_id: ID único do usuário
+        company_id: ID da empresa/organização
+    """
+
+    user_id: str
+    company_id: str
+
+    def to_dict(self) -> dict:
+        """Converte para dicionário."""
+        return {
+            'user_id': self.user_id,
+            'company_id': self.company_id,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'ChatID':
+        """Cria instância a partir de dicionário."""
+        return cls(
+            user_id=data.get('user_id', ''),
+            company_id=data.get('company_id', ''),
+        )
+
+
+@dataclass
+class User:
+    """
+    Informações do usuário.
+
+    Attributes:
+        cpf: CPF do usuário (opcional)
+        name: Nome do usuário (opcional)
+        phone: Telefone do usuário (opcional)
+        email: Email do usuário (opcional)
+    """
+
+    cpf: Optional[str] = None
+    name: Optional[str] = None
+    phone: Optional[str] = None
+    email: Optional[str] = None
+
+    def to_dict(self) -> dict:
+        """Converte para dicionário, omitindo campos None."""
+        data = {}
+        if self.cpf is not None:
+            data['cpf'] = self.cpf
+        if self.name is not None:
+            data['name'] = self.name
+        if self.phone is not None:
+            data['phone'] = self.phone
+        if self.email is not None:
+            data['email'] = self.email
+        return data
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'User':
+        """Cria instância a partir de dicionário."""
+        return cls(
+            cpf=data.get('cpf'),
+            name=data.get('name'),
+            phone=data.get('phone'),
+            email=data.get('email'),
+        )
+
+
+@dataclass
+class Menu:
+    """
+    Informações do menu/departamento.
+
+    Attributes:
+        id: ID do menu (opcional)
+        department_id: ID do departamento (opcional)
+        name: Nome do menu (opcional)
+        description: Descrição do menu (opcional)
+        active: Status de ativação do menu (opcional)
+    """
+
+    id: Optional[int] = None
+    department_id: Optional[int] = None
+    name: Optional[str] = None
+    description: Optional[str] = None
+    active: Optional[bool] = None
+
+    def to_dict(self) -> dict:
+        """Converte para dicionário, omitindo campos None."""
+        data = {}
+        if self.id is not None:
+            data['id'] = self.id
+        if self.department_id is not None:
+            data['department_id'] = self.department_id
+        if self.name is not None:
+            data['name'] = self.name
+        if self.description is not None:
+            data['description'] = self.description
+        if self.active is not None:
+            data['active'] = self.active
+        return data
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'Menu':
+        """Cria instância a partir de dicionário."""
+        return cls(
+            id=data.get('id'),
+            department_id=data.get('department_id'),
+            name=data.get('name'),
+            description=data.get('description'),
+            active=data.get('active'),
+        )
+
+
+@dataclass
+class UserState:
+    """
+    Estado completo do usuário no sistema.
+
+    Attributes:
+        chat_id: Identificador do chat (obrigatório)
+        platform: Plataforma de comunicação (obrigatório)
+        session_id: ID da sessão (opcional)
+        menu: Menu atual (opcional)
+        user: Informações do usuário (opcional)
+        route: Rota atual no fluxo (opcional)
+        direction_in: Indica se é mensagem de entrada (opcional)
+        observation: Observações/contexto adicional (opcional)
+        last_update: Data/hora da última atualização (opcional)
+        dt_created: Data/hora de criação (opcional)
+    """
+
+    chat_id: ChatID
+    platform: str
+    session_id: Optional[int] = None
+    menu: Optional[Menu] = field(default_factory=Menu)
+    user: Optional[User] = field(default_factory=User)
+    route: str = 'start'
+    direction_in: Optional[bool] = None
+    observation: Optional[str] = None
+    last_update: Optional[str] = None
+    dt_created: Optional[str] = None
+
+    def to_dict(self) -> dict:
+        """Converte para dicionário."""
+        data = {
+            'chat_id': self.chat_id.to_dict(),
+            'platform': self.platform,
+        }
+
+        if self.session_id is not None:
+            data['session_id'] = self.session_id
+        if self.menu is not None:
+            data['menu'] = self.menu.to_dict()
+        if self.user is not None:
+            data['user'] = self.user.to_dict()
+        if self.route is not None:
+            data['route'] = self.route
+        if self.direction_in is not None:
+            data['direction_in'] = self.direction_in
+        if self.observation is not None:
+            data['observation'] = self.observation
+        if self.last_update is not None:
+            data['last_update'] = self.last_update
+        if self.dt_created is not None:
+            data['dt_created'] = self.dt_created
+
+        return data
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'UserState':
+        """Cria instância a partir de dicionário."""
+        chat_id_data = data.get('chat_id', {})
+        menu_data = data.get('menu', {})
+        user_data = data.get('user', {})
+
+        return cls(
+            session_id=data.get('session_id'),
+            chat_id=ChatID.from_dict(chat_id_data),
+            menu=Menu.from_dict(menu_data) if menu_data else Menu(),
+            user=User.from_dict(user_data) if user_data else User(),
+            route=data.get('route', 'start'),
+            direction_in=data.get('direction_in'),
+            observation=data.get('observation'),
+            platform=data.get('platform', ''),
+            last_update=data.get('last_update'),
+            dt_created=data.get('dt_created'),
+        )
+
+    @property
+    def observation_dict(self) -> dict:
+        """Retorna a observação como dicionário."""
+
+        if self.observation:
+            try:
+                return json.loads(self.observation)
+            except json.JSONDecodeError:
+                return {}
+        return {}

chatgraph/pb/router.proto

@@ -0,0 +1,151 @@
+syntax = "proto3";
+
+package chatbot;
+
+option go_package = "./chatbot";
+
+///// Serviços de Estado do Usuário /////
+service UserStateService {
+    rpc InsertUpdateUserState(UserState) returns (RequestStatus);
+    rpc SetRoute(RouteRequest) returns (RequestStatus);
+    rpc DeleteUserState(ChatID) returns (RequestStatus);
+    rpc GetUserState(ChatID) returns (UserState);
+    rpc GetAllUserStates(Void) returns (UserStateList);
+}
+
+///// Serviços de Mensagens /////
+service SendMessage {
+    rpc SendMessage(Message) returns (RequestStatus);
+    rpc SendImage(FileMessage) returns (RequestStatus);
+    rpc SendFile(FileMessage) returns (RequestStatus);
+    rpc UploadFile(UploadFileRequest) returns (RequestStatus);
+}
+
+///// Serviços de Transfer /////
+service Transfer {
+    rpc GetAllCampaigns(Void) returns (CampaignsList);
+    rpc GetCampaignID(CampaignName) returns (CampaignDetails);
+    rpc TransferToHuman(TransferToHumanRequest) returns (RequestStatus);
+    rpc TransferToMenu(TransferToMenuRequest) returns (RequestStatus);
+}
+
+///// Serviços de EndChat /////
+service EndChat {
+    rpc GetAllTabulations(Void) returns (TabulationsList);
+    rpc GetTabulationID(TabulationName) returns (TabulationDetails);
+    rpc EndChat(EndChatRequest) returns (RequestStatus);
+}
+
+///// Mensagens Compartilhadas /////
+message Void {}
+
+message RequestStatus {
+    bool status = 1;
+    string message = 2;
+}
+
+message ChatID {
+    string user_id = 1;
+    string company_id = 2;
+}
+///// Mensagens para Estado do Usuário /////
+message UserState {
+    ChatID chat_id = 1;
+    string menu = 2;
+    string route = 3;
+    string protocol = 4;
+    string observation = 5;
+}
+
+message UserStateList {
+    repeated UserState user_states = 1;
+}
+
+message RouteRequest {
+    ChatID chat_id = 1;
+    string route = 2;
+}
+///// Mensagens para Serviços de Mensagens /////
+message TextMessage {
+    string type = 1;
+    string url = 2;
+    string filename = 3;
+    string title = 4;
+    string detail = 5;
+    string caption = 6;
+}
+
+message Button{
+    string type = 1;
+    string title = 2;
+    string detail = 3;
+}
+
+message Message {
+    ChatID chat_id = 1;
+    TextMessage message = 2;
+    repeated Button buttons = 3;
+    Button display_button = 4;
+}
+
+message FileMessage {
+    Message message = 1;
+    string file_id = 2;
+}
+
+message UploadFileRequest {
+  string file_url = 1;
+  string file_type = 2;
+  string file_extension = 3;
+  string expiration = 4;
+  bytes file_content = 5;
+}
+
+///// Mensagens para Serviços de Transfer /////
+message TransferToHumanRequest{
+    ChatID chat_id = 1;
+    string campaign_id = 2;
+    string observation = 3;
+}
+
+message TransferToMenuRequest{
+    ChatID chat_id = 1;
+    string menu = 2;
+    string route = 3;
+    string user_message = 4;
+}
+
+message TabulationName{
+    string name = 1;
+}
+
+message TabulationDetails{
+    string id = 1;
+    string name = 2;
+    string last_update = 3;
+}
+
+message TabulationsList{
+    repeated TabulationDetails tabulations = 1;
+}
+
+///// Serviços de EndChat /////
+message EndChatRequest {
+    ChatID chat_id = 1;
+    string tabulation_id = 2;
+    string observation = 3;
+}
+
+message CampaignName {
+    string name = 1;
+}
+
+message CampaignDetails {
+    string id = 1;
+    string name = 2;
+    string last_update = 3;
+}
+
+message CampaignsList {
+    repeated CampaignDetails campaigns = 1;
+}