django-spire 0.23.6__py3-none-any.whl → 0.23.8__py3-none-any.whl

django_spire/ai/admin.py

@@ -30,17 +30,17 @@ class AiUsageAdmin(AiUsageAdminMixin):
         return [field.name for field in self.model._meta.fields]
 
     def view_interactions_link(
-            self,
-            ai_usage: models.AiUsage,
-            was_successful: bool | None = None,
+        self,
+        ai_usage: models.AiUsage,
+        was_successful: bool | None = None
     ) -> str:
         was_successful_filter = '' if was_successful is None else f'&was_successful__exact={int(was_successful)}'
 
         url = (
-                reverse("admin:django_spire_ai_aiinteraction_changelist")
-                + "?"
-                + urlencode({"ai_usage__id": f"{ai_usage.id}"})
-                + was_successful_filter
+            reverse("admin:django_spire_ai_aiinteraction_changelist")
+            + "?"
+            + urlencode({"ai_usage__id": f"{ai_usage.id}"})
+            + was_successful_filter
         )
 
         if was_successful is None:
@@ -57,16 +57,16 @@ class AiUsageAdmin(AiUsageAdminMixin):
     view_interactions_link.short_description = "All"
 
     def view_successful_interactions_link(
-            self,
-            ai_usage: models.AiUsage,
+        self,
+        ai_usage: models.AiUsage
     ) -> str:
         return self.view_interactions_link(ai_usage, was_successful=True)
 
     view_successful_interactions_link.short_description = "Successful"
 
     def view_failed_interactions_link(
-            self,
-            ai_usage: models.AiUsage,
+        self,
+        ai_usage: models.AiUsage
     ) -> str:
         return self.view_interactions_link(ai_usage, was_successful=False)
 

django_spire/ai/chat/apps.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from django.apps import AppConfig
+
 from django_spire.utils import check_required_apps
 
 

django_spire/ai/chat/templates/django_spire/ai/chat/widget/dialog_widget.html

@@ -101,7 +101,7 @@
                 <div class="col-12 overflow-auto p-4" style="{{ dialog_height|default:'height: calc(100vh - 90px - var(--app-top-navigation-height));' }}" x-ref="target_div"></div>
             </div>
 
-            <div class="row">
+            <div class="row pe-5">
                 <div class="col-auto text-center ps-2 pe-1">
                     <button @click="start_listening()" class="btn btn-app-primary-outlined" x-show="!speech_listening">
                         <i class="bi bi-mic"></i>

django_spire/ai/chat/tests/factories.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from django_spire.ai.chat.models import Chat
+
+if TYPE_CHECKING:
+    from django.contrib.auth.models import User
+
+
+def create_test_chat(user: User) -> Chat:
+    return Chat.objects.create(
+        user=user,
+        name='New Exciting Chat!'
+    )

django_spire/ai/chat/tests/test_controller.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from django.contrib.auth.models import Permission, User
+from django.test import RequestFactory
+
+from django_spire.ai.chat.auth.controller import BaseAiChatAuthController
+from django_spire.core.tests.test_cases import BaseTestCase
+
+
+class BaseAiChatAuthControllerTests(BaseTestCase):
+    def setUp(self) -> None:
+        super().setUp()
+
+        self.factory = RequestFactory()
+        self.request = self.factory.get('/')
+        self.request.user = self.super_user
+
+    def test_can_delete_with_permission(self) -> None:
+        permission = Permission.objects.get(codename='delete_chat')
+        self.super_user.user_permissions.add(permission)
+
+        self.super_user = type(self.super_user).objects.get(pk=self.super_user.pk)
+        self.request.user = self.super_user
+
+        controller = BaseAiChatAuthController(self.request)
+
+        assert controller.can_delete() is True
+
+    def test_can_delete_without_permission(self) -> None:
+        regular_user = User.objects.create_user(
+            username='regular_user',
+            password='testpass123'  # noqa: S106
+        )
+
+        request = self.factory.get('/')
+        request.user = regular_user
+
+        controller = BaseAiChatAuthController(request)
+
+        assert controller.can_delete() is False
+
+    def test_controller_has_request(self) -> None:
+        controller = BaseAiChatAuthController(self.request)
+
+        assert controller.request == self.request

django_spire/ai/chat/tests/test_models.py

@@ -0,0 +1,301 @@
+from __future__ import annotations
+
+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
+from django_spire.core.tests.test_cases import BaseTestCase
+
+
+class ChatModelTests(BaseTestCase):
+    def test_chat_creation(self) -> None:
+        chat = Chat.objects.create(
+            user=self.super_user,
+            name='Test Chat'
+        )
+
+        assert chat.name == 'Test Chat'
+        assert chat.user == self.super_user
+
+    def test_chat_str_short_name(self) -> None:
+        chat = Chat.objects.create(
+            user=self.super_user,
+            name='Short Name'
+        )
+
+        assert str(chat) == 'Short Name'
+
+    def test_chat_str_long_name(self) -> None:
+        long_name = 'A' * 100
+        chat = Chat.objects.create(
+            user=self.super_user,
+            name=long_name
+        )
+
+        assert len(str(chat)) == 51
+        assert str(chat).endswith('...')
+
+    def test_chat_name_shortened_short(self) -> None:
+        chat = Chat.objects.create(
+            user=self.super_user,
+            name='Short'
+        )
+
+        assert chat.name_shortened == 'Short'
+
+    def test_chat_name_shortened_long(self) -> None:
+        long_name = 'A' * 50
+        chat = Chat.objects.create(
+            user=self.super_user,
+            name=long_name
+        )
+
+        assert len(chat.name_shortened) == 27
+        assert chat.name_shortened.endswith('...')
+
+    def test_chat_is_empty(self) -> None:
+        chat = Chat.objects.create(
+            user=self.super_user,
+            name='Empty Chat'
+        )
+
+        assert chat.is_empty
+
+    def test_chat_is_not_empty(self) -> None:
+        chat = Chat.objects.create(
+            user=self.super_user,
+            name='Chat with messages'
+        )
+
+        message_response = MessageResponse(
+            type=MessageResponseType.REQUEST,
+            sender='User',
+            message_intel=DefaultMessageIntel(text='Hello')
+        )
+        chat.add_message_response(message_response)
+
+        assert not chat.is_empty
+
+    def test_add_message_response(self) -> None:
+        chat = Chat.objects.create(
+            user=self.super_user,
+            name='Test Chat'
+        )
+
+        message_response = MessageResponse(
+            type=MessageResponseType.REQUEST,
+            sender='User',
+            message_intel=DefaultMessageIntel(text='Test message')
+        )
+        chat.add_message_response(message_response)
+
+        assert chat.messages.count() == 1
+
+    def test_add_message_response_updates_last_message_datetime(self) -> None:
+        chat = Chat.objects.create(
+            user=self.super_user,
+            name='Test Chat'
+        )
+
+        initial_datetime = chat.last_message_datetime
+
+        message_response = MessageResponse(
+            type=MessageResponseType.REQUEST,
+            sender='User',
+            message_intel=DefaultMessageIntel(text='Test')
+        )
+        chat.add_message_response(message_response)
+        chat.refresh_from_db()
+
+        assert chat.last_message_datetime >= initial_datetime
+
+    def test_generate_message_history(self) -> None:
+        chat = Chat.objects.create(
+            user=self.super_user,
+            name='Test Chat'
+        )
+
+        chat.add_message_response(MessageResponse(
+            type=MessageResponseType.REQUEST,
+            sender='User',
+            message_intel=DefaultMessageIntel(text='Hello')
+        ))
+        chat.add_message_response(MessageResponse(
+            type=MessageResponseType.RESPONSE,
+            sender='Assistant',
+            message_intel=DefaultMessageIntel(text='Hi there')
+        ))
+
+        message_history = chat.generate_message_history()
+
+        assert message_history is not None
+
+    def test_generate_message_history_exclude_last(self) -> None:
+        chat = Chat.objects.create(
+            user=self.super_user,
+            name='Test Chat'
+        )
+
+        chat.add_message_response(MessageResponse(
+            type=MessageResponseType.REQUEST,
+            sender='User',
+            message_intel=DefaultMessageIntel(text='Message 1')
+        ))
+        chat.add_message_response(MessageResponse(
+            type=MessageResponseType.REQUEST,
+            sender='User',
+            message_intel=DefaultMessageIntel(text='Message 2')
+        ))
+
+        message_history = chat.generate_message_history(exclude_last_message=True)
+
+        assert message_history is not None
+
+
+class ChatMessageModelTests(BaseTestCase):
+    def setUp(self) -> None:
+        super().setUp()
+
+        self.chat = Chat.objects.create(
+            user=self.super_user,
+            name='Test Chat'
+        )
+
+    def test_chat_message_str_short(self) -> None:
+        message_response = MessageResponse(
+            type=MessageResponseType.REQUEST,
+            sender='User',
+            message_intel=DefaultMessageIntel(text='Short')
+        )
+        self.chat.add_message_response(message_response)
+
+        message = self.chat.messages.first()
+
+        assert str(message) == 'Short'
+
+    def test_chat_message_str_long(self) -> None:
+        long_text = 'A' * 100
+        message_response = MessageResponse(
+            type=MessageResponseType.REQUEST,
+            sender='User',
+            message_intel=DefaultMessageIntel(text=long_text)
+        )
+        self.chat.add_message_response(message_response)
+
+        message = self.chat.messages.first()
+
+        assert len(str(message)) == 67
+        assert str(message).endswith('...')
+
+    def test_chat_message_intel_property(self) -> None:
+        message_response = MessageResponse(
+            type=MessageResponseType.REQUEST,
+            sender='User',
+            message_intel=DefaultMessageIntel(text='Test intel')
+        )
+        self.chat.add_message_response(message_response)
+
+        message = self.chat.messages.first()
+
+        assert isinstance(message.intel, DefaultMessageIntel)
+        assert message.intel.text == 'Test intel'
+
+    def test_chat_message_role_request(self) -> None:
+        message_response = MessageResponse(
+            type=MessageResponseType.REQUEST,
+            sender='User',
+            message_intel=DefaultMessageIntel(text='Test')
+        )
+        self.chat.add_message_response(message_response)
+
+        message = self.chat.messages.first()
+
+        assert message.role == 'user'
+
+    def test_chat_message_role_response(self) -> None:
+        message_response = MessageResponse(
+            type=MessageResponseType.RESPONSE,
+            sender='Assistant',
+            message_intel=DefaultMessageIntel(text='Test')
+        )
+        self.chat.add_message_response(message_response)
+
+        message = self.chat.messages.first()
+
+        assert message.role == 'assistant'
+
+    def test_chat_message_to_message_response(self) -> None:
+        original_response = MessageResponse(
+            type=MessageResponseType.REQUEST,
+            sender='User',
+            message_intel=DefaultMessageIntel(text='Test')
+        )
+        self.chat.add_message_response(original_response)
+
+        message = self.chat.messages.first()
+        converted_response = message.to_message_response()
+
+        assert isinstance(converted_response, MessageResponse)
+        assert converted_response.type == MessageResponseType.REQUEST
+        assert converted_response.sender == 'User'
+
+
+class ChatQuerySetTests(BaseTestCase):
+    def test_by_user(self) -> None:
+        Chat.objects.create(user=self.super_user, name='User Chat')
+
+        result = Chat.objects.by_user(self.super_user)
+
+        assert result.count() == 1
+
+    def test_search(self) -> None:
+        Chat.objects.create(user=self.super_user, name='Python Programming')
+        Chat.objects.create(user=self.super_user, name='Django Framework')
+
+        result = Chat.objects.search('Python')
+
+        assert result.count() == 1
+        assert result.first().name == 'Python Programming'
+
+    def test_search_case_insensitive(self) -> None:
+        Chat.objects.create(user=self.super_user, name='Python Programming')
+
+        result = Chat.objects.search('python')
+
+        assert result.count() == 1
+
+
+class ChatMessageQuerySetTests(BaseTestCase):
+    def setUp(self) -> None:
+        super().setUp()
+
+        self.chat = Chat.objects.create(
+            user=self.super_user,
+            name='Test Chat'
+        )
+
+    def test_newest_by_count(self) -> None:
+        for i in range(25):
+            message_response = MessageResponse(
+                type=MessageResponseType.REQUEST,
+                sender='User',
+                message_intel=DefaultMessageIntel(text=f'Message {i}')
+            )
+            self.chat.add_message_response(message_response)
+
+        messages = self.chat.messages.newest_by_count(20)
+
+        assert len(messages) == 20
+
+    def test_newest_by_count_reversed(self) -> None:
+        for i in range(5):
+            message_response = MessageResponse(
+                type=MessageResponseType.REQUEST,
+                sender='User',
+                message_intel=DefaultMessageIntel(text=f'Message {i}')
+            )
+            self.chat.add_message_response(message_response)
+
+        messages = self.chat.messages.newest_by_count_reversed(5)
+
+        assert len(messages) == 5

django_spire/ai/chat/tests/test_prompts.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from django_spire.ai.chat.intelligence.prompts import chat_system_prompt
+from django_spire.ai.context.models import Organization
+from django_spire.core.tests.test_cases import BaseTestCase
+
+
+class ChatPromptsTests(BaseTestCase):
+    def test_chat_system_prompt_returns_prompt(self) -> None:
+        prompt = chat_system_prompt()
+
+        assert prompt is not None
+
+    def test_chat_system_prompt_contains_assistant_text(self) -> None:
+        prompt = chat_system_prompt()
+        prompt_str = prompt.to_str()
+
+        assert 'chat assistant' in prompt_str.lower()
+
+    def test_chat_system_prompt_contains_rules(self) -> None:
+        prompt = chat_system_prompt()
+        prompt_str = prompt.to_str()
+
+        assert 'rules' in prompt_str.lower()
+
+    def test_chat_system_prompt_with_organization(self) -> None:
+        Organization.objects.create(
+            name='Test Company',
+            description='A test company for testing purposes'
+        )
+
+        prompt = chat_system_prompt()
+        prompt_str = prompt.to_str()
+
+        assert 'organization' in prompt_str.lower()
+
+    def test_chat_system_prompt_without_organization(self) -> None:
+        prompt = chat_system_prompt()
+        prompt_str = prompt.to_str()
+
+        assert prompt_str is not None
+        assert len(prompt_str) > 0
+
+    def test_chat_system_prompt_ai_illusion_rule(self) -> None:
+        prompt = chat_system_prompt()
+        prompt_str = prompt.to_str()
+
+        assert 'ai' in prompt_str.lower() or 'illusion' in prompt_str.lower()

django_spire/ai/chat/tests/test_responses.py

@@ -0,0 +1,208 @@
+from __future__ import annotations
+
+from django_spire.ai.chat.choices import MessageResponseType
+from django_spire.ai.chat.message_intel import DefaultMessageIntel
+from django_spire.ai.chat.responses import MessageResponse, MessageResponseGroup
+from django_spire.core.tests.test_cases import BaseTestCase
+
+
+class MessageResponseTests(BaseTestCase):
+    def test_message_response_creation(self) -> None:
+        response = MessageResponse(
+            type=MessageResponseType.REQUEST,
+            sender='User',
+            message_intel=DefaultMessageIntel(text='Hello')
+        )
+
+        assert response.type == MessageResponseType.REQUEST
+        assert response.sender == 'User'
+        assert response.message_intel.text == 'Hello'
+
+    def test_message_response_with_timestamp(self) -> None:
+        response = MessageResponse(
+            type=MessageResponseType.REQUEST,
+            sender='User',
+            message_intel=DefaultMessageIntel(text='Hello'),
+            message_timestamp='Jan 01, 2024 at 12:00 PM'
+        )
+
+        assert response.message_timestamp == 'Jan 01, 2024 at 12:00 PM'
+
+    def test_message_response_with_synthesis_speech(self) -> None:
+        response = MessageResponse(
+            type=MessageResponseType.RESPONSE,
+            sender='Assistant',
+            message_intel=DefaultMessageIntel(text='Hello'),
+            synthesis_speech=True
+        )
+
+        assert response.synthesis_speech is True
+
+    def test_message_response_render_to_html_string_request(self) -> None:
+        response = MessageResponse(
+            type=MessageResponseType.REQUEST,
+            sender='User',
+            message_intel=DefaultMessageIntel(text='Hello')
+        )
+
+        html = response.render_to_html_string()
+
+        assert isinstance(html, str)
+        assert len(html) > 0
+
+    def test_message_response_render_to_html_string_response(self) -> None:
+        response = MessageResponse(
+            type=MessageResponseType.RESPONSE,
+            sender='Assistant',
+            message_intel=DefaultMessageIntel(text='Hello')
+        )
+
+        html = response.render_to_html_string()
+
+        assert isinstance(html, str)
+        assert len(html) > 0
+
+    def test_message_response_render_to_html_string_loading(self) -> None:
+        response = MessageResponse(
+            type=MessageResponseType.LOADING_RESPONSE,
+            sender='Assistant',
+            message_intel=DefaultMessageIntel(text='Loading...')
+        )
+
+        html = response.render_to_html_string()
+
+        assert isinstance(html, str)
+        assert len(html) > 0
+
+    def test_message_response_render_with_context_data(self) -> None:
+        response = MessageResponse(
+            type=MessageResponseType.REQUEST,
+            sender='User',
+            message_intel=DefaultMessageIntel(text='Hello')
+        )
+
+        html = response.render_to_html_string(context_data={'chat_id': 123})
+
+        assert isinstance(html, str)
+
+    def test_message_response_default_synthesis_speech(self) -> None:
+        response = MessageResponse(
+            type=MessageResponseType.REQUEST,
+            sender='User',
+            message_intel=DefaultMessageIntel(text='Hello')
+        )
+
+        assert response.synthesis_speech is False
+
+    def test_message_response_default_timestamp(self) -> None:
+        response = MessageResponse(
+            type=MessageResponseType.REQUEST,
+            sender='User',
+            message_intel=DefaultMessageIntel(text='Hello')
+        )
+
+        assert response.message_timestamp is None
+
+
+class MessageResponseGroupTests(BaseTestCase):
+    def test_message_response_group_creation(self) -> None:
+        group = MessageResponseGroup()
+
+        assert len(group.message_responses) == 0
+
+    def test_add_message_response(self) -> None:
+        group = MessageResponseGroup()
+        response = MessageResponse(
+            type=MessageResponseType.REQUEST,
+            sender='User',
+            message_intel=DefaultMessageIntel(text='Hello')
+        )
+
+        group.add_message_response(response)
+
+        assert len(group.message_responses) == 1
+
+    def test_add_multiple_message_responses(self) -> None:
+        group = MessageResponseGroup()
+
+        for i in range(5):
+            response = MessageResponse(
+                type=MessageResponseType.REQUEST,
+                sender='User',
+                message_intel=DefaultMessageIntel(text=f'Message {i}')
+            )
+            group.add_message_response(response)
+
+        assert len(group.message_responses) == 5
+
+    def test_render_to_html_string_empty(self) -> None:
+        group = MessageResponseGroup()
+
+        html = group.render_to_html_string()
+
+        assert html == ''
+
+    def test_render_to_html_string_with_messages(self) -> None:
+        group = MessageResponseGroup()
+        group.add_message_response(MessageResponse(
+            type=MessageResponseType.REQUEST,
+            sender='User',
+            message_intel=DefaultMessageIntel(text='Hello')
+        ))
+        group.add_message_response(MessageResponse(
+            type=MessageResponseType.RESPONSE,
+            sender='Assistant',
+            message_intel=DefaultMessageIntel(text='Hi')
+        ))
+
+        html = group.render_to_html_string()
+
+        assert isinstance(html, str)
+        assert len(html) > 0
+
+    def test_render_to_html_string_with_context(self) -> None:
+        group = MessageResponseGroup()
+        group.add_message_response(MessageResponse(
+            type=MessageResponseType.REQUEST,
+            sender='User',
+            message_intel=DefaultMessageIntel(text='Hello')
+        ))
+
+        html = group.render_to_html_string(context_data={'chat_id': 123})
+
+        assert isinstance(html, str)
+
+    def test_render_to_html_string_with_is_loading(self) -> None:
+        group = MessageResponseGroup()
+        group.add_message_response(MessageResponse(
+            type=MessageResponseType.REQUEST,
+            sender='User',
+            message_intel=DefaultMessageIntel(text='Hello')
+        ))
+
+        html = group.render_to_html_string(context_data={'is_loading': True})
+
+        assert isinstance(html, str)
+
+    def test_render_to_html_string_default_is_loading(self) -> None:
+        group = MessageResponseGroup()
+        group.add_message_response(MessageResponse(
+            type=MessageResponseType.REQUEST,
+            sender='User',
+            message_intel=DefaultMessageIntel(text='Hello')
+        ))
+
+        html = group.render_to_html_string(context_data={})
+
+        assert isinstance(html, str)
+
+
+class MessageResponseTypeTests(BaseTestCase):
+    def test_request_type(self) -> None:
+        assert MessageResponseType.REQUEST.value == 'request'
+
+    def test_response_type(self) -> None:
+        assert MessageResponseType.RESPONSE.value == 'response'
+
+    def test_loading_response_type(self) -> None:
+        assert MessageResponseType.LOADING_RESPONSE.value == 'loading_response'