django-spire 0.20.4__py3-none-any.whl → 0.21.1__py3-none-any.whl

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

@@ -0,0 +1,147 @@
+from __future__ import annotations
+
+from unittest.mock import Mock, patch
+
+from django.contrib.auth.models import Permission, User
+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 BaseMessageIntel, DefaultMessageIntel
+from django_spire.ai.chat.router import BaseChatRouter
+from django_spire.core.tests.test_cases import BaseTestCase
+
+
+class KnowledgeRouter(BaseChatRouter):
+    def workflow(self, request, user_input, message_history=None) -> DefaultMessageIntel:
+        return DefaultMessageIntel(text='Knowledge search result')
+
+
+class SupportRouter(BaseChatRouter):
+    def workflow(self, request, user_input, message_history=None) -> DefaultMessageIntel:
+        return DefaultMessageIntel(text='Support response')
+
+
+class TestRouterIntegration(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',
+            'KNOWLEDGE': 'django_spire.ai.chat.tests.test_router.test_integration.KnowledgeRouter',
+            'SUPPORT': 'django_spire.ai.chat.tests.test_router.test_integration.SupportRouter',
+        },
+        DJANGO_SPIRE_AI_INTENT_CHAT_ROUTERS={
+            'KNOWLEDGE_SEARCH': {
+                'INTENT_DESCRIPTION': 'User asking about documentation',
+                'REQUIRED_PERMISSION': 'auth.view_user',
+                'CHAT_ROUTER': 'django_spire.ai.chat.tests.test_router.test_integration.KnowledgeRouter',
+            },
+            'SUPPORT': {
+                'INTENT_DESCRIPTION': 'User needs support',
+                'CHAT_ROUTER': 'django_spire.ai.chat.tests.test_router.test_integration.SupportRouter',
+            }
+        }
+    )
+    def test_intent_routing_with_permission(self) -> None:
+        permission = Permission.objects.get(codename='view_user')
+        self.super_user.user_permissions.add(permission)
+
+        with patch('django_spire.ai.chat.router.generate_intent_decoder') as mock_decoder:
+            mock_decoder_instance = type('MockDecoder', (), {
+                'process': lambda self, user_input, **kwargs: [
+                    lambda **kwargs: KnowledgeRouter().workflow(**kwargs)
+                ]
+            })()
+
+            mock_decoder.return_value = mock_decoder_instance
+
+            result = chat_workflow(
+                request=self.request,
+                user_input='Tell me about the documentation',
+                message_history=None
+            )
+
+            assert isinstance(result, BaseMessageIntel)
+
+    @override_settings(
+        DJANGO_SPIRE_AI_DEFAULT_CHAT_ROUTER='SUPPORT',
+        DJANGO_SPIRE_AI_CHAT_ROUTERS={
+            'SUPPORT': 'django_spire.ai.chat.tests.test_router.test_integration.SupportRouter',
+        }
+    )
+    def test_direct_router_selection(self) -> None:
+        result = chat_workflow(
+            request=self.request,
+            user_input='I need help',
+            message_history=None
+        )
+
+        assert isinstance(result, DefaultMessageIntel)
+        assert result.text == 'Support response'
+
+    @override_settings(
+        DJANGO_SPIRE_AI_INTENT_CHAT_ROUTERS={
+            'RESTRICTED': {
+                'INTENT_DESCRIPTION': 'Restricted intent',
+                'REQUIRED_PERMISSION': 'auth.delete_user',
+                'CHAT_ROUTER': 'django_spire.ai.chat.tests.test_router.test_integration.SupportRouter',
+            }
+        }
+    )
+    def test_intent_excluded_without_permission(self) -> None:
+        from django_spire.ai.chat.intelligence.decoders.intent_decoder import generate_intent_decoder
+
+        regular_user = User.objects.create_user(username='regular', password='test')
+
+        request = self.factory.get('/')
+        request.user = regular_user
+
+        decoder = generate_intent_decoder(request=request, default_callable=None)
+
+        assert 'Restricted intent' not in decoder.mapping
+
+    @override_settings(
+        DJANGO_SPIRE_AI_DEFAULT_CHAT_ROUTER='KNOWLEDGE',
+        DJANGO_SPIRE_AI_CHAT_ROUTERS={
+            'KNOWLEDGE': 'django_spire.ai.chat.tests.test_router.test_integration.KnowledgeRouter',
+        }
+    )
+    def test_end_to_end_workflow(self) -> None:
+        from dandy.llm.request.message import MessageHistory
+
+        message_history = MessageHistory()
+        message_history.add_message(role='user', content='Previous message')
+
+        result = chat_workflow(
+            request=self.request,
+            user_input='Current message',
+            message_history=message_history
+        )
+
+        assert isinstance(result, BaseMessageIntel)
+        assert isinstance(result, DefaultMessageIntel)
+
+    @override_settings(
+        DJANGO_SPIRE_AI_CHAT_ROUTERS={}
+    )
+    def test_workflow_handles_empty_routers(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='Test',
+                message_history=None
+            )
+
+            assert isinstance(result, DefaultMessageIntel)

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

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+from unittest.mock import Mock
+
+from django.contrib.auth.models import Permission, User
+from django.test import RequestFactory, override_settings
+
+from django_spire.ai.chat.intelligence.decoders.intent_decoder import generate_intent_decoder
+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 TestRouter(BaseChatRouter):
+    def workflow(self, request, user_input, message_history=None) -> DefaultMessageIntel:
+        return DefaultMessageIntel(text='Test response')
+
+
+class TestIntentDecoder(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_INTENT_CHAT_ROUTERS={})
+    def test_decoder_with_no_intents(self) -> None:
+        decoder = generate_intent_decoder(
+            request=self.request,
+            default_callable=lambda **kwargs: DefaultMessageIntel(text='Default')
+        )
+
+        assert decoder is not None
+        assert len(decoder.mapping) == 1
+
+    @override_settings(
+        DJANGO_SPIRE_AI_INTENT_CHAT_ROUTERS={
+            'TEST_INTENT': {
+                'INTENT_DESCRIPTION': 'Test intent description',
+                'CHAT_ROUTER': 'django_spire.ai.chat.tests.test_router.test_intent_decoder.TestRouter',
+            }
+        }
+    )
+    def test_decoder_adds_intent_without_permission(self) -> None:
+        decoder = generate_intent_decoder(
+            request=self.request,
+            default_callable=None
+        )
+
+        assert len(decoder.mapping) == 1
+        assert 'Test intent description' in decoder.mapping
+
+    @override_settings(
+        DJANGO_SPIRE_AI_INTENT_CHAT_ROUTERS={
+            'TEST_INTENT': {
+                'INTENT_DESCRIPTION': 'Test intent with permission',
+                'REQUIRED_PERMISSION': 'auth.add_user',
+                'CHAT_ROUTER': 'django_spire.ai.chat.tests.test_router.test_intent_decoder.TestRouter',
+            }
+        }
+    )
+    def test_decoder_checks_required_permission(self) -> None:
+        permission = Permission.objects.get(codename='add_user')
+        self.super_user.user_permissions.add(permission)
+
+        decoder = generate_intent_decoder(
+            request=self.request,
+            default_callable=None
+        )
+
+        assert 'Test intent with permission' in decoder.mapping
+
+    @override_settings(
+        DJANGO_SPIRE_AI_INTENT_CHAT_ROUTERS={
+            'TEST_INTENT': {
+                'INTENT_DESCRIPTION': 'Test intent with permission',
+                'REQUIRED_PERMISSION': 'auth.add_user',
+                'CHAT_ROUTER': 'django_spire.ai.chat.tests.test_router.test_intent_decoder.TestRouter',
+            }
+        }
+    )
+    def test_decoder_excludes_intent_without_permission(self) -> None:
+        regular_user = User.objects.create_user(username='regular', password='test')
+
+        request = self.factory.get('/')
+        request.user = regular_user
+
+        decoder = generate_intent_decoder(
+            request=request,
+            default_callable=None
+        )
+
+        assert 'Test intent with permission' not in decoder.mapping
+
+    @override_settings(
+        DJANGO_SPIRE_AI_INTENT_CHAT_ROUTERS={
+            'INVALID_ROUTER': {
+                'INTENT_DESCRIPTION': 'Invalid router',
+                'CHAT_ROUTER': 'non.existent.router.InvalidRouter',
+            }
+        }
+    )
+    def test_decoder_handles_import_error(self) -> None:
+        decoder = generate_intent_decoder(
+            request=self.request,
+            default_callable=None
+        )
+
+        assert 'Invalid router' not in decoder.mapping
+
+    def test_decoder_adds_default_callable(self) -> None:
+        default_callable = Mock()
+
+        decoder = generate_intent_decoder(
+            request=self.request,
+            default_callable=default_callable
+        )
+
+        assert "None of the above choices match the user's intent" in decoder.mapping
+
+    @override_settings(
+        DJANGO_SPIRE_AI_INTENT_CHAT_ROUTERS={
+            'INTENT_1': {
+                'INTENT_DESCRIPTION': 'First intent',
+                'CHAT_ROUTER': 'django_spire.ai.chat.tests.test_router.test_intent_decoder.TestRouter',
+            },
+            'INTENT_2': {
+                'INTENT_DESCRIPTION': 'Second intent',
+                'CHAT_ROUTER': 'django_spire.ai.chat.tests.test_router.test_intent_decoder.TestRouter',
+            }
+        }
+    )
+    def test_decoder_adds_multiple_intents(self) -> None:
+        decoder = generate_intent_decoder(
+            request=self.request,
+            default_callable=None
+        )
+
+        assert 'First intent' in decoder.mapping
+        assert 'Second intent' in decoder.mapping
+        assert len(decoder.mapping) == 2

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

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import pytest
+
+from django_spire.ai.chat.message_intel import BaseMessageIntel, DefaultMessageIntel
+from django_spire.core.tests.test_cases import BaseTestCase
+
+
+class CustomMessageIntel(BaseMessageIntel):
+    _template: str = 'django_spire/ai/chat/message/default_message.html'
+    text: str
+    extra_data: str = 'Extra'
+
+    def render_to_str(self) -> str:
+        return f'{self.text} - {self.extra_data}'
+
+
+class TestMessageIntel(BaseTestCase):
+    def test_default_message_intel_has_template(self) -> None:
+        intel = DefaultMessageIntel(text='Test')
+        assert intel.template == 'django_spire/ai/chat/message/default_message.html'
+
+    def test_default_message_intel_render_to_str(self) -> None:
+        intel = DefaultMessageIntel(text='Hello World')
+        result = intel.render_to_str()
+
+        assert result == 'Hello World'
+
+    def test_custom_message_intel_render_to_str(self) -> None:
+        intel = CustomMessageIntel(text='Test', extra_data='Custom')
+        result = intel.render_to_str()
+
+        assert result == 'Test - Custom'
+
+    def test_render_template_to_str_renders_django_template(self) -> None:
+        intel = DefaultMessageIntel(text='Hello')
+        result = intel.render_template_to_str()
+
+        assert isinstance(result, str)
+        assert len(result) > 0
+
+    def test_render_template_to_str_with_context(self) -> None:
+        intel = DefaultMessageIntel(text='Test')
+        result = intel.render_template_to_str(context_data={'extra': 'data'})
+
+        assert isinstance(result, str)
+
+    def test_template_property(self) -> None:
+        intel = DefaultMessageIntel(text='Test')
+
+        assert intel.template == intel._template
+
+    def test_message_intel_raises_without_template(self) -> None:
+        with pytest.raises(ValueError):
+            class NoTemplateIntel(BaseMessageIntel):
+                _template = None
+
+                def render_to_str(self) -> str:
+                    return 'test'
+
+    def test_message_intel_raises_with_empty_template(self) -> None:
+        with pytest.raises(ValueError):
+            class EmptyTemplateIntel(BaseMessageIntel):
+                _template = ''
+
+                def render_to_str(self) -> str:
+                    return 'test'

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

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from unittest.mock import Mock, patch
+
+from django.test import RequestFactory, override_settings
+
+from django_spire.ai.chat.message_intel import DefaultMessageIntel
+from django_spire.ai.chat.router import SpireChatRouter
+from django_spire.core.tests.test_cases import BaseTestCase
+
+
+class TestSpireChatRouter(BaseTestCase):
+    def setUp(self) -> None:
+        super().setUp()
+        self.factory = RequestFactory()
+        self.request = self.factory.get('/')
+        self.request.user = self.super_user
+
+    def test_router_can_be_instantiated(self) -> None:
+        router = SpireChatRouter()
+        assert isinstance(router, SpireChatRouter)
+
+    def test_default_chat_callable_returns_message_intel(self) -> None:
+        router = SpireChatRouter()
+
+        with patch('django_spire.ai.chat.router.Bot') as MockBot:
+            mock_bot_instance = Mock()
+            MockBot.return_value = mock_bot_instance
+            mock_bot_instance.llm.prompt_to_intel.return_value = DefaultMessageIntel(text='Response')
+
+            result = router._default_chat_callable(
+                request=self.request,
+                user_input='Hello',
+                message_history=None
+            )
+
+            assert isinstance(result, DefaultMessageIntel)
+            mock_bot_instance.llm.prompt_to_intel.assert_called_once()
+
+    @override_settings(DJANGO_SPIRE_AI_PERSONA_NAME='Test Bot')
+    def test_default_callable_uses_persona_name(self) -> None:
+        router = SpireChatRouter()
+
+        with patch('django_spire.ai.chat.router.Bot') as MockBot:
+            mock_bot_instance = Mock()
+            MockBot.return_value = mock_bot_instance
+            mock_bot_instance.llm.prompt_to_intel.return_value = DefaultMessageIntel(text='Response')
+
+            router._default_chat_callable(
+                request=self.request,
+                user_input='Hello',
+                message_history=None
+            )
+
+            assert MockBot.called
+
+    def test_workflow_uses_intent_decoder(self) -> None:
+        router = SpireChatRouter()
+
+        with patch('django_spire.ai.chat.router.generate_intent_decoder') as mock_decoder:
+            mock_decoder_instance = Mock()
+            mock_decoder.return_value = mock_decoder_instance
+            mock_decoder_instance.process.return_value = [lambda **kwargs: DefaultMessageIntel(text='Response')]
+
+            result = router.workflow(
+                request=self.request,
+                user_input='Hello',
+                message_history=None
+            )
+
+            mock_decoder.assert_called_once()
+            assert isinstance(result, DefaultMessageIntel)
+
+    @override_settings(DJANGO_SPIRE_AI_INTENT_CHAT_ROUTERS={})
+    def test_workflow_with_no_intent_routers(self) -> None:
+        router = SpireChatRouter()
+
+        with patch.object(router, '_default_chat_callable') as mock_default:
+            mock_default.return_value = DefaultMessageIntel(text='Default response')
+
+            with patch('django_spire.ai.chat.router.generate_intent_decoder') as mock_decoder:
+                mock_decoder_instance = Mock()
+                mock_decoder.return_value = mock_decoder_instance
+                mock_decoder_instance.process.return_value = [mock_default]
+
+                result = router.workflow(
+                    request=self.request,
+                    user_input='Hello',
+                    message_history=None
+                )
+
+                assert isinstance(result, DefaultMessageIntel)

django_spire/ai/chat/tests/test_urls/test_json_urls.py

@@ -20,4 +20,4 @@ class ChatJsonUrlTests(BaseTestCase):
             content_type='application/json'
         )
 
-        self.assertEqual(response.status_code, 200)
+        assert response.status_code == 200

django_spire/ai/chat/views/message_request_views.py

@@ -4,7 +4,6 @@ import json
 
 from typing import TYPE_CHECKING
 
-from django.conf import settings
 from django.http import HttpResponse
 from django.utils.timezone import now
 
@@ -12,6 +11,7 @@ from django_spire.ai.chat.choices import MessageResponseType
 from django_spire.ai.chat.message_intel import DefaultMessageIntel
 from django_spire.ai.chat.models import Chat
 from django_spire.ai.chat.responses import MessageResponse, MessageResponseGroup
+from django_spire.conf import settings
 
 if TYPE_CHECKING:
     from django.core.handlers.wsgi import WSGIRequest
@@ -59,10 +59,12 @@ def request_message_render_view(request: WSGIRequest) -> HttpResponse:
 
     chat.add_message_response(user_message_response)
 
+    persona_name = getattr(settings, 'DJANGO_SPIRE_AI_PERSONA_NAME', 'AI Assistant')
+
     message_response_group.add_message_response(
         MessageResponse(
             type=MessageResponseType.LOADING_RESPONSE,
-            sender='Spire',
+            sender=persona_name,
             message_intel=DefaultMessageIntel(
                 text=body_data['message_body']
             ),
@@ -74,7 +76,7 @@ def request_message_render_view(request: WSGIRequest) -> HttpResponse:
         message_response_group.render_to_html_string(
             context_data={
                 "chat_id": chat.id,
-                "chat_workflow_name": settings.AI_PERSONA_NAME,
+                "chat_workflow_name": persona_name,
             }
         )
     )

django_spire/ai/chat/views/message_response_views.py

@@ -8,10 +8,10 @@ from django.conf import settings
 from django.http import HttpResponse
 from django.utils.timezone import now
 
+from django_spire.ai.chat.choices import MessageResponseType
 from django_spire.ai.chat.intelligence.workflows.chat_workflow import chat_workflow
 from django_spire.ai.chat.models import Chat
 from django_spire.ai.chat.responses import MessageResponse
-from django_spire.ai.chat.choices import MessageResponseType
 
 if TYPE_CHECKING:
     from django.core.handlers.wsgi import WSGIRequest
@@ -33,7 +33,7 @@ def response_message_render_view(request: WSGIRequest) -> HttpResponse:
 
     response_message = MessageResponse(
         type=MessageResponseType.RESPONSE,
-        sender=settings.AI_PERSONA_NAME,
+        sender=getattr(settings, 'DJANGO_SPIRE_AI_PERSONA_NAME', 'AI Assistant'),
         message_intel=message_intel,
         synthesis_speech=body_data.get('synthesis_speech', False),
         message_timestamp=formatted_timestamp

django_spire/ai/sms/intelligence/workflows/sms_conversation_workflow.py

@@ -8,20 +8,20 @@ from django_spire.ai.chat.intelligence.workflows.chat_workflow import chat_workf
 from django_spire.ai.sms.intel import SmsIntel
 
 if TYPE_CHECKING:
-    from django.core.handlers.wsgi import WSGIRequest
     from dandy.llm.request.message import MessageHistory
+    from django.core.handlers.wsgi import WSGIRequest
 
 
 @recorder_to_html_file('spire_ai_sms_conversation_workflow')
 def sms_conversation_workflow(
     request: WSGIRequest, user_input: str, message_history: MessageHistory | None = None, actor: str | None = None
 ) -> SmsIntel:
+    message_intel = chat_workflow(
+        request,
+        user_input=user_input,
+        message_history=message_history,
+    )
+
     return SmsIntel(
-        body=str(
-            chat_workflow(
-                request,
-                user_input=user_input,
-                message_history=message_history,
-            )
-        )
+        body=message_intel.render_to_str()
     )

django_spire/ai/sms/models.py

@@ -5,7 +5,7 @@ from django.contrib.auth.models import User
 from django.db import models
 from django.utils.timezone import now
 
-from django_spire.ai.sms.querysets import SmsMessageQuerySet, SmsConversationQuerySet
+from django_spire.ai.sms.querysets import SmsConversationQuerySet, SmsMessageQuerySet
 from django_spire.history.mixins import HistoryModelMixin
 
 

django_spire/ai/tests/test_ai.py

@@ -25,4 +25,4 @@ class AiTestCase(BaseTestCase):
 
         horse_intel = generate_horse_intel('Make me a magical horse that grants wishes!')
 
-        self.assertNotEqual(horse_intel.first_name, '')
+        assert horse_intel.first_name != ''

django_spire/consts.py

@@ -1,4 +1,4 @@
-__VERSION__ = '0.20.4'
+__VERSION__ = '0.21.1'
 
 MAINTENANCE_MODE_SETTINGS_NAME = 'MAINTENANCE_MODE'
 

django_spire/core/static/django_spire/css/app-navigation.css

@@ -82,14 +82,14 @@
 }
 
 .side-navigation-fade-bottom {
-    background: linear-gradient(to top, var(--app-side-navigation-bg-color) 0%, var(--app-side-navigation-bg-color) 50%, transparent 100%);
-    height: 100px;
+    background: linear-gradient(to top, var(--app-side-navigation-bg-color) 0%, transparent 100%);
+    height: 60px;
     pointer-events: none;
 }
 
 .side-navigation-fade-top {
-    background: linear-gradient(to bottom, var(--app-side-navigation-bg-color) 0%, var(--app-side-navigation-bg-color) 50%, transparent 100%);
-    height: 75px;
+    background: linear-gradient(to bottom, var(--app-side-navigation-bg-color) 0%, transparent 100%);
+    height: 60px;
     pointer-events: none;
 }
 

django_spire/core/static/django_spire/css/app-side-panel.css

@@ -5,25 +5,6 @@
     top: var(--app-top-navigation-height);
 }
 
-.btn-close-panel {
-    align-items: center;
-    background: transparent;
-    border: none;
-    border-radius: 50%;
-    color: var(--app-primary);
-    cursor: pointer;
-    display: flex;
-    height: 28px;
-    justify-content: center;
-    transition: background 0.2s ease, color 0.2s ease;
-    width: 28px;
-}
-
-.btn-close-panel:hover {
-    background: var(--app-primary);
-    color: var(--app-default-button-text-color);
-}
-
 .panel-toggle-container {
     height: 30px;
     position: fixed;
@@ -50,32 +31,6 @@
     width: 30px !important;
 }
 
-.side-panel-transition-enter {
-    transition: opacity 0.3s ease;
-}
-
-.side-panel-transition-enter-start-left,
-.side-panel-transition-enter-start-right {
-    opacity: 0;
-}
-
-.side-panel-transition-enter-end {
-    opacity: 1;
-}
-
-.side-panel-transition-leave {
-    transition: opacity 0.3s ease;
-}
-
-.side-panel-transition-leave-start {
-    opacity: 1;
-}
-
-.side-panel-transition-leave-end-left,
-.side-panel-transition-leave-end-right {
-    opacity: 0;
-}
-
 @media (min-width: 992px) {
     .panel-toggle-container-left {
         left: var(--app-side-navigation-width);