django-spire 0.23.7__py3-none-any.whl → 0.23.9__py3-none-any.whl

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

@@ -1,8 +1,11 @@
 from __future__ import annotations
 
+import json
+
+from django.urls import reverse
+
 from django_spire.ai.chat.tests.test_urls.factories import create_test_chat
 from django_spire.core.tests.test_cases import BaseTestCase
-from django.urls import reverse
 
 
 class ChatJsonUrlTests(BaseTestCase):
@@ -21,3 +24,201 @@ class ChatJsonUrlTests(BaseTestCase):
         )
 
         assert response.status_code == 200
+
+    def test_delete_view_success_response(self) -> None:
+        response = self.client.post(
+            reverse(
+                'django_spire:ai:chat:json:delete',
+                kwargs={'pk': self.test_chat.pk}
+            ),
+            content_type='application/json'
+        )
+
+        data = response.json()
+
+        assert data['type'] == 'success'
+        assert 'deleted' in data['message'].lower()
+
+    def test_delete_view_sets_deleted_flag(self) -> None:
+        self.client.post(
+            reverse(
+                'django_spire:ai:chat:json:delete',
+                kwargs={'pk': self.test_chat.pk}
+            ),
+            content_type='application/json'
+        )
+
+        self.test_chat.refresh_from_db()
+
+        assert self.test_chat.is_deleted
+
+    def test_delete_view_nonexistent_chat(self) -> None:
+        response = self.client.post(
+            reverse(
+                'django_spire:ai:chat:json:delete',
+                kwargs={'pk': 99999}
+            ),
+            content_type='application/json'
+        )
+
+        data = response.json()
+
+        assert data['type'] == 'error'
+
+    def test_rename_view_url_path(self) -> None:
+        response = self.client.post(
+            reverse(
+                'django_spire:ai:chat:json:rename',
+                kwargs={'pk': self.test_chat.pk}
+            ),
+            data=json.dumps({'new_name': 'New Chat Name'}),
+            content_type='application/json'
+        )
+
+        assert response.status_code == 200
+
+    def test_rename_view_success_response(self) -> None:
+        response = self.client.post(
+            reverse(
+                'django_spire:ai:chat:json:rename',
+                kwargs={'pk': self.test_chat.pk}
+            ),
+            data=json.dumps({'new_name': 'Updated Name'}),
+            content_type='application/json'
+        )
+
+        data = response.json()
+
+        assert data['type'] == 'success'
+
+    def test_rename_view_updates_name(self) -> None:
+        new_name = 'Brand New Name'
+
+        self.client.post(
+            reverse(
+                'django_spire:ai:chat:json:rename',
+                kwargs={'pk': self.test_chat.pk}
+            ),
+            data=json.dumps({'new_name': new_name}),
+            content_type='application/json'
+        )
+
+        self.test_chat.refresh_from_db()
+
+        assert self.test_chat.name == new_name
+
+    def test_rename_view_empty_name(self) -> None:
+        response = self.client.post(
+            reverse(
+                'django_spire:ai:chat:json:rename',
+                kwargs={'pk': self.test_chat.pk}
+            ),
+            data=json.dumps({'new_name': ''}),
+            content_type='application/json'
+        )
+
+        data = response.json()
+
+        assert data['type'] == 'error'
+
+    def test_rename_view_name_too_long(self) -> None:
+        long_name = 'A' * 200
+
+        response = self.client.post(
+            reverse(
+                'django_spire:ai:chat:json:rename',
+                kwargs={'pk': self.test_chat.pk}
+            ),
+            data=json.dumps({'new_name': long_name}),
+            content_type='application/json'
+        )
+
+        data = response.json()
+
+        assert data['type'] == 'error'
+
+    def test_rename_view_nonexistent_chat(self) -> None:
+        response = self.client.post(
+            reverse(
+                'django_spire:ai:chat:json:rename',
+                kwargs={'pk': 99999}
+            ),
+            data=json.dumps({'new_name': 'New Name'}),
+            content_type='application/json'
+        )
+
+        data = response.json()
+
+        assert data['type'] == 'error'
+
+    def test_rename_view_max_length_name(self) -> None:
+        max_length_name = 'A' * 128
+
+        response = self.client.post(
+            reverse(
+                'django_spire:ai:chat:json:rename',
+                kwargs={'pk': self.test_chat.pk}
+            ),
+            data=json.dumps({'new_name': max_length_name}),
+            content_type='application/json'
+        )
+
+        data = response.json()
+
+        assert data['type'] == 'success'
+
+        self.test_chat.refresh_from_db()
+        assert self.test_chat.name == max_length_name
+
+
+class ChatJsonUrlAdditionalTests(BaseTestCase):
+    def test_delete_multiple_chats(self) -> None:
+        chat1 = create_test_chat(user=self.super_user)
+        chat2 = create_test_chat(user=self.super_user)
+
+        self.client.post(
+            reverse('django_spire:ai:chat:json:delete', kwargs={'pk': chat1.pk}),
+            content_type='application/json'
+        )
+
+        self.client.post(
+            reverse('django_spire:ai:chat:json:delete', kwargs={'pk': chat2.pk}),
+            content_type='application/json'
+        )
+
+        chat1.refresh_from_db()
+        chat2.refresh_from_db()
+
+        assert chat1.is_deleted
+        assert chat2.is_deleted
+
+    def test_rename_with_special_characters(self) -> None:
+        chat = create_test_chat(user=self.super_user)
+        special_name = "Chat with 'quotes' and \"double quotes\""
+
+        response = self.client.post(
+            reverse('django_spire:ai:chat:json:rename', kwargs={'pk': chat.pk}),
+            data=json.dumps({'new_name': special_name}),
+            content_type='application/json'
+        )
+
+        data = response.json()
+
+        assert data['type'] == 'success'
+
+    def test_rename_with_unicode(self) -> None:
+        chat = create_test_chat(user=self.super_user)
+        unicode_name = 'Chat 日本語 🎉'
+
+        response = self.client.post(
+            reverse('django_spire:ai:chat:json:rename', kwargs={'pk': chat.pk}),
+            data=json.dumps({'new_name': unicode_name}),
+            content_type='application/json'
+        )
+
+        data = response.json()
+
+        assert data['type'] == 'success'
+
+        chat.refresh_from_db()
+        assert chat.name == unicode_name

django_spire/ai/context/tests/test_context.py

@@ -0,0 +1,188 @@
+from __future__ import annotations
+
+import pytest
+
+from django.core.exceptions import ValidationError
+
+from django_spire.ai.context.choices import PersonRoleChoices
+from django_spire.ai.context.intelligence.prompts.organization_prompts import organization_info_prompt
+from django_spire.ai.context.models import Organization, Person
+from django_spire.core.tests.test_cases import BaseTestCase
+
+
+class OrganizationModelTests(BaseTestCase):
+    def test_organization_creation(self) -> None:
+        org = Organization.objects.create(
+            name='Test Organization',
+            legal_name='Test Organization Inc.'
+        )
+
+        assert org.name == 'Test Organization'
+        assert org.legal_name == 'Test Organization Inc.'
+
+    def test_organization_only_one_allowed(self) -> None:
+        Organization.objects.create(name='First Org')
+
+        with pytest.raises(ValidationError):
+            Organization.objects.create(name='Second Org')
+
+    def test_organization_all_fields(self) -> None:
+        org = Organization.objects.create(
+            name='Test Org',
+            legal_name='Test Org LLC',
+            description='A test organization',
+            sector='Technology',
+            sub_sector='Software',
+            website='https://example.com',
+            street_address='123 Main St',
+            unit_number='Suite 100',
+            city='New York',
+            province='NY',
+            postal_code='10001',
+            country='USA',
+            phone='555-1234',
+            email='info@example.com'
+        )
+
+        assert org.name == 'Test Org'
+        assert org.sector == 'Technology'
+        assert org.city == 'New York'
+        assert org.email == 'info@example.com'
+
+    def test_organization_nullable_fields(self) -> None:
+        org = Organization.objects.create()
+
+        assert org.name is None
+        assert org.legal_name is None
+        assert org.description is None
+
+    def test_organization_get_only_or_none_exists(self) -> None:
+        Organization.objects.create(name='Test Org')
+
+        result = Organization.objects.get_only_or_none()
+
+        assert result is not None
+        assert result.name == 'Test Org'
+
+    def test_organization_get_only_or_none_not_exists(self) -> None:
+        result = Organization.objects.get_only_or_none()
+
+        assert result is None
+
+
+class PersonModelTests(BaseTestCase):
+    def test_person_creation(self) -> None:
+        person = Person.objects.create(
+            first_name='John',
+            last_name='Doe',
+            role=PersonRoleChoices.ADMIN
+        )
+
+        assert person.first_name == 'John'
+        assert person.last_name == 'Doe'
+        assert person.role == PersonRoleChoices.ADMIN
+
+    def test_person_default_role(self) -> None:
+        person = Person.objects.create(
+            first_name='Jane',
+            last_name='Smith'
+        )
+
+        assert person.role == PersonRoleChoices.ADMIN
+
+    def test_person_default_is_internal(self) -> None:
+        person = Person.objects.create(
+            first_name='Test',
+            last_name='User'
+        )
+
+        assert person.is_internal_to_organization is True
+
+    def test_person_all_roles(self) -> None:
+        for role_choice in PersonRoleChoices:
+            person = Person.objects.create(
+                first_name=f'Test_{role_choice.value}',
+                last_name='User',
+                role=role_choice
+            )
+
+            assert person.role == role_choice
+
+    def test_person_with_user(self) -> None:
+        person = Person.objects.create(
+            user=self.super_user,
+            first_name='Super',
+            last_name='User'
+        )
+
+        assert person.user == self.super_user
+
+    def test_person_nullable_fields(self) -> None:
+        person = Person.objects.create()
+
+        assert person.first_name is None
+        assert person.last_name is None
+        assert person.phone is None
+        assert person.email is None
+        assert person.role_details is None
+
+    def test_person_external_to_organization(self) -> None:
+        person = Person.objects.create(
+            first_name='External',
+            last_name='Person',
+            is_internal_to_organization=False
+        )
+
+        assert person.is_internal_to_organization is False
+
+
+class PersonRoleChoicesTests(BaseTestCase):
+    def test_admin_choice(self) -> None:
+        assert PersonRoleChoices.ADMIN.value == 'admin'
+        assert PersonRoleChoices.ADMIN.label == 'Admin'
+
+    def test_human_resources_choice(self) -> None:
+        assert PersonRoleChoices.HUMAN_RESOURCES.value == 'human_resources'
+        assert PersonRoleChoices.HUMAN_RESOURCES.label == 'Human Resources'
+
+    def test_sales_choice(self) -> None:
+        assert PersonRoleChoices.SALES.value == 'sales'
+        assert PersonRoleChoices.SALES.label == 'Sales'
+
+    def test_manager_choice(self) -> None:
+        assert PersonRoleChoices.MANAGER.value == 'manager'
+        assert PersonRoleChoices.MANAGER.label == 'Manager'
+
+    def test_marketing_choice(self) -> None:
+        assert PersonRoleChoices.MARKETING.value == 'marketing'
+        assert PersonRoleChoices.MARKETING.label == 'Marketing'
+
+    def test_technical_choice(self) -> None:
+        assert PersonRoleChoices.TECHNICAL.value == 'technical'
+        assert PersonRoleChoices.TECHNICAL.label == 'Technical'
+
+    def test_it_support_choice(self) -> None:
+        assert PersonRoleChoices.IT_SUPPORT.value == 'it_support'
+        assert PersonRoleChoices.IT_SUPPORT.label == 'IT Support'
+
+    def test_all_choices_count(self) -> None:
+        assert len(PersonRoleChoices) == 7
+
+
+class OrganizationPromptTests(BaseTestCase):
+    def test_organization_info_prompt_with_org(self) -> None:
+        Organization.objects.create(
+            name='Test Org',
+            legal_name='Test Org Inc.'
+        )
+
+        prompt = organization_info_prompt()
+
+        assert prompt is not None
+        assert 'Organization Information' in prompt.to_str()
+
+    def test_organization_info_prompt_without_org(self) -> None:
+        prompt = organization_info_prompt()
+
+        assert prompt is not None
+        assert 'no organization information available' in prompt.to_str()

django_spire/ai/decorators.py

@@ -4,7 +4,7 @@ import json
 import traceback
 import uuid
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Callable, TypeVar
 
 from dandy import Recorder
 from django.utils.timezone import now
@@ -15,16 +15,19 @@ if TYPE_CHECKING:
     from django.contrib.auth.models import AbstractBaseUser
 
 
+T = TypeVar('T')
+
+
 def log_ai_interaction_from_recorder(
     user: AbstractBaseUser | None = None,
     actor: str | None = None
-):
+) -> Callable[[Callable[..., T]], Callable[..., T]]:
     if user is None and actor is None:
         message = 'user or actor must be provided'
         raise ValueError(message)
 
-    def decorator(func):
-        def wrapper(*args, **kwargs):
+    def decorator(func: Callable[..., T]) -> Callable[..., T]:
+        def wrapper(*args, **kwargs) -> T:
             recording_uuid = f'Recording-{uuid.uuid4()}'
 
             ai_usage, _ = AiUsage.objects.get_or_create(
@@ -41,7 +44,6 @@ def log_ai_interaction_from_recorder(
             try:
                 Recorder.start_recording(recording_uuid)
                 return func(*args, **kwargs)
-
             except Exception as e:
                 ai_usage.was_successful = False
 
@@ -55,7 +57,6 @@ def log_ai_interaction_from_recorder(
                 ai_interaction.stack_trace = stack_trace
 
                 raise
-
             finally:
                 Recorder.stop_recording(recording_uuid)
 

django_spire/ai/prompt/tests/test_bots.py

@@ -1,31 +1,121 @@
 from __future__ import annotations
 
 from django_spire.ai.prompt.system import bots
+from django_spire.ai.prompt.system.intel import SystemPromptIntel, SystemPromptResultIntel
 from django_spire.core.tests.test_cases import BaseTestCase
 
 
 class PromptBotTestCase(BaseTestCase):
-    def test_system_prompt_system_prompt(self):
+    def test_role_system_prompt_bot(self) -> None:
         ISSUE_PROMPT = (
-            "I am using jira to plan developer workloads And I want to be able to build very clear issues  that"
-            "developers will be able to read understand and take action on to complete the goal."
-            "I will give you details about a software development task that we have to achieve and I want you "
-            "to return a short one sentence summary that the developer can read and understand the scope of the issue"
-            "before they get into the details of it "
+            'I am using jira to plan developer workloads And I want to be able to build very clear issues that '
+            'developers will be able to read understand and take action on to complete the goal. '
+            'I will give you details about a software development task that we have to achieve and I want you '
+            'to return a short one sentence summary that the developer can read and understand the scope of the issue '
+            'before they get into the details of it '
         )
 
         role_bot = bots.RoleSystemPromptBot()
         role_result = role_bot.process(ISSUE_PROMPT)
-        self.assertIsNotNone(role_result)
+
+        assert role_result is not None
+        assert role_result.result is not None
+        assert len(role_result.result) > 0
+
+    def test_task_system_prompt_bot(self) -> None:
+        ISSUE_PROMPT = (
+            'I am using jira to plan developer workloads And I want to be able to build very clear issues that '
+            'developers will be able to read understand and take action on to complete the goal.'
+        )
 
         task_bot = bots.TaskSystemPromptBot()
         task_result = task_bot.process(ISSUE_PROMPT)
-        self.assertIsNotNone(task_result)
+
+        assert task_result is not None
+        assert task_result.result is not None
+        assert len(task_result.result) > 0
+
+    def test_guidelines_system_prompt_bot(self) -> None:
+        ISSUE_PROMPT = (
+            'I want to create a system that helps users write better emails.'
+        )
 
         guidelines_bot = bots.GuidelinesSystemPromptBot()
         guidelines_result = guidelines_bot.process(ISSUE_PROMPT)
-        self.assertIsNotNone(guidelines_result)
+
+        assert guidelines_result is not None
+        assert guidelines_result.result is not None
+        assert len(guidelines_result.result) > 0
+
+    def test_output_format_system_prompt_bot(self) -> None:
+        ISSUE_PROMPT = (
+            'I want to create a system that returns a summary of a document.'
+        )
 
         output_format_bot = bots.OutputFormatSystemPromptBot()
         output_format_result = output_format_bot.process(ISSUE_PROMPT)
-        self.assertIsNotNone(output_format_result)
+
+        assert output_format_result is not None
+        assert output_format_result.result is not None
+
+    def test_system_prompt_bot_full_workflow(self) -> None:
+        ISSUE_PROMPT = (
+            'I am using jira to plan developer workloads And I want to be able to build very clear issues that '
+            'developers will be able to read understand and take action on to complete the goal. '
+            'I will give you details about a software development task that we have to achieve and I want you '
+            'to return a short one sentence summary that the developer can read and understand the scope of the issue '
+            'before they get into the details of it '
+        )
+
+        role_bot = bots.RoleSystemPromptBot()
+        role_result = role_bot.process(ISSUE_PROMPT)
+        assert role_result is not None
+
+        task_bot = bots.TaskSystemPromptBot()
+        task_result = task_bot.process(ISSUE_PROMPT)
+        assert task_result is not None
+
+        guidelines_bot = bots.GuidelinesSystemPromptBot()
+        guidelines_result = guidelines_bot.process(ISSUE_PROMPT)
+        assert guidelines_result is not None
+
+        output_format_bot = bots.OutputFormatSystemPromptBot()
+        output_format_result = output_format_bot.process(ISSUE_PROMPT)
+        assert output_format_result is not None
+
+
+class SystemPromptIntelTestCase(BaseTestCase):
+    def test_system_prompt_intel_to_string(self) -> None:
+        intel = SystemPromptIntel(
+            role='Test Role',
+            task='Test Task',
+            guidelines='Test Guidelines',
+            output_format='Test Output Format'
+        )
+
+        result = intel.to_string()
+
+        assert 'Role: Test Role' in result
+        assert 'Task: Test Task' in result
+        assert 'Guidelines: Test Guidelines' in result
+        assert 'Output Format: Test Output Format' in result
+
+    def test_system_prompt_intel_to_string_without_output_format(self) -> None:
+        intel = SystemPromptIntel(
+            role='Test Role',
+            task='Test Task',
+            guidelines='Test Guidelines',
+            output_format=None
+        )
+
+        result = intel.to_string()
+
+        assert 'Role: Test Role' in result
+        assert 'Task: Test Task' in result
+        assert 'Guidelines: Test Guidelines' in result
+        assert 'Output Format' not in result
+
+    def test_system_prompt_result_intel(self) -> None:
+        intel = SystemPromptResultIntel(result='Test result')
+
+        assert intel.result == 'Test result'

django_spire/ai/prompt/tests/test_prompt_intel.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from django_spire.ai.prompt.intel import DandyPromptPythonFileIntel, TextToMarkdownIntel
+from django_spire.core.tests.test_cases import BaseTestCase
+
+
+class DandyPromptPythonFileIntelTests(BaseTestCase):
+    def test_dandy_prompt_python_file_intel_creation(self) -> None:
+        intel = DandyPromptPythonFileIntel(
+            source_code='print("hello")',
+            file_name='test.py'
+        )
+
+        assert intel.source_code == 'print("hello")'
+        assert intel.file_name == 'test.py'
+
+    def test_dandy_prompt_python_file_intel_empty_source(self) -> None:
+        intel = DandyPromptPythonFileIntel(
+            source_code='',
+            file_name='empty.py'
+        )
+
+        assert intel.source_code == ''
+
+    def test_dandy_prompt_python_file_intel_long_source(self) -> None:
+        long_source = 'x = 1\n' * 1000
+        intel = DandyPromptPythonFileIntel(
+            source_code=long_source,
+            file_name='long.py'
+        )
+
+        assert intel.source_code == long_source
+
+
+class TextToMarkdownIntelTests(BaseTestCase):
+    def test_text_to_markdown_intel_creation(self) -> None:
+        intel = TextToMarkdownIntel(
+            markdown_content='# Hello World',
+            file_name='test.md'
+        )
+
+        assert intel.markdown_content == '# Hello World'
+        assert intel.file_name == 'test.md'
+
+    def test_text_to_markdown_intel_empty_content(self) -> None:
+        intel = TextToMarkdownIntel(
+            markdown_content='',
+            file_name='empty.md'
+        )
+
+        assert intel.markdown_content == ''
+
+    def test_text_to_markdown_intel_complex_markdown(self) -> None:
+        complex_md = """
+            # Title
+
+            ## Section 1
+
+            - Item 1
+            - Item 2
+
+            ```python
+            print("code")
+            ```
+        """
+
+        intel = TextToMarkdownIntel(
+            markdown_content=complex_md,
+            file_name='complex.md'
+        )
+
+        assert intel.markdown_content == complex_md
+
+    def test_text_to_markdown_intel_model_dump(self) -> None:
+        intel = TextToMarkdownIntel(
+            markdown_content='Test',
+            file_name='test.md'
+        )
+
+        dump = intel.model_dump()
+
+        assert 'markdown_content' in dump
+        assert 'file_name' in dump