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

django_spire/ai/prompt/tests/test_prompt_tuning.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+from django_spire.ai.prompt.tuning.prompts import (
+    duplication_removal_bot_instruction_prompt,
+    example_optimization_bot_instruction_prompt,
+    formatting_bot_instruction_prompt,
+    instruction_clarity_bot_instruction_prompt,
+    persona_bot_instruction_prompt,
+    prompt_tuning_input_prompt,
+    prompt_tuning_instruction_bot_prompt,
+    specialized_bot_input_prompt,
+)
+from django_spire.ai.prompt.tuning.choices import OutcomeRatingChoices
+from django_spire.ai.prompt.tuning.intel import PromptTestingIntel, PromptTuningIntel
+from django_spire.core.tests.test_cases import BaseTestCase
+
+
+class OutcomeRatingChoicesTests(BaseTestCase):
+    def test_terrible_rating(self) -> None:
+        assert OutcomeRatingChoices.TERRIBLE.value == 1
+        assert OutcomeRatingChoices.TERRIBLE.label == 'terrible'
+
+    def test_bad_rating(self) -> None:
+        assert OutcomeRatingChoices.BAD.value == 2
+        assert OutcomeRatingChoices.BAD.label == 'bad'
+
+    def test_ok_rating(self) -> None:
+        assert OutcomeRatingChoices.OK.value == 3
+        assert OutcomeRatingChoices.OK.label == 'ok'
+
+    def test_good_rating(self) -> None:
+        assert OutcomeRatingChoices.GOOD.value == 4
+        assert OutcomeRatingChoices.GOOD.label == 'good'
+
+    def test_great_rating(self) -> None:
+        assert OutcomeRatingChoices.GREAT.value == 5
+        assert OutcomeRatingChoices.GREAT.label == 'great'
+
+    def test_amazing_rating(self) -> None:
+        assert OutcomeRatingChoices.AMAZING.value == 6
+        assert OutcomeRatingChoices.AMAZING.label == 'amazing'
+
+    def test_all_ratings_count(self) -> None:
+        assert len(OutcomeRatingChoices) == 6
+
+
+class PromptTuningIntelTests(BaseTestCase):
+    def test_prompt_tuning_intel_creation(self) -> None:
+        intel = PromptTuningIntel(prompt='Test prompt')
+
+        assert intel.prompt == 'Test prompt'
+
+    def test_prompt_tuning_intel_empty_prompt(self) -> None:
+        intel = PromptTuningIntel(prompt='')
+
+        assert intel.prompt == ''
+
+    def test_prompt_tuning_intel_long_prompt(self) -> None:
+        long_prompt = 'A' * 10000
+        intel = PromptTuningIntel(prompt=long_prompt)
+
+        assert intel.prompt == long_prompt
+        assert len(intel.prompt) == 10000
+
+
+class PromptTestingIntelTests(BaseTestCase):
+    def test_prompt_testing_intel_creation(self) -> None:
+        intel = PromptTestingIntel(result='Test result')
+
+        assert intel.result == 'Test result'
+
+    def test_prompt_testing_intel_empty_result(self) -> None:
+        intel = PromptTestingIntel(result='')
+
+        assert intel.result == ''
+
+
+class PromptTuningPromptsTests(BaseTestCase):
+    def test_prompt_tuning_instruction_bot_prompt(self) -> None:
+        prompt = prompt_tuning_instruction_bot_prompt()
+
+        assert prompt is not None
+        assert 'System Prompt Tuning Expert' in prompt.to_str()
+
+    def test_prompt_tuning_input_prompt(self) -> None:
+        prompt = prompt_tuning_input_prompt('Test system prompt', 'Test feedback')
+
+        assert prompt is not None
+        assert 'Test system prompt' in prompt.to_str()
+        assert 'Test feedback' in prompt.to_str()
+
+    def test_formatting_bot_instruction_prompt(self) -> None:
+        prompt = formatting_bot_instruction_prompt()
+
+        assert prompt is not None
+        assert 'Prompt Formatting Expert' in prompt.to_str()
+
+    def test_instruction_clarity_bot_instruction_prompt(self) -> None:
+        prompt = instruction_clarity_bot_instruction_prompt()
+
+        assert prompt is not None
+        assert 'Instruction Clarity Expert' in prompt.to_str()
+
+    def test_persona_bot_instruction_prompt(self) -> None:
+        prompt = persona_bot_instruction_prompt()
+
+        assert prompt is not None
+        assert 'Persona Consistency Expert' in prompt.to_str()
+
+    def test_duplication_removal_bot_instruction_prompt(self) -> None:
+        prompt = duplication_removal_bot_instruction_prompt()
+
+        assert prompt is not None
+        assert 'Duplication Removal Expert' in prompt.to_str()
+
+    def test_example_optimization_bot_instruction_prompt(self) -> None:
+        prompt = example_optimization_bot_instruction_prompt()
+
+        assert prompt is not None
+        assert 'Example Optimization Expert' in prompt.to_str()
+
+    def test_specialized_bot_input_prompt(self) -> None:
+        prompt = specialized_bot_input_prompt('Test system prompt')
+
+        assert prompt is not None
+        assert 'Test system prompt' in prompt.to_str()

django_spire/ai/sms/decorators.py

@@ -3,13 +3,19 @@ from __future__ import annotations
 import functools
 import os
 
+from typing import TYPE_CHECKING, Callable
+
 from django.http import HttpResponseForbidden
 from twilio.request_validator import RequestValidator
 
+if TYPE_CHECKING:
+    from django.core.handlers.wsgi import WSGIRequest
+    from django.http import HttpResponse
+
 
-def twilio_auth_required(func):
+def twilio_auth_required(func: Callable[..., HttpResponse]) -> Callable[..., HttpResponse]:
     @functools.wraps(func)
-    def decorated_function(request, *args, **kwargs):
+    def decorated_function(request: WSGIRequest, *args, **kwargs) -> HttpResponse:
         request_validator = RequestValidator(os.environ.get('TWILIO_AUTH_TOKEN', ''))
 
         absolute_uri = request.build_absolute_uri()

django_spire/ai/sms/tests/test_sms.py

@@ -1,30 +1,254 @@
+from __future__ import annotations
+
 from django.test import TestCase
 
-from django_spire.ai.sms.models import SmsConversation
+from django_spire.ai.sms.models import SmsConversation, SmsMessage
+
+
+class SmsConversationModelTests(TestCase):
+    def test_conversation_creation(self) -> None:
+        conversation = SmsConversation.objects.create(
+            phone_number='+15551234567'
+        )
+
+        assert conversation.phone_number == '+15551234567'
+        assert conversation.messages.count() == 0
+        assert conversation.is_empty
+
+    def test_conversation_str(self) -> None:
+        conversation = SmsConversation.objects.create(
+            phone_number='+15551234567'
+        )
+
+        assert '+15551234567' in str(conversation)
+        assert 'SMS Conversation' in str(conversation)
+
+    def test_add_message(self) -> None:
+        conversation = SmsConversation.objects.create(
+            phone_number='+15551234567'
+        )
+
+        message = conversation.add_message(body='Hello', is_inbound=True, twilio_sid='')
+
+        assert message.body == 'Hello'
+        assert message.is_inbound
+
+        message = conversation.add_message(body='Hi there', is_inbound=False, twilio_sid='')
+
+        assert message.body == 'Hi there'
+        assert not message.is_inbound
+
+        assert conversation.messages.count() == 2
+        assert not conversation.is_empty
+
+    def test_add_message_updates_last_message_datetime(self) -> None:
+        conversation = SmsConversation.objects.create(
+            phone_number='+15551234567'
+        )
+
+        initial_datetime = conversation.last_message_datetime
+
+        conversation.add_message(body='Test', is_inbound=True, twilio_sid='')
+        conversation.refresh_from_db()
+
+        assert conversation.last_message_datetime >= initial_datetime
+
+    def test_generate_message_history(self) -> None:
+        conversation = SmsConversation.objects.create(
+            phone_number='+15551234567'
+        )
+
+        conversation.add_message(body='User message 1', is_inbound=True, twilio_sid='')
+        conversation.add_message(body='Assistant response 1', is_inbound=False, twilio_sid='')
+        conversation.add_message(body='User message 2', is_inbound=True, twilio_sid='')
 
+        message_history = conversation.generate_message_history(
+            message_count=20,
+            exclude_last_message=True
+        )
+
+        assert message_history is not None
 
-class SmsModelTests(TestCase):
-    def test_conversation_creation(self):
+    def test_generate_message_history_includes_last_message(self) -> None:
         conversation = SmsConversation.objects.create(
             phone_number='+15551234567'
         )
-        self.assertEqual(conversation.phone_number, '+15551234567')
-        self.assertEqual(conversation.messages.count(), 0)
-        self.assertTrue(conversation.is_empty)
 
-    def test_add_message(self):
+        conversation.add_message(body='User message 1', is_inbound=True, twilio_sid='')
+        conversation.add_message(body='User message 2', is_inbound=True, twilio_sid='')
+
+        message_history = conversation.generate_message_history(
+            message_count=20,
+            exclude_last_message=False
+        )
+
+        assert message_history is not None
+
+    def test_is_empty_property(self) -> None:
+        conversation = SmsConversation.objects.create(
+            phone_number='+15551234567'
+        )
+
+        assert conversation.is_empty
+
+        conversation.add_message(body='Test', is_inbound=True, twilio_sid='')
+
+        assert not conversation.is_empty
+
+
+class SmsMessageModelTests(TestCase):
+    def test_message_creation(self) -> None:
+        conversation = SmsConversation.objects.create(
+            phone_number='+15551234567'
+        )
+        message = SmsMessage.objects.create(
+            conversation=conversation,
+            body='Test message',
+            is_inbound=True,
+            twilio_sid='SM123'
+        )
+
+        assert message.body == 'Test message'
+        assert message.is_inbound
+        assert message.twilio_sid == 'SM123'
+
+    def test_message_str_short(self) -> None:
+        conversation = SmsConversation.objects.create(
+            phone_number='+15551234567'
+        )
+        message = SmsMessage.objects.create(
+            conversation=conversation,
+            body='Short message',
+            is_inbound=True
+        )
+
+        assert 'Inbound' in str(message)
+        assert 'Short message' in str(message)
+
+    def test_message_str_long(self) -> None:
+        conversation = SmsConversation.objects.create(
+            phone_number='+15551234567'
+        )
+        long_body = 'A' * 100
+        message = SmsMessage.objects.create(
+            conversation=conversation,
+            body=long_body,
+            is_inbound=True
+        )
+
+        assert '...' in str(message)
+
+    def test_direction_property_inbound(self) -> None:
+        conversation = SmsConversation.objects.create(
+            phone_number='+15551234567'
+        )
+        message = SmsMessage.objects.create(
+            conversation=conversation,
+            body='Test',
+            is_inbound=True
+        )
+
+        assert message.direction == 'Inbound'
+
+    def test_direction_property_outbound(self) -> None:
+        conversation = SmsConversation.objects.create(
+            phone_number='+15551234567'
+        )
+        message = SmsMessage.objects.create(
+            conversation=conversation,
+            body='Test',
+            is_inbound=False
+        )
+
+        assert message.direction == 'Outbound'
+
+    def test_is_outbound_property(self) -> None:
+        conversation = SmsConversation.objects.create(
+            phone_number='+15551234567'
+        )
+
+        inbound_message = SmsMessage.objects.create(
+            conversation=conversation,
+            body='Test',
+            is_inbound=True
+        )
+
+        outbound_message = SmsMessage.objects.create(
+            conversation=conversation,
+            body='Test',
+            is_inbound=False
+        )
+
+        assert not inbound_message.is_outbound
+        assert outbound_message.is_outbound
+
+    def test_role_property_inbound(self) -> None:
+        conversation = SmsConversation.objects.create(
+            phone_number='+15551234567'
+        )
+        message = SmsMessage.objects.create(
+            conversation=conversation,
+            body='Test',
+            is_inbound=True
+        )
+
+        assert message.role == 'user'
+
+    def test_role_property_outbound(self) -> None:
+        conversation = SmsConversation.objects.create(
+            phone_number='+15551234567'
+        )
+        message = SmsMessage.objects.create(
+            conversation=conversation,
+            body='Test',
+            is_inbound=False
+        )
+
+        assert message.role == 'assistant'
+
+    def test_message_is_processed_default(self) -> None:
+        conversation = SmsConversation.objects.create(
+            phone_number='+15551234567'
+        )
+        message = SmsMessage.objects.create(
+            conversation=conversation,
+            body='Test',
+            is_inbound=True
+        )
+
+        assert message.is_processed is False
+
+
+class SmsQuerySetTests(TestCase):
+    def test_by_phone_number(self) -> None:
+        SmsConversation.objects.create(phone_number='+15551234567')
+        SmsConversation.objects.create(phone_number='+15559876543')
+
+        result = SmsConversation.objects.by_phone_number('+15551234567')
+
+        assert result.count() == 1
+        assert result.first().phone_number == '+15551234567'
+
+    def test_newest_by_count(self) -> None:
+        conversation = SmsConversation.objects.create(
+            phone_number='+15551234567'
+        )
+
+        for i in range(25):
+            conversation.add_message(body=f'Message {i}', is_inbound=True, twilio_sid='')
+
+        messages = conversation.messages.newest_by_count(20)
+
+        assert len(messages) == 20
+
+    def test_newest_by_count_reversed(self) -> None:
         conversation = SmsConversation.objects.create(
             phone_number='+15551234567'
         )
-        
-        message = conversation.add_message(body="Hello", is_inbound=True, twilio_sid='')
-        self.assertEqual(message.body, "Hello")
-        self.assertTrue(message.is_inbound)
 
-        message = conversation.add_message(body="Hi there", is_inbound=False, twilio_sid='')
-        self.assertEqual(message.body, "Hi there")
-        self.assertFalse(message.is_inbound)
+        for i in range(5):
+            conversation.add_message(body=f'Message {i}', is_inbound=True, twilio_sid='')
 
-        self.assertEqual(conversation.messages.count(), 2)
-        self.assertFalse(conversation.is_empty)
+        messages = conversation.messages.newest_by_count_reversed(5)
 
+        assert len(messages) == 5

django_spire/ai/sms/tests/test_sms_intel.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from django_spire.ai.sms.intel import SmsIntel
+from django_spire.core.tests.test_cases import BaseTestCase
+
+
+class SmsIntelTests(BaseTestCase):
+    def test_sms_intel_creation(self) -> None:
+        intel = SmsIntel(body='Test message')
+
+        assert intel.body == 'Test message'
+
+    def test_sms_intel_empty_body(self) -> None:
+        intel = SmsIntel(body='')
+
+        assert intel.body == ''
+
+    def test_sms_intel_long_body(self) -> None:
+        long_body = 'A' * 1000
+        intel = SmsIntel(body=long_body)
+
+        assert intel.body == long_body
+        assert len(intel.body) == 1000
+
+    def test_sms_intel_unicode_body(self) -> None:
+        unicode_body = 'Hello 世界 🌍'
+        intel = SmsIntel(body=unicode_body)
+
+        assert intel.body == unicode_body
+
+    def test_sms_intel_model_dump(self) -> None:
+        intel = SmsIntel(body='Test')
+        dump = intel.model_dump()
+
+        assert 'body' in dump
+        assert dump['body'] == 'Test'
+
+    def test_sms_intel_special_characters(self) -> None:
+        special_body = 'Line 1\nLine 2\tTabbed'
+        intel = SmsIntel(body=special_body)
+
+        assert intel.body == special_body

django_spire/ai/sms/tests/test_webhook.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from unittest.mock import patch
 
 from django.urls import reverse
@@ -7,13 +9,13 @@ from django_spire.core.tests.test_cases import BaseTestCase
 
 
 class SmsWebhookTests(BaseTestCase):
-    def setUp(self):
+    def setUp(self) -> None:
         super().setUp()
 
         self.webhook_url = reverse('django_spire:ai:sms:webhook')
 
     @patch('twilio.request_validator.RequestValidator.validate')
-    def test_webhook_receives_message(self, mock_validate):
+    def test_webhook_receives_message(self, mock_validate) -> None:
         mock_validate.return_value = True
 
         response = self.client.post(
@@ -25,14 +27,160 @@ class SmsWebhookTests(BaseTestCase):
             }
         )
 
-        self.assertEqual(response.status_code, 200)
+        assert response.status_code == 200
 
         conversation = SmsConversation.objects.get(phone_number='+15551234567')
-        self.assertEqual(conversation.messages.count(), 2)  # Inbound and outbound
+        assert conversation.messages.count() == 2
 
         inbound_message = conversation.messages.filter(is_inbound=True).first()
-        self.assertEqual(inbound_message.body, 'Hello')
-        self.assertEqual(inbound_message.twilio_sid, 'SM123456789')
+        assert inbound_message.body == 'Hello'
+        assert inbound_message.twilio_sid == 'SM123456789'
 
         outbound_message = conversation.messages.filter(is_inbound=False).first()
-        self.assertTrue(len(outbound_message.body) > 0)
+        assert len(outbound_message.body) > 0
+
+    @patch('twilio.request_validator.RequestValidator.validate')
+    def test_webhook_creates_conversation(self, mock_validate) -> None:
+        mock_validate.return_value = True
+
+        initial_count = SmsConversation.objects.count()
+
+        self.client.post(
+            self.webhook_url,
+            {
+                'From': '+15559999999',
+                'Body': 'New conversation',
+                'MessageSid': 'SM999999999'
+            }
+        )
+
+        assert SmsConversation.objects.count() == initial_count + 1
+
+    @patch('twilio.request_validator.RequestValidator.validate')
+    def test_webhook_reuses_existing_conversation(self, mock_validate) -> None:
+        mock_validate.return_value = True
+
+        SmsConversation.objects.create(phone_number='+15551234567')
+
+        initial_count = SmsConversation.objects.count()
+
+        self.client.post(
+            self.webhook_url,
+            {
+                'From': '+15551234567',
+                'Body': 'Another message',
+                'MessageSid': 'SM123456789'
+            }
+        )
+
+        assert SmsConversation.objects.count() == initial_count
+
+    @patch('twilio.request_validator.RequestValidator.validate')
+    def test_webhook_invalid_signature(self, mock_validate) -> None:
+        mock_validate.return_value = False
+
+        response = self.client.post(
+            self.webhook_url,
+            {
+                'From': '+15551234567',
+                'Body': 'Hello',
+                'MessageSid': 'SM123456789'
+            }
+        )
+
+        assert response.status_code == 403
+
+    @patch('twilio.request_validator.RequestValidator.validate')
+    def test_webhook_short_phone_number(self, mock_validate) -> None:
+        mock_validate.return_value = True
+
+        response = self.client.post(
+            self.webhook_url,
+            {
+                'From': '1234',
+                'Body': 'Hello',
+                'MessageSid': 'SM123456789'
+            }
+        )
+
+        assert response.status_code == 403
+
+    @patch('twilio.request_validator.RequestValidator.validate')
+    def test_webhook_empty_body(self, mock_validate) -> None:
+        mock_validate.return_value = True
+
+        response = self.client.post(
+            self.webhook_url,
+            {
+                'From': '+15551234567',
+                'Body': '',
+                'MessageSid': 'SM123456789'
+            }
+        )
+
+        assert response.status_code == 200
+
+    @patch('twilio.request_validator.RequestValidator.validate')
+    def test_webhook_marks_inbound_as_processed(self, mock_validate) -> None:
+        mock_validate.return_value = True
+
+        self.client.post(
+            self.webhook_url,
+            {
+                'From': '+15551234567',
+                'Body': 'Test message',
+                'MessageSid': 'SM123456789'
+            }
+        )
+
+        conversation = SmsConversation.objects.get(phone_number='+15551234567')
+        inbound_message = conversation.messages.filter(is_inbound=True).first()
+
+        assert inbound_message.is_processed
+
+    @patch('twilio.request_validator.RequestValidator.validate')
+    def test_webhook_response_is_twiml(self, mock_validate) -> None:
+        mock_validate.return_value = True
+
+        response = self.client.post(
+            self.webhook_url,
+            {
+                'From': '+15551234567',
+                'Body': 'Hello',
+                'MessageSid': 'SM123456789'
+            }
+        )
+
+        assert b'<Response>' in response.content or b'Response' in response.content
+
+    @patch('twilio.request_validator.RequestValidator.validate')
+    def test_webhook_missing_from(self, mock_validate) -> None:
+        mock_validate.return_value = True
+
+        response = self.client.post(
+            self.webhook_url,
+            {
+                'Body': 'Hello',
+                'MessageSid': 'SM123456789'
+            }
+        )
+
+        assert response.status_code == 403
+
+    @patch('twilio.request_validator.RequestValidator.validate')
+    def test_webhook_stores_twilio_sid(self, mock_validate) -> None:
+        mock_validate.return_value = True
+
+        self.client.post(
+            self.webhook_url,
+            {
+                'From': '+15551234567',
+                'Body': 'Hello',
+                'MessageSid': 'SM_TEST_SID_123'
+            }
+        )
+
+        conversation = SmsConversation.objects.get(phone_number='+15551234567')
+        inbound_message = conversation.messages.filter(is_inbound=True).first()
+
+        assert inbound_message.twilio_sid == 'SM_TEST_SID_123'