django-spire 0.20.3__py3-none-any.whl → 0.21.0__py3-none-any.whl

django_spire/ai/chat/intelligence/decoders/intent_decoder.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from typing import Callable, TYPE_CHECKING
+
+from dandy import Decoder
+
+from django_spire.conf import settings
+from django_spire.core.utils import get_callable_from_module_string_and_validate_arguments
+
+if TYPE_CHECKING:
+    from django.core.handlers.wsgi import WSGIRequest
+
+
+def generate_intent_decoder(
+    request: WSGIRequest,
+    default_callable: Callable | None = None
+) -> Decoder:
+    intent_dict = {}
+
+    if hasattr(settings, 'DJANGO_SPIRE_AI_INTENT_CHAT_ROUTERS'):
+        for intent_config in settings.DJANGO_SPIRE_AI_INTENT_CHAT_ROUTERS.values():
+            required_permission = intent_config.get('REQUIRED_PERMISSION')
+
+            if required_permission and not request.user.has_perm(required_permission):
+                continue
+
+            intent_description = intent_config.get('INTENT_DESCRIPTION', '')
+            chat_router_path = intent_config.get('CHAT_ROUTER')
+
+            if chat_router_path:
+                try:
+                    router_class = get_callable_from_module_string_and_validate_arguments(
+                        chat_router_path,
+                        []
+                    )
+
+                    router_instance = router_class()
+
+                    intent_dict[intent_description] = router_instance.workflow
+                except ImportError:
+                    pass
+
+    if default_callable is not None:
+        intent_dict['None of the above choices match the user\'s intent'] = default_callable
+
+    return Decoder(
+        mapping_keys_description='Intent of the User\'s Request',
+        mapping=intent_dict
+    )

django_spire/ai/chat/intelligence/workflows/chat_workflow.py

@@ -1,13 +1,7 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Callable
+from typing import TYPE_CHECKING
 
-from dandy import Bot
-from dandy.recorder import recorder_to_html_file
-
-from django_spire.ai.chat.intelligence.decoders.tools import generate_intent_decoder
-from django_spire.ai.chat.message_intel import BaseMessageIntel, DefaultMessageIntel
-from django_spire.ai.decorators import log_ai_interaction_from_recorder
 from django_spire.conf import settings
 from django_spire.core.utils import get_callable_from_module_string_and_validate_arguments
 
@@ -15,62 +9,34 @@ if TYPE_CHECKING:
     from dandy.llm.request.message import MessageHistory
     from django.core.handlers.wsgi import WSGIRequest
 
-
-def default_chat_callable(
-    request: WSGIRequest,
-    user_input: str,
-    message_history: MessageHistory | None = None
-) -> BaseMessageIntel:
-    bot = Bot()
-    return bot.llm.prompt_to_intel(
-        prompt=user_input,
-        intel_class=DefaultMessageIntel,
-        message_history=message_history,
-    )
+    from django_spire.ai.chat.message_intel import BaseMessageIntel
 
 
-@recorder_to_html_file('spire_ai_chat_workflow')
 def chat_workflow(
     request: WSGIRequest,
     user_input: str,
     message_history: MessageHistory | None = None
 ) -> BaseMessageIntel:
-    @log_ai_interaction_from_recorder(request.user)
-    def run_workflow_process(callable_: Callable) -> BaseMessageIntel | None:
-        return callable_(
-            request=request,
-            user_input=user_input,
-            message_history=message_history,
-        )
-
-    if settings.AI_CHAT_CALLABLE is not None:
-        chat_callable = get_callable_from_module_string_and_validate_arguments(
-            settings.AI_CHAT_CALLABLE,
-            ['request', 'user_input', 'message_history']
-        )
-
-        message_intel = run_workflow_process(chat_callable)
-
-    else:
+    router_key = getattr(settings, 'DJANGO_SPIRE_AI_DEFAULT_CHAT_ROUTER', 'SPIRE')
 
-        intent_decoder = generate_intent_decoder(
-            request=request,
-            default_callable=default_chat_callable,
-        )
+    chat_routers = getattr(settings, 'DJANGO_SPIRE_AI_CHAT_ROUTERS', {
+        'SPIRE': 'django_spire.ai.chat.router.SpireChatRouter'
+    })
 
-        intent_process = intent_decoder.process(user_input, max_return_values=1)[0]
+    router_path = chat_routers.get(router_key)
 
-        message_intel = run_workflow_process(intent_process)
+    if not router_path:
+        router_path = 'django_spire.ai.chat.router.SpireChatRouter'
 
-    if not isinstance(message_intel, BaseMessageIntel):
-        if message_intel is None:
-            return default_chat_callable(
-                request=request,
-                user_input=user_input,
-                message_history=message_history
-            )
+    router_class = get_callable_from_module_string_and_validate_arguments(
+        router_path,
+        []
+    )
 
-        message = f'{intent_process.__qualname__} must return an instance of a {BaseMessageIntel.__name__} sub class.'
-        raise TypeError(message)
+    router_instance = router_class()
 
-    return message_intel
+    return router_instance.process(
+        request=request,
+        user_input=user_input,
+        message_history=message_history,
+    )

django_spire/ai/chat/message_intel.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from abc import abstractmethod, ABC
+from abc import ABC, abstractmethod
 
 from dandy import BaseIntel
 from django.template.loader import render_to_string
@@ -9,18 +9,26 @@ from django.template.loader import render_to_string
 class BaseMessageIntel(BaseIntel, ABC):
     _template: str
 
-    def __init_subclass__(cls):
-        super().__init_subclass__()
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
 
-        if cls._template is None or cls._template == '':
+        template = cls.__dict__.get('_template')
+
+        if template is None and hasattr(cls, '__private_attributes__'):
+            private_attr = cls.__private_attributes__.get('_template')
+
+            if private_attr and hasattr(private_attr, 'default'):
+                template = private_attr.default
+
+        if not template:
             message = f'{cls.__module__}.{cls.__qualname__}._template must be set'
             raise ValueError(message)
 
     @abstractmethod
-    def content_to_str(self) -> str:
+    def render_to_str(self) -> str:
         raise NotImplementedError
 
-    def render_to_string(self, context_data: dict | None = None):
+    def render_template_to_str(self, context_data: dict | None = None):
         return render_to_string(
             template_name=self._template,
             context={**self.model_dump(), **(context_data or {})},
@@ -35,5 +43,5 @@ class DefaultMessageIntel(BaseMessageIntel):
     _template: str = 'django_spire/ai/chat/message/default_message.html'
     text: str
 
-    def content_to_str(self) -> str:
+    def render_to_str(self) -> str:
         return self.text

django_spire/ai/chat/models.py

@@ -4,11 +4,12 @@ from dandy.llm.request.message import MessageHistory, RoleLiteralStr
 from django.contrib.auth.models import User
 from django.db import models
 from django.utils.timezone import now
+from pydantic import ValidationError
 
+from django_spire.ai.chat.choices import MessageResponseType
 from django_spire.ai.chat.message_intel import BaseMessageIntel, DefaultMessageIntel
+from django_spire.ai.chat.querysets import ChatMessageQuerySet, ChatQuerySet
 from django_spire.ai.chat.responses import MessageResponse
-from django_spire.ai.chat.choices import MessageResponseType
-from django_spire.ai.chat.querysets import ChatQuerySet, ChatMessageQuerySet
 from django_spire.history.mixins import HistoryModelMixin
 from django_spire.utils import get_class_from_string, get_class_name_from_class
 
@@ -64,7 +65,7 @@ class Chat(HistoryModelMixin):
         for message in messages:
             message_history.add_message(
                 role=message.role,
-                content=message.intel.content_to_str()
+                content=message.intel.render_to_str()
             )
 
         return message_history
@@ -105,7 +106,7 @@ class ChatMessage(HistoryModelMixin):
     objects = ChatMessageQuerySet.as_manager()
 
     def __str__(self):
-        content = self.intel.content_to_str()
+        content = self.intel.render_to_str()
 
         if len(content) < 64:
             return content
@@ -118,7 +119,7 @@ class ChatMessage(HistoryModelMixin):
             intel_class: type[BaseMessageIntel] = get_class_from_string(self._intel_class_name)
             return intel_class.model_validate(self._intel_data)
 
-        except ImportError:
+        except (ImportError, ValidationError):
             intel_class: type[BaseMessageIntel] = DefaultMessageIntel
             return intel_class.model_validate(
                 {'text': str(self._intel_data)}

django_spire/ai/chat/router.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+from dandy import Bot, Prompt
+from dandy.recorder import recorder_to_html_file
+
+from django_spire.ai.chat.intelligence.decoders.intent_decoder import generate_intent_decoder
+from django_spire.ai.chat.message_intel import BaseMessageIntel, DefaultMessageIntel
+from django_spire.ai.decorators import log_ai_interaction_from_recorder
+from django_spire.conf import settings
+
+if TYPE_CHECKING:
+    from dandy.llm.request.message import MessageHistory
+    from django.core.handlers.wsgi import WSGIRequest
+
+
+class BaseChatRouter(ABC):
+    @abstractmethod
+    def workflow(
+        self,
+        request: WSGIRequest,
+        user_input: str,
+        message_history: MessageHistory | None = None
+    ) -> BaseMessageIntel:
+        raise NotImplementedError
+
+    @recorder_to_html_file('spire_ai_chat_workflow')
+    def process(
+        self,
+        request: WSGIRequest,
+        user_input: str,
+        message_history: MessageHistory | None = None
+    ) -> BaseMessageIntel:
+        @log_ai_interaction_from_recorder(request.user)
+        def run_workflow_process() -> BaseMessageIntel | None:
+            return self.workflow(
+                request=request,
+                user_input=user_input,
+                message_history=message_history,
+            )
+
+        message_intel = run_workflow_process()
+
+        if not isinstance(message_intel, BaseMessageIntel):
+            if message_intel is None:
+                return DefaultMessageIntel(
+                    text='I apologize, but I was unable to process your request.'
+                )
+
+            message = f'{self.__class__.__name__}.workflow must return an instance of a {BaseMessageIntel.__name__} sub class.'
+            raise TypeError(message)
+
+        return message_intel
+
+
+class SpireChatRouter(BaseChatRouter):
+    def _default_chat_callable(
+        self,
+        request: WSGIRequest,
+        user_input: str,
+        message_history: MessageHistory | None = None
+    ) -> BaseMessageIntel:
+        persona_name = getattr(settings, 'DJANGO_SPIRE_AI_PERSONA_NAME', 'AI Assistant')
+
+        system_prompt = (
+            Prompt()
+            .text(f'You are {persona_name}, a helpful AI assistant.')
+            .line_break()
+            .text('Important rules:')
+            .list([
+                f'You should always identify yourself as {persona_name}.',
+                'Please never mention being Qwen, Claude, GPT, or any other model name.',
+                'Be helpful, friendly, and professional.',
+            ])
+        )
+
+        bot = Bot()
+        bot.llm_role = system_prompt
+
+        return bot.llm.prompt_to_intel(
+            prompt=user_input,
+            intel_class=DefaultMessageIntel,
+            message_history=message_history,
+        )
+
+    def workflow(
+        self,
+        request: WSGIRequest,
+        user_input: str,
+        message_history: MessageHistory | None = None
+    ) -> BaseMessageIntel:
+        intent_decoder = generate_intent_decoder(
+            request=request,
+            default_callable=self._default_chat_callable,
+        )
+
+        intent_process = intent_decoder.process(user_input, max_return_values=1)[0]
+
+        return intent_process(
+            request=request,
+            user_input=user_input,
+            message_history=message_history
+        )

django_spire/ai/chat/templates/django_spire/ai/chat/message/message.html

@@ -19,7 +19,7 @@
             }
         }"
     >
-        {{ message_intel.content_to_str|json_script:message_intel_id }}
+        {{ message_intel.render_to_str|json_script:message_intel_id }}
 
         <div class="px-1 text-muted {{ sender_class }}" style="font-size: 0.7rem;">
             {% block message_sender %}
@@ -33,7 +33,7 @@
 
         <div class="d-inline-block px-2 py-1 rounded-3 shadow-sm {{ content_class|default:'border' }}">
             {% block message_content %}
-                {{ message_intel.content_to_str|linebreaksbr }}
+                {{ message_intel.render_to_str|linebreaksbr }}
             {% endblock %}
         </div>
 

django_spire/ai/chat/tests/test_router/test_base_chat_router.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import pytest
+
+from typing import TYPE_CHECKING
+
+from django.test import RequestFactory
+
+from django_spire.ai.chat.message_intel import BaseMessageIntel, DefaultMessageIntel
+from django_spire.ai.chat.router import BaseChatRouter
+from django_spire.core.tests.test_cases import BaseTestCase
+
+if TYPE_CHECKING:
+    from dandy.llm.request.message import MessageHistory
+    from django.core.handlers.wsgi import WSGIRequest
+
+
+class TestBaseChatRouter(BaseTestCase):
+    def setUp(self) -> None:
+        super().setUp()
+
+        self.factory = RequestFactory()
+        self.request = self.factory.get('/')
+        self.request.user = self.super_user
+
+    def test_workflow_is_abstract_method(self) -> None:
+        with pytest.raises(TypeError):
+            BaseChatRouter()
+
+    def test_process_calls_workflow(self) -> None:
+        class TestRouter(BaseChatRouter):
+            workflow_called = False
+
+            def workflow(
+                self,
+                request: WSGIRequest,
+                user_input: str,
+                message_history: MessageHistory | None = None
+            ) -> BaseMessageIntel:
+                self.workflow_called = True
+                return DefaultMessageIntel(text='Test response')
+
+        router = TestRouter()
+        result = router.process(
+            request=self.request,
+            user_input='Hello',
+            message_history=None
+        )
+
+        assert router.workflow_called
+        assert isinstance(result, DefaultMessageIntel)
+        assert result.text == 'Test response'
+
+    def test_process_validates_workflow_return_type(self) -> None:
+        class InvalidRouter(BaseChatRouter):
+            def workflow(self, request, user_input, message_history=None) -> str:
+                return 'Invalid return type'
+
+        router = InvalidRouter()
+
+        with pytest.raises(TypeError) as cm:
+            router.process(
+                request=self.request,
+                user_input='Hello',
+                message_history=None
+            )
+
+        assert 'BaseMessageIntel' in str(cm.value)
+
+    def test_process_handles_none_return(self) -> None:
+        class NoneRouter(BaseChatRouter):
+            def workflow(self, request, user_input, message_history=None) -> None:
+                return None
+
+        router = NoneRouter()
+        result = router.process(
+            request=self.request,
+            user_input='Hello',
+            message_history=None
+        )
+
+        assert isinstance(result, DefaultMessageIntel)
+        assert result.text == 'I apologize, but I was unable to process your request.'
+
+    def test_process_accepts_all_parameters(self) -> None:
+        from dandy.llm.request.message import MessageHistory
+
+        class ParamTestRouter(BaseChatRouter):
+            received_params = {}
+
+            def workflow(self, request, user_input, message_history=None) -> DefaultMessageIntel:
+                self.received_params = {
+                    'request': request,
+                    'user_input': user_input,
+                    'message_history': message_history
+                }
+                return DefaultMessageIntel(text='Success')
+
+        router = ParamTestRouter()
+        message_history = MessageHistory()
+
+        router.process(
+            request=self.request,
+            user_input='Test input',
+            message_history=message_history
+        )
+
+        assert router.received_params['request'] == self.request
+        assert router.received_params['user_input'] == 'Test input'
+        assert router.received_params['message_history'] == message_history

django_spire/ai/chat/tests/test_router/test_chat_workflow.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from unittest.mock import Mock, patch
+
+from django.test import RequestFactory, override_settings
+
+from django_spire.ai.chat.intelligence.workflows.chat_workflow import chat_workflow
+from django_spire.ai.chat.message_intel import DefaultMessageIntel
+from django_spire.ai.chat.router import BaseChatRouter
+from django_spire.core.tests.test_cases import BaseTestCase
+
+
+class MockRouter(BaseChatRouter):
+    def workflow(self, request, user_input, message_history=None) -> DefaultMessageIntel:
+        return DefaultMessageIntel(text='Mock response')
+
+
+class TestChatWorkflow(BaseTestCase):
+    def setUp(self) -> None:
+        super().setUp()
+
+        self.factory = RequestFactory()
+        self.request = self.factory.get('/')
+        self.request.user = self.super_user
+
+    @override_settings(
+        DJANGO_SPIRE_AI_DEFAULT_CHAT_ROUTER='SPIRE',
+        DJANGO_SPIRE_AI_CHAT_ROUTERS={
+            'SPIRE': 'django_spire.ai.chat.router.SpireChatRouter'
+        }
+    )
+    def test_workflow_loads_default_router(self) -> None:
+        with patch('django_spire.ai.chat.intelligence.workflows.chat_workflow.get_callable_from_module_string_and_validate_arguments') as mock_get_callable:
+            mock_router_class = Mock()
+            mock_router_instance = Mock()
+            mock_router_instance.process.return_value = DefaultMessageIntel(text='Response')
+            mock_router_class.return_value = mock_router_instance
+            mock_get_callable.return_value = mock_router_class
+
+            result = chat_workflow(
+                request=self.request,
+                user_input='Hello',
+                message_history=None
+            )
+
+            mock_get_callable.assert_called_once_with(
+                'django_spire.ai.chat.router.SpireChatRouter',
+                []
+            )
+
+            assert isinstance(result, DefaultMessageIntel)
+
+    @override_settings(
+        DJANGO_SPIRE_AI_DEFAULT_CHAT_ROUTER='CUSTOM',
+        DJANGO_SPIRE_AI_CHAT_ROUTERS={
+            'CUSTOM': 'django_spire.ai.chat.tests.test_router.test_chat_workflow.MockRouter'
+        }
+    )
+    def test_workflow_loads_custom_router(self) -> None:
+        result = chat_workflow(
+            request=self.request,
+            user_input='Hello',
+            message_history=None
+        )
+
+        assert isinstance(result, DefaultMessageIntel)
+        assert result.text == 'Mock response'
+
+    @override_settings(
+        DJANGO_SPIRE_AI_DEFAULT_CHAT_ROUTER='NONEXISTENT',
+        DJANGO_SPIRE_AI_CHAT_ROUTERS={
+            'SPIRE': 'django_spire.ai.chat.router.SpireChatRouter'
+        }
+    )
+    def test_workflow_falls_back_when_router_not_found(self) -> None:
+        with patch('django_spire.ai.chat.intelligence.workflows.chat_workflow.get_callable_from_module_string_and_validate_arguments') as mock_get_callable:
+            mock_router_class = Mock()
+            mock_router_instance = Mock()
+            mock_router_instance.process.return_value = DefaultMessageIntel(text='Fallback')
+            mock_router_class.return_value = mock_router_instance
+            mock_get_callable.return_value = mock_router_class
+
+            result = chat_workflow(
+                request=self.request,
+                user_input='Hello',
+                message_history=None
+            )
+
+            assert isinstance(result, DefaultMessageIntel)
+
+    @override_settings(
+        DJANGO_SPIRE_AI_DEFAULT_CHAT_ROUTER='TEST',
+        DJANGO_SPIRE_AI_CHAT_ROUTERS={
+            'TEST': 'django_spire.ai.chat.tests.test_router.test_chat_workflow.MockRouter'
+        }
+    )
+    def test_workflow_passes_message_history(self) -> None:
+        from dandy.llm.request.message import MessageHistory
+
+        message_history = MessageHistory()
+
+        with patch('django_spire.ai.chat.tests.test_router.test_chat_workflow.MockRouter.process') as mock_process:
+            mock_process.return_value = DefaultMessageIntel(text='Response')
+
+            chat_workflow(
+                request=self.request,
+                user_input='Hello',
+                message_history=message_history
+            )
+
+            mock_process.assert_called_once()
+            call_kwargs = mock_process.call_args[1]
+            assert call_kwargs['message_history'] == message_history