chatgraph 0.1.0__tar.gz

chatgraph-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Irisson Lima
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

chatgraph-0.1.0/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.1
+Name: chatgraph
+Version: 0.1.0
+Summary: A user-friendly chatbot library
+Author: Irisson N. Lima
+Author-email: irisson.lima@verdecard.com.br
+Requires-Python: >=3.12,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: pika (>=1.3.2,<2.0.0)
+Description-Content-Type: text/markdown
+
+# chatgraph
+ChatGraph is a user-friendly chatbot library that offers seamless integration with RabbitMQ. It is designed to simplify the development process by providing intuitive interfaces and robust messaging capabilities, making it easy to build and deploy chatbots leveraging RabbitMQ's powerful messaging infrastructure.
+

chatgraph-0.1.0/README.md

@@ -0,0 +1,2 @@
+# chatgraph
+ChatGraph is a user-friendly chatbot library that offers seamless integration with RabbitMQ. It is designed to simplify the development process by providing intuitive interfaces and robust messaging capabilities, making it easy to build and deploy chatbots leveraging RabbitMQ's powerful messaging infrastructure.

chatgraph-0.1.0/chatgraph/__init__.py

@@ -0,0 +1,20 @@
+from .auth.credentials import Credential
+from .bot.chatbot_model import ChatbotApp
+from .bot.chatbot_router import ChatbotRouter
+from .messages.rabbitMQ_message_consumer import RabbitMessageConsumer
+from .types.message_types import Message
+from .types.output_state import ChatbotResponse, RedirectResponse
+from .types.route import Route
+from .types.user_state import SimpleUserState
+
+__all__ = [
+    'ChatbotApp',
+    'Credential',
+    'SimpleUserState',
+    'Message',
+    'ChatbotRouter',
+    'ChatbotResponse',
+    'RedirectResponse',
+    'RabbitMessageConsumer',
+    'Route',
+]

chatgraph-0.1.0/chatgraph/auth/credentials.py

@@ -0,0 +1,33 @@
+import os
+
+
+class Credential:
+    def __init__(
+        self, username: str | None = None, password: str | None = None
+    ):
+        self.__username = username
+        self.__password = password
+
+    @property
+    def password(self):
+        if not self.__password:
+            raise ValueError('Senha vazia!')
+        return self.__password
+
+    @property
+    def username(self):
+        if not self.__username:
+            raise ValueError('Usuário vazio!')
+        return self.__username
+
+    @classmethod
+    def dot_env_credentials(
+        cls, user_env: str = 'CHATBOT_USER', pass_env: str = 'CHATBOT_PASS'
+    ) -> 'Credential':
+        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-0.1.0/chatgraph/bot/chatbot_app.py

@@ -0,0 +1,155 @@
+import inspect
+import json
+from functools import wraps
+from logging import debug
+
+import pika
+import pika.exceptions
+
+from ..auth.credentials import Credential
+from ..error.chatbot_error import ChatbotError, ChatbotMessageError
+from ..types.message_types import Message
+from ..types.user_state import SimpleUserState, UserState
+from .chatbot_router import ChatbotRouter
+
+
+class ChatbotApp:
+    def __init__(
+        self,
+        amqp_url: str,
+        queue_consume: str,
+        credentials: Credential,
+        user_state: UserState,
+        prefetch_count: int = 1,
+        virtual_host: str = '/',
+    ):
+        self.__virtual_host = virtual_host
+        self.__prefetch_count = prefetch_count
+        self.__user_state = user_state
+        self.__queue_consume = queue_consume
+        self.__amqp_url = amqp_url
+        self.__credentials = pika.PlainCredentials(
+            credentials.username, credentials.password
+        )
+        self.__routes = {}
+
+    def include_router(self, router: ChatbotRouter, prefix: str):
+        if 'START' not in router.routes.keys():
+            raise ChatbotError('Erro ao incluir rota, START não encontrado!')
+
+        prefixed_routes = {
+            (
+                f'START{prefix.upper()}'
+                if key.upper() == 'START'
+                else f'START{prefix.upper()}{key.upper()}'
+            ): value
+            for key, value in router.routes.items()
+        }
+        self.__routes.update(prefixed_routes)
+
+    def route(self, state: str, default_message: str):
+        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}')
+
+            if Message not in params.keys():
+                raise ChatbotError(
+                    'Função não recebe Message, parâmetro obrigatório!'
+                )
+
+            self.__routes[state.upper()] = {
+                'function': func,
+                'default_message': default_message,
+                'params': params,
+                'return': output_param,
+            }
+
+            @wraps(func)
+            def wrapper(*args, **kwargs):
+                return func(*args, **kwargs)
+
+            return wrapper
+
+        return decorator
+
+    def start(self):
+        try:  # Verificar se recursão não vai estourar
+            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=self.on_request,
+            )
+
+            debug('[x] Aguardando solicitações RPC')
+            channel.start_consuming()
+        except pika.exceptions.StreamLostError as e:
+            debug(e)
+            self.start()
+
+    def on_request(self, ch, method, props, body):
+        message = body.decode()
+        response = self.process_message(message)
+
+        ch.basic_publish(
+            exchange='',
+            routing_key=props.reply_to,
+            properties=pika.BasicProperties(
+                correlation_id=props.correlation_id
+            ),
+            body=str(response),
+        )
+        ch.basic_ack(delivery_tag=method.delivery_tag)
+
+    def process_message(self, message: str):
+        data = json.loads(message)
+        message_imported = self.__transform_message(data)
+
+        customer_id = message_imported.customer_id
+
+        menu = self.__user_state.get_menu(customer_id)
+        handler = self.__routes.get(menu, None)
+
+        if not handler:
+            raise ChatbotMessageError(
+                customer_id, f'Rota não encontrada para {menu}!'
+            )
+        func = handler['function']
+        message_name = handler['params'].get(Message)
+        user_state_name = handler['params'].get(UserState, None)
+
+        kwargs = {message_name: message_imported}
+        if user_state_name:
+            kwargs[user_state_name] = SimpleUserState(
+                menu, list(self.__routes.keys())
+            )
+        return func(**kwargs)
+
+    def __transform_message(self, message: dict) -> Message:
+        return Message(
+            type=message.get('type', ''),
+            text=message.get('text', ''),
+            customer_id=message.get('customer_id', ''),
+            channel=message.get('channel', ''),
+            customer_phone=message.get('customer_phone', ''),
+            company_phone=message.get('company_phone', ''),
+            status=message.get('status'),
+        )

chatgraph-0.1.0/chatgraph/bot/chatbot_model.py

@@ -0,0 +1,117 @@
+import inspect
+from abc import ABC
+from functools import wraps
+from logging import debug
+
+from ..error.chatbot_error import ChatbotError, ChatbotMessageError
+from ..messages.base_message_consumer import MessageConsumer
+from ..types.message_types import Message
+from ..types.route import Route
+from ..types.user_state import UserState
+from .chatbot_router import ChatbotRouter
+from ..types.output_state import ChatbotResponse, RedirectResponse
+
+class ChatbotApp(ABC):
+    def __init__(
+        self,
+        user_state: UserState,
+        message_consumer: MessageConsumer,
+    ):
+        self.__message_consumer = message_consumer
+        self.__user_state = user_state
+        self.__routes = {}
+
+    def include_router(self, router: ChatbotRouter, prefix: str):
+        if 'START' not in router.routes.keys():
+            raise ChatbotError('Erro ao incluir rota, START não encontrado!')
+
+        prefixed_routes = {
+            (
+                f'START{prefix.upper()}'
+                if key.upper() == 'START'
+                else f'START{prefix.upper()}{key.upper().replace("START", "")}'
+            ): value
+            for key, value in router.routes.items()
+        }
+        self.__routes.update(prefixed_routes)
+
+    def route(self, route_name: str):
+        if not 'START' in route_name:
+            route_name = f'START{route_name}'
+            
+        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.strip().upper()] = {
+                'function': func,
+                'params': params,
+                'return': output_param,
+            }
+
+            @wraps(func)
+            def wrapper(*args, **kwargs):
+                return func(*args, **kwargs)
+
+            return wrapper
+
+        return decorator
+
+    def start(self):
+        self.__message_consumer.start_consume(self.process_message)
+
+    def process_message(self, message: Message):
+        customer_id = message.customer_id
+
+        menu = self.__user_state.get_menu(customer_id)
+        menu = menu.upper()
+        handler = self.__routes.get(menu, None)
+
+        if not handler:
+            raise ChatbotMessageError(
+                customer_id, f'Rota não encontrada para {menu}!'
+            )
+        func = handler['function']
+        message_name = handler['params'].get(Message, None)
+        route_state_name = handler['params'].get(Route, None)
+
+        kwargs = dict()
+        if message_name:
+            kwargs[message_name] = message
+        if route_state_name:
+            kwargs[route_state_name] = Route(menu, list(self.__routes.keys()))
+
+        message_response = func(**kwargs)
+        
+        if type(message_response) in (str, float, int):
+            return message_response
+        elif type(message_response) == ChatbotResponse:
+            route = self.__adjust_route(message_response.route, menu)
+            self.__user_state.set_menu(customer_id, route)
+            return message_response.message
+        elif type(message_response) == RedirectResponse:
+            route = self.__adjust_route(message_response.route, menu)
+            self.__user_state.set_menu(customer_id, route)
+            return self.process_message(message)
+        else:
+            raise ChatbotError('Tipo de retorno inválido!')
+    
+    def __adjust_route(self, route: str, absolute_route:str) -> str:
+        if not route:
+            return absolute_route
+        
+        if not 'START' in route:
+            route = absolute_route+route
+            
+        return route

chatgraph-0.1.0/chatgraph/bot/chatbot_router.py

@@ -0,0 +1,58 @@
+import inspect
+from functools import wraps
+from logging import debug
+
+from ..error.chatbot_error import ChatbotError
+from ..types.message_types import Message
+
+
+class ChatbotRouter:
+    def __init__(self):
+        self.routes = {}
+
+    def route(self, route_name: str):
+        if not 'START' in route_name:
+            route_name = f'START{route_name}'
+            
+        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.strip().upper()] = {
+                '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', prefix: str):
+        if 'START' not in router.routes.keys():
+            raise ChatbotError('Erro ao incluir rota, START não encontrado!')
+
+        prefixed_routes = {
+            (
+                f'{prefix.upper()}'
+                if key.upper() == 'START'
+                else f'START{prefix.upper()}{key.upper().replace("START", "")}'
+            ): value
+            for key, value in router.routes.items()
+        }
+        self.routes.update(prefixed_routes)

chatgraph-0.1.0/chatgraph/error/chatbot_error.py

@@ -0,0 +1,17 @@
+class ChatbotError(Exception):
+    def __init__(self, message: str):
+        self.message = message
+        super().__init__(self.message)
+
+    def __str__(self):
+        return f'ChatbotError: {self.message}'
+
+
+class ChatbotMessageError(Exception):
+    def __init__(self, customer_id: str, message: str):
+        self.customer_id = customer_id
+        self.message = f'{message} ID recebido: {customer_id}'
+        super().__init__(self.message)
+
+    def __str__(self):
+        return f'InvalidCustomerIDError: {self.message}'

chatgraph-0.1.0/chatgraph/error/route_error.py

@@ -0,0 +1,7 @@
+class RouteError(Exception):
+    def __init__(self, message: str):
+        self.message = message
+        super().__init__(self.message)
+
+    def __str__(self):
+        return f'RouteError: {self.message}'

chatgraph-0.1.0/chatgraph/messages/__init__.py

@@ -0,0 +1,5 @@
+from .base_message_consumer import MessageConsumer
+
+__all__ = [
+    'MessageConsumer',
+]

chatgraph-0.1.0/chatgraph/messages/base_message_consumer.py

@@ -0,0 +1,8 @@
+from abc import ABC, abstractmethod
+from typing import Any, Callable
+
+
+class MessageConsumer(ABC):
+    @abstractmethod
+    def start_consume(self, process_message: Callable) -> Any:
+        pass

chatgraph-0.1.0/chatgraph/messages/rabbitMQ_message_consumer.py

@@ -0,0 +1,78 @@
+import json
+from logging import debug, info
+
+import pika
+
+from ..auth.credentials import Credential
+from ..types.message_types import Message
+from .base_message_consumer import MessageConsumer
+
+
+class RabbitMessageConsumer(MessageConsumer):
+    def __init__(
+        self,
+        amqp_url: str,
+        queue_consume: str,
+        credentials: Credential,
+        prefetch_count: int = 1,
+        virtual_host: str = '/',
+    ) -> None:
+        self.__virtual_host = virtual_host
+        self.__prefetch_count = prefetch_count
+        self.__queue_consume = queue_consume
+        self.__amqp_url = amqp_url
+        self.__credentials = pika.PlainCredentials(
+            credentials.username, credentials.password
+        )
+
+    def start_consume(self, process_message: callable):
+        try:  # Verificar se recursão não vai estourar
+            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] 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):
+        message = body.decode()
+        message_json = json.loads(message)
+        pure_message = self.__transform_message(message_json)
+        response = process_message(pure_message)
+
+        ch.basic_publish(
+            exchange='',
+            routing_key=props.reply_to,
+            properties=pika.BasicProperties(
+                correlation_id=props.correlation_id
+            ),
+            body=str(response),
+        )
+        ch.basic_ack(delivery_tag=method.delivery_tag)
+
+    def __transform_message(self, message: dict) -> Message:
+        return Message(
+            type=message.get('type', ''),
+            text=message.get('text', ''),
+            customer_id=message.get('customer_id', ''),
+            channel=message.get('channel', ''),
+            customer_phone=message.get('customer_phone', ''),
+            company_phone=message.get('company_phone', ''),
+            status=message.get('status'),
+        )

chatgraph-0.1.0/chatgraph/types/message_types.py

@@ -0,0 +1,13 @@
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class Message:
+    type: str
+    text: str
+    customer_id: str
+    channel: str
+    customer_phone: str
+    company_phone: str
+    status: Optional[str] = None

chatgraph-0.1.0/chatgraph/types/output_state.py

@@ -0,0 +1,15 @@
+from typing import Union
+
+messageTypes = Union[str, float, int, None]
+
+
+class ChatbotResponse:
+    def __init__(
+        self, message: messageTypes = None, route: str = None
+    ) -> None:
+        self.message = message
+        self.route = route
+
+class RedirectResponse:
+    def __init__(self, route: str) -> None:
+        self.route = route

chatgraph-0.1.0/chatgraph/types/route.py

@@ -0,0 +1,33 @@
+from ..error.route_error import RouteError
+
+
+class Route:
+    def __init__(self, current: str, routes: list[str]):
+        self.current = current
+        self.routes = routes
+
+    def get_previous(self) -> str:
+        """
+        Retorna o caminho anterior ao caminho atual.
+        """
+        if self.current == 'START':
+            raise RouteError('Não há caminho anterior ao START')
+
+        previous_route = '/'.join(self.current.split('/')[:-1])
+        return previous_route
+
+    def get_next(self, next_part: str) -> str:
+        """
+        Monta e retorna o próximo caminho com base na parte fornecida.
+        """
+        next_part = next_part.strip().upper()
+        next_route = f"{self.current.rstrip('/')}{next_part}"
+        if next_route not in self.routes:
+            raise RouteError(f'Rota não encontrada: {next_route}')
+        return next_route
+
+    def __str__(self):
+        return f'Route(current={self.current})'
+
+    def __repr__(self):
+        return self.__str__()

chatgraph-0.1.0/chatgraph/types/user_state.py

@@ -0,0 +1,26 @@
+from abc import ABC, abstractmethod
+
+
+class UserState(ABC):
+    @abstractmethod
+    def get_menu(self, customer_id: str):
+        pass
+
+    @abstractmethod
+    def set_menu(self, customer_id: str, menu: str):
+        pass
+
+
+class SimpleUserState(UserState):
+    def __init__(self):
+        self.states = {}
+
+    def get_menu(self, customer_id: str) -> str:
+        menu = self.states.get(customer_id, 'START')
+        if menu == 'START':
+            self.set_menu(customer_id, menu)
+        return menu
+
+    def set_menu(self, customer_id: str, menu: str|None=None) -> str:
+        if menu:
+            self.states[customer_id] = menu.upper()

chatgraph-0.1.0/pyproject.toml

@@ -0,0 +1,43 @@
+[tool.poetry]
+name = "chatgraph"
+version = "0.1.0"
+description = "A user-friendly chatbot library"
+authors = ["Irisson N. Lima <irisson.lima@verdecard.com.br>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.12"
+pika = "^1.3.2"
+
+
+[tool.poetry.group.dev.dependencies]
+ruff = "^0.5.1"
+pytest = "^8.2.2"
+pytest-cov = "^5.0.0"
+taskipy = "^1.13.0"
+
+[tool.pytest.ini_options]
+pythonpath = "."
+addopts = "-p no:warnings"
+
+[tool.ruff]
+line-length = 79
+extend-exclude = ['migrations']
+
+[tool.ruff.lint]
+preview = true
+select = ['I', 'F', 'E', 'W', 'PL', 'PT']
+
+[tool.ruff.format]
+preview = true
+quote-style = 'single'
+
+[tool.taskipy.tasks]
+test = 'pytest --cov=chatbot --cov-report=html'
+start_cov = 'start htmlcov/index.html'
+lint = 'ruff check . && check . --diff'
+format = 'ruff format . && ruff check . --fix'
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"