chatgraph 1.2.4__tar.gz → 1.2.6__tar.gz

{chatgraph-1.2.4 → chatgraph-1.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chatgraph
-Version: 1.2.4
+Version: 1.2.6
 Summary: A user-friendly chatbot library
 Project-URL: Homepage, https://github.com/irissonnlima/chatgraph
 Project-URL: Repository, https://github.com/irissonnlima/chatgraph

{chatgraph-1.2.4 → chatgraph-1.2.6}/chatgraph/__init__.py

@@ -6,15 +6,16 @@ from .container.container import Container
 from .logger import logger, set_level
 from .messages.message_consumer import MessageConsumer
 from .models.message import Button, File, Message, SendType, TextMessage
+from .models.platform_state import PlatformState, VollStateData
 from .models.userstate import (
     AuthLevel,
     ChatID,
     Menu,
+    User,
     UserData,
     UserIdentity,
     UserInternal,
     UserState,
-    User,
 )
 from .types.background_task import BackgroundTask
 from .types.end_types import (
@@ -54,4 +55,6 @@ __all__ = [
     "BackgroundTask",
     "Container", "logger",
     "default_guard",
+    "PlatformState",
+    "VollStateData",
 ]

{chatgraph-1.2.4 → chatgraph-1.2.6}/chatgraph/logger/__init__.py

@@ -1,11 +1,11 @@
-import logging
-
-from .user_logger import UserLoggerManager
-
-logger_httpx = logging.getLogger('httpx')
-logger_httpx.setLevel(logging.ERROR)
-
-get_system_logger = UserLoggerManager.get_system_logger
-get_user_logger = UserLoggerManager.get_user_logger
-set_level = UserLoggerManager.set_level
-remove_user_logger = UserLoggerManager.remove_user_logger
+import logging
+
+from .user_logger import UserLoggerManager
+
+logger_httpx = logging.getLogger('httpx')
+logger_httpx.setLevel(logging.ERROR)
+
+get_system_logger = UserLoggerManager.get_system_logger
+get_user_logger = UserLoggerManager.get_user_logger
+set_level = UserLoggerManager.set_level
+remove_user_logger = UserLoggerManager.remove_user_logger

{chatgraph-1.2.4 → chatgraph-1.2.6}/chatgraph/logger/user_logger.py

@@ -1,88 +1,97 @@
-import logging
-import os
-import sys
-
-LOG_DIR = "chatgraph_logs"
-LOG_FORMAT = "%(asctime)s | %(levelname)s | %(message)s | %(funcName)s | %(name)s"
-
-_ENV_LEVEL = os.getenv("CHATGRAPH_LOG_LEVEL", "").upper()
-_DEFAULT_LEVEL: int = getattr(logging, _ENV_LEVEL, logging.INFO)
-
-
-class UserLoggerManager:
-    _loggers: dict[str, logging.Logger] = {}
-    _level: int = _DEFAULT_LEVEL
-
-    @classmethod
-    def set_level(cls, level: int | str) -> None:
-        if isinstance(level, str):
-            numeric = getattr(logging, level.upper(), None)
-            if numeric is None:
-                raise ValueError(f"Nível de log inválido: '{level}'")
-            level = numeric
-        cls._level = level
-        for logger in cls._loggers.values():
-            logger.setLevel(level)
-            for handler in logger.handlers:
-                handler.setLevel(level)
-
-    @classmethod
-    def get_user_logger(cls, user_id: str, company_id: str) -> logging.Logger:
-        key = f"{user_id}_{company_id}"
-        if key in cls._loggers:
-            return cls._loggers[key]
-
-        os.makedirs(LOG_DIR, exist_ok=True)
-
-        logger = logging.getLogger(key)
-        logger.setLevel(cls._level)
-
-        if not logger.handlers:
-            handler = logging.FileHandler(
-                os.path.join(LOG_DIR, f"{key}.log"), encoding="utf-8"
-            )
-            handler.setLevel(cls._level)
-            handler.setFormatter(logging.Formatter(LOG_FORMAT))
-            logger.addHandler(handler)
-            stream_handler = logging.StreamHandler(sys.stdout)
-            stream_handler.setLevel(cls._level)
-            stream_handler.setFormatter(logging.Formatter(LOG_FORMAT))
-            logger.addHandler(stream_handler)
-
-        cls._loggers[key] = logger
-        return logger
-
-    @classmethod
-    def remove_user_logger(cls, user_id: str, company_id: str) -> None:
-        key = f"{user_id}_{company_id}"
-        logger = cls._loggers.pop(key, None)
-        if logger:
-            for handler in logger.handlers[:]:
-                handler.close()
-                logger.removeHandler(handler)
-
-    @classmethod
-    def get_system_logger(cls) -> logging.Logger:
-        key = "chatgraph.system"
-        if key in cls._loggers:
-            return cls._loggers[key]
-
-        os.makedirs(LOG_DIR, exist_ok=True)
-
-        logger = logging.getLogger(key)
-        logger.setLevel(cls._level)
-
-        if not logger.handlers:
-            handler = logging.FileHandler(
-                os.path.join(LOG_DIR, "system.log"), encoding="utf-8"
-            )
-            handler.setLevel(cls._level)
-            handler.setFormatter(logging.Formatter(LOG_FORMAT))
-            logger.addHandler(handler)
-            stream_handler = logging.StreamHandler(sys.stdout)
-            stream_handler.setLevel(cls._level)
-            stream_handler.setFormatter(logging.Formatter(LOG_FORMAT))
-            logger.addHandler(stream_handler)
-
-        cls._loggers[key] = logger
-        return logger
+import logging
+import os
+import sys
+
+LOG_DIR = "chatgraph_logs"
+LOG_FORMAT = "%(asctime)s | %(levelname)s | %(message)s | %(funcName)s | %(name)s"
+
+_ENV_LEVEL = os.getenv("CHATGRAPH_LOG_LEVEL", "").upper()
+_DEFAULT_LEVEL: int = getattr(logging, _ENV_LEVEL, logging.INFO)
+
+
+class ChatIDFilter(logging.Filter):
+    def filter(self, record: logging.LogRecord) -> bool:
+        chat_id = getattr(record, 'chat_id', None)
+        if chat_id:
+            record.msg = f'[ChatID: {chat_id}] - {record.msg}'
+        return True
+
+
+class UserLoggerManager:
+    _loggers: dict[str, logging.Logger] = {}
+    _level: int = _DEFAULT_LEVEL
+
+    @classmethod
+    def set_level(cls, level: int | str) -> None:
+        if isinstance(level, str):
+            numeric = getattr(logging, level.upper(), None)
+            if numeric is None:
+                raise ValueError(f"Nível de log inválido: '{level}'")
+            level = numeric
+        cls._level = level
+        for logger in cls._loggers.values():
+            logger.setLevel(level)
+            for handler in logger.handlers:
+                handler.setLevel(level)
+
+    @classmethod
+    def get_user_logger(cls, user_id: str, company_id: str) -> logging.Logger:
+        key = f"{user_id}_{company_id}"
+        if key in cls._loggers:
+            return cls._loggers[key]
+
+        os.makedirs(LOG_DIR, exist_ok=True)
+
+        logger = logging.getLogger(key)
+        logger.setLevel(cls._level)
+
+        if not logger.handlers:
+            handler = logging.FileHandler(
+                os.path.join(LOG_DIR, f"{key}.log"), encoding="utf-8"
+            )
+            handler.setLevel(cls._level)
+            handler.setFormatter(logging.Formatter(LOG_FORMAT))
+            logger.addHandler(handler)
+            stream_handler = logging.StreamHandler(sys.stdout)
+            stream_handler.setLevel(cls._level)
+            stream_handler.setFormatter(logging.Formatter(LOG_FORMAT))
+            logger.addHandler(stream_handler)
+            logger.addFilter(ChatIDFilter())
+
+        cls._loggers[key] = logger
+        return logger
+
+    @classmethod
+    def remove_user_logger(cls, user_id: str, company_id: str) -> None:
+        key = f"{user_id}_{company_id}"
+        logger = cls._loggers.pop(key, None)
+        if logger:
+            for handler in logger.handlers[:]:
+                handler.close()
+                logger.removeHandler(handler)
+
+    @classmethod
+    def get_system_logger(cls) -> logging.Logger:
+        key = "chatgraph.system"
+        if key in cls._loggers:
+            return cls._loggers[key]
+
+        os.makedirs(LOG_DIR, exist_ok=True)
+
+        logger = logging.getLogger(key)
+        logger.setLevel(cls._level)
+
+        if not logger.handlers:
+            handler = logging.FileHandler(
+                os.path.join(LOG_DIR, "system.log"), encoding="utf-8"
+            )
+            handler.setLevel(cls._level)
+            handler.setFormatter(logging.Formatter(LOG_FORMAT))
+            logger.addHandler(handler)
+            stream_handler = logging.StreamHandler(sys.stdout)
+            stream_handler.setLevel(cls._level)
+            stream_handler.setFormatter(logging.Formatter(LOG_FORMAT))
+            logger.addHandler(stream_handler)
+
+        cls._loggers[key] = logger
+        return logger

{chatgraph-1.2.4 → chatgraph-1.2.6}/chatgraph/messages/message_consumer.py

@@ -13,6 +13,7 @@ from rich.text import Text
 from ..auth.credentials import Credential
 from ..logger.user_logger import UserLoggerManager
 from ..models.message import Message
+from ..models.platform_state import PlatformState
 from ..models.userstate import UserState
 from ..services.router_http_client import RouterHTTPClient
 from ..types.usercall import UserCall
@@ -154,7 +155,9 @@ class MessageConsumer:
             channel = await connection.channel()
             await channel.set_qos(prefetch_count=self.__prefetch_count)
             queue = await self.__declare_queue(channel)
-            _logger.info('[x] Server inicializado! Aguardando solicitações RPC')
+            _logger.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)
@@ -188,12 +191,14 @@ class MessageConsumer:
             _logger.error(f'Erro ao processar mensagem: {e}')
         finally:
             if pure_message is not None:
-                UserLoggerManager.remove_user_logger(pure_message.user_id, pure_message.company_id)
+                UserLoggerManager.remove_user_logger(
+                    pure_message.user_id, pure_message.company_id
+                )
 
     async def __transform_message(self, message: dict) -> UserCall:
         user_state = message.get('user_state', {})
         message_data = message.get('message', {})
-        observation = user_state.get('observation', "{}")
+        observation = user_state.get('observation', '{}')
 
         if isinstance(observation, str):
             observation = json.loads(observation)
@@ -201,13 +206,18 @@ class MessageConsumer:
         user_state_models = UserState.from_dict(user_state)
         message_models = Message.from_dict(message_data)
 
-        # Reutilizar o mesmo cliente para todas as mensagens
+        platform_state_data = message.get('platform_state', {})
+        if not isinstance(platform_state_data, dict):
+            platform_state_data = None
+        platform_state = PlatformState.from_dict(platform_state_data)
+
         router_client = await self.__initialize_router()
 
         usercall = UserCall(
             user_state=user_state_models,
             message=message_models,
             router_client=router_client,
+            platform_state=platform_state,
         )
 
         return usercall

chatgraph-1.2.6/chatgraph/models/platform_state.py

@@ -0,0 +1,35 @@
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class PlatformState:
+    data: dict = field(default_factory=dict)
+
+    def to_dict(self) -> dict:
+        return self.data
+
+    @classmethod
+    def from_dict(cls, data: Optional[dict]) -> 'PlatformState':
+        if data is None:
+            return cls(data={})
+        return cls(data=data)
+
+    @property
+    def as_voll(self) -> Optional['VollStateData']:
+        try:
+            return VollStateData(**self.data)
+        except (TypeError, ValueError):
+            return None
+
+    def __bool__(self) -> bool:
+        return bool(self.data)
+
+
+@dataclass
+class VollStateData:
+    session_id: int
+    customer_id: str
+    platform: str
+    protocol: str
+    campaign: str

{chatgraph-1.2.4 → chatgraph-1.2.6}/chatgraph/services/router_http_client.py

@@ -3,10 +3,11 @@ from typing import Any, Dict, Optional
 import httpx
 
 from ..logger.user_logger import UserLoggerManager
-from ..models.http_responses import RouterResponses
-from ..models.userstate import UserState, ChatID, Menu, User, UserIdentity
-from ..models.message import Message, File
 from ..models.actions import EndAction
+from ..models.http_responses import RouterResponses
+from ..models.message import File, Message
+from ..models.platform_state import PlatformState
+from ..models.userstate import ChatID, Menu, User, UserIdentity, UserState
 
 _logger = UserLoggerManager.get_system_logger()
 
@@ -258,6 +259,7 @@ class RouterHTTPClient:
         self,
         message_data: Message,
         user_state: UserState,
+        platform_state: PlatformState = PlatformState(),
     ) -> Any:
         """
         Envia uma mensagem de texto ao usuário.
@@ -267,6 +269,7 @@ class RouterHTTPClient:
                 - chat_id: ID do chat (user_id, company_id)
                 - type: Tipo da mensagem
                 - detail: Conteúdo da mensagem
+            platform_state: Estado específico da plataforma (opcional).
 
         Returns:
             Objeto de resposta com atributo 'status' indicando sucesso/falha.
@@ -280,6 +283,8 @@ class RouterHTTPClient:
             'message': message_data.to_dict(),
             'user_state': user_state.to_dict(),
         }
+        if platform_state:
+            payload['platform_state'] = platform_state.to_dict()
         _logger.debug(f"[send_message] POST {endpoint}")
         response = await self._actions_client.post(
             endpoint,

{chatgraph-1.2.4 → chatgraph-1.2.6}/chatgraph/types/usercall.py

@@ -1,5 +1,4 @@
 import asyncio
-import concurrent.futures
 import json
 import logging
 from typing import Optional
@@ -10,6 +9,7 @@ from chatgraph.models.message import (
     Message,
     MessageTypes,
 )
+from chatgraph.models.platform_state import PlatformState
 from chatgraph.models.userstate import Menu, User, UserIdentity, UserState
 from chatgraph.services.router_http_client import RouterHTTPClient
 
@@ -33,16 +33,23 @@ class UserCall:  # noqa: PLR0904
         user_state: UserState,
         message: Message,
         router_client: RouterHTTPClient,
+        platform_state: PlatformState = PlatformState(),
     ) -> None:
         self.type = type
         self.__message = message
         self.__user_state = user_state
         self.__router_client = router_client
+        self.__platform_state = platform_state
         self.__content_message = self.__message.text_message.detail
 
     @property
-    def logger(self) -> logging.Logger:
-        return UserLoggerManager.get_user_logger(self.user_id, self.company_id)
+    def logger(self) -> logging.LoggerAdapter:
+        base_logger = UserLoggerManager.get_user_logger(
+            self.user_id, self.company_id
+        )
+        return logging.LoggerAdapter(
+            base_logger, {'chat_id': str(self.__user_state.chat_id)}
+        )
 
     def __str__(self):
         return (
@@ -115,21 +122,23 @@ class UserCall:  # noqa: PLR0904
 
     async def __send(self, message: Message) -> None:
         try:
-            self.logger.debug(
+            self.logger.info(
                 f'Enviando mensagem | user={self.user_id} | company={self.company_id} | tipo={message.type if hasattr(message, "type") else "N/A"}'
             )
             response = await self.__router_client.send_message(
-                message, self.__user_state
+                message, self.__user_state, self.__platform_state
             )
 
             if response:
-                self.logger.debug(
+                self.logger.info(
                     f'Mensagem enviada com sucesso | user={self.user_id}'
                 )
 
             await asyncio.sleep(0.1)
         except Exception as e:
-            raise Exception(f'Erro ao enviar mensagem: {e}')
+            raise Exception(
+                f'[ChatID: {self.__user_state.chat_id}] - Erro ao enviar mensagem: {e}'
+            )
 
     async def send(
         self,
@@ -321,7 +330,9 @@ class UserCall:  # noqa: PLR0904
     async def load_identity(self, cpf: Optional[str] = None) -> UserIdentity:
         try:
             self.logger.debug(f'Consultando identidade | user={self.user_id}')
-            identity = await self.__router_client.get_identity(self.user_id, cpf=cpf)
+            identity = await self.__router_client.get_identity(
+                self.user_id, cpf=cpf
+            )
             if self.__user_state.user is None:
                 self.__user_state.user = User()
             self.__user_state.user.identity = identity
@@ -336,9 +347,13 @@ class UserCall:  # noqa: PLR0904
     async def load_userstate(self) -> UserState:
         try:
             self.logger.debug(f'Carregando userstate | user={self.user_id}')
-            resultado = await self.__router_client.get_session_by_chat_id(self.__user_state.chat_id)
+            resultado = await self.__router_client.get_session_by_chat_id(
+                self.__user_state.chat_id
+            )
             if resultado is None:
-                raise ValueError('Sessão não encontrada para o chat_id informado.')
+                raise ValueError(
+                    'Sessão não encontrada para o chat_id informado.'
+                )
             self.__user_state = resultado
             self.logger.info(
                 f'Userstate carregado | user={self.user_id} | route={self.__user_state.route}'
@@ -400,6 +415,10 @@ class UserCall:  # noqa: PLR0904
     def observation(self):
         return self.__user_state.observation_dict
 
+    @property
+    def platform_state(self) -> PlatformState:
+        return self.__platform_state
+
     @property
     def content_message(self):
         return self.__content_message