django-spire 0.23.4__py3-none-any.whl

django_spire/ai/prompt/tuning/prompt_tuning_cli.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from dandy import Recorder
+
+from django_spire.ai.prompt.bots import DandyPythonPromptBot
+from django_spire.ai.prompt.tuning.bots import SimplePromptTuningBot
+
+
+def prompt_tuning_cli(prompt: str):
+    Recorder.start_recording(recording_name='prompt_tuning')
+
+    holding = prompt
+    tuning_bot = SimplePromptTuningBot()
+
+    print('----------------------------------------------------')
+
+    while True:
+        print("\nEnter your feedback (or type 'stop' to finish):")
+        feedback = input()
+
+        if feedback == "stop":
+            break
+
+        print('Attempting to tune prompt.....')
+
+        new_prompt = tuning_bot.process(holding, feedback)
+        holding = new_prompt.prompt
+
+        print('----------------------NEW PROMPT START------------------------------')
+        print()
+        print(new_prompt.prompt)
+        print()
+        print('----------------------NEW PROMPT END------------------------------')
+        print()
+
+    Recorder.stop_recording(recording_name='prompt_tuning')
+    Recorder.to_html_file(recording_name='prompt_tuning')
+
+    python_bot = DandyPythonPromptBot()
+    python_bot.process(prompt)

django_spire/ai/prompt/tuning/prompts.py

@@ -0,0 +1,204 @@
+from __future__ import annotations
+
+from dandy import Prompt
+
+
+def prompt_tuning_instruction_bot_prompt():
+    return (
+        Prompt()
+        .heading('System Prompt Tuning Expert')
+        .text(
+            'You are an expert prompt engineer specializing in analyzing and tuning system prompts for Large Language Models (LLMs).')
+        .line_break()
+        .heading('Goal').text('Analyze the provided prompt and user feedback to create a tuned version of the system prompt that meets the users\' needs.')
+        .line_break()
+        .heading('Rules')
+        .ordered_list([
+            'Preserve Core Purpose: Maintain the fundamental goal and role of the original prompt while making improvements.',
+            'Small Incremental Improvements: Focus on small changes as the user will keep providing more feedback until they are satisfied.',
+            'Adaptability: You can add, create, or remove parts of the prompt to better align with the user\'s feedback but ensure to keep the overall structure. ',
+        ])
+        .line_break()
+        .heading('Input Format')
+        .text('You will receive:')
+        .ordered_list([
+            'System Prompt: The original system prompt that needs tuning',
+            'Feedback: The user\'s feedback about issues with the current prompt and what they want to improve',
+        ])
+    )
+
+
+def formatting_bot_instruction_prompt():
+    return (
+        Prompt()
+        .heading('Prompt Formatting Expert')
+        .text(
+            'You are a specialized prompt engineer focused on improving the formatting and structure of system prompts for Large Language Models (LLMs).')
+        .line_break()
+        .heading('Goal')
+        .text(
+            'Analyze the provided system prompt and improve its formatting and structure while preserving its content and intent.')
+        .line_break()
+        .heading('Rules')
+        .ordered_list([
+            'Preserve Content: Maintain all the information and instructions from the original prompt.',
+            'Improve Structure: Organize content into clear sections with appropriate headings.',
+            'Standardize Formatting: Apply consistent formatting for similar elements (lists, examples, etc.).',
+            'Enhance Readability: Use proper spacing, indentation, and line breaks to improve readability.',
+            'Maintain Hierarchy: Ensure logical hierarchy of information with primary and secondary points clearly distinguished.',
+        ])
+        .line_break()
+        .heading('Input Format')
+        .text('You will receive:')
+        .ordered_list([
+            'System Prompt: The original system prompt that needs formatting improvements',
+        ])
+        .line_break()
+        .heading('Output Format')
+        .text('Return a reformatted system prompt that maintains the original content but with improved structure and formatting.')
+    )
+
+
+def instruction_clarity_bot_instruction_prompt():
+    return (
+        Prompt()
+        .heading('Instruction Clarity Expert')
+        .text(
+            'You are a specialized prompt engineer focused on improving the clarity of instructions in system prompts for Large Language Models (LLMs).')
+        .line_break()
+        .heading('Goal')
+        .text(
+            'Analyze the provided system prompt and improve the clarity of its instructions while maintaining its intent.')
+        .line_break()
+        .heading('Rules')
+        .ordered_list([
+            'Identify Ambiguities: Find and resolve any ambiguous or unclear instructions.',
+            'Enhance Precision: Make instructions more precise and specific where needed.',
+            'Improve Logical Flow: Ensure instructions follow a logical sequence.',
+            'Add Context: Provide necessary context for complex instructions.',
+            'Simplify Complex Instructions: Break down complex instructions into simpler steps when appropriate.',
+        ])
+        .line_break()
+        .heading('Input Format')
+        .text('You will receive:')
+        .ordered_list([
+            'System Prompt: The original system prompt that needs instruction clarity improvements',
+        ])
+        .line_break()
+        .heading('Output Format')
+        .text('Return an improved system prompt with clearer, more precise instructions.')
+    )
+
+
+def persona_bot_instruction_prompt():
+    return (
+        Prompt()
+        .heading('Persona Consistency Expert')
+        .text(
+            'You are a specialized prompt engineer focused on maintaining consistent tone and persona in system prompts for Large Language Models (LLMs).')
+        .line_break()
+        .heading('Goal')
+        .text(
+            'Analyze the provided system prompt and ensure it maintains a consistent tone, voice, and persona throughout.')
+        .line_break()
+        .heading('Rules')
+        .ordered_list([
+            'Identify Tone: Determine the intended tone of the prompt (formal, conversational, authoritative, etc.).',
+            'Ensure Consistency: Make sure the tone and voice remain consistent throughout the prompt.',
+            'Align with Purpose: Ensure the persona aligns with the prompt\'s purpose and intended audience.',
+            'Standardize Language: Use consistent terminology and phrasing throughout.',
+            'Preserve Character: If the prompt defines a specific character or role, ensure all language aligns with that character.',
+        ])
+        .line_break()
+        .heading('Input Format')
+        .text('You will receive:')
+        .ordered_list([
+            'System Prompt: The original system prompt that needs persona consistency improvements',
+        ])
+        .line_break()
+        .heading('Output Format')
+        .text('Return an improved system prompt with consistent tone, voice, and persona throughout.')
+    )
+
+
+def duplication_removal_bot_instruction_prompt():
+    return (
+        Prompt()
+        .heading('Duplication Removal Expert')
+        .text(
+            'You are a specialized prompt engineer focused on identifying and removing redundancies in system prompts for Large Language Models (LLMs).')
+        .line_break()
+        .heading('Goal')
+        .text(
+            'Analyze the provided system prompt and remove any duplicated or redundant content while preserving all unique information.')
+        .line_break()
+        .heading('Rules')
+        .ordered_list([
+            'Identify Redundancies: Find repeated information, instructions, or concepts.',
+            'Consolidate Information: Combine similar or related points into concise statements.',
+            'Preserve Unique Content: Ensure no unique information is lost when removing duplications.',
+            'Maintain Context: Keep necessary context when consolidating information.',
+            'Improve Flow: Ensure the prompt flows naturally after removing redundancies.',
+        ])
+        .line_break()
+        .heading('Input Format')
+        .text('You will receive:')
+        .ordered_list([
+            'System Prompt: The original system prompt that may contain duplicated content',
+        ])
+        .line_break()
+        .heading('Output Format')
+        .text('Return an improved system prompt with duplications removed and information consolidated.')
+    )
+
+
+def example_optimization_bot_instruction_prompt():
+    return (
+        Prompt()
+        .heading('Example Optimization Expert')
+        .text(
+            'You are a specialized prompt engineer focused on refining examples within system prompts for Large Language Models (LLMs).')
+        .line_break()
+        .heading('Goal')
+        .text(
+            'Analyze the provided system prompt and optimize the examples to better illustrate the desired behavior and outputs.')
+        .line_break()
+        .heading('Rules')
+        .ordered_list([
+            'Assess Current Examples: Evaluate the effectiveness of existing examples.',
+            'Improve Clarity: Make examples clearer and more illustrative of the desired behavior.',
+            'Ensure Diversity: Ensure examples cover a range of scenarios and edge cases.',
+            'Balance Complexity: Include both simple and more complex examples when appropriate.',
+            'Align with Instructions: Ensure examples clearly demonstrate the instructions they support.',
+        ])
+        .line_break()
+        .heading('Input Format')
+        .text('You will receive:')
+        .ordered_list([
+            'System Prompt: The original system prompt containing examples that need optimization',
+        ])
+        .line_break()
+        .heading('Output Format')
+        .text('Return an improved system prompt with optimized examples that better illustrate the desired behavior.')
+    )
+
+
+def prompt_tuning_input_prompt(system_prompt: str, feedback: str):
+    return (
+        Prompt()
+        .heading('User Supplies System Prompt')
+        .line_break()
+        .text(system_prompt)
+        .line_break()
+        .heading('Feedback')
+        .text(feedback)
+    )
+
+
+def specialized_bot_input_prompt(system_prompt: str):
+    return (
+        Prompt()
+        .heading('System Prompt for Analysis')
+        .line_break()
+        .text(system_prompt)
+    )

django_spire/ai/sms/admin.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from urllib.parse import urlencode
+
+from django.contrib import admin
+from django.urls import reverse
+from django.utils.html import format_html
+
+from django_spire.ai.sms.models import SmsConversation, SmsMessage
+
+
+class SmsMessageInline(admin.TabularInline):
+    model = SmsMessage
+    extra = 0
+    readonly_fields = ('created_datetime', )
+    fields = ('body', 'is_inbound', 'is_processed', 'twilio_sid', 'created_datetime')
+
+
+@admin.register(SmsConversation)
+class SmsConversationAdmin(admin.ModelAdmin):
+    list_display = ('phone_number', 'user', 'last_message_datetime', 'view_sms_messages_link')
+    search_fields = ('phone_number', 'user__username', 'user__email')
+    readonly_fields = ('created_datetime', )
+    inlines = [SmsMessageInline]
+
+    def view_sms_messages_link(self, obj):
+        count = obj.messages.count()
+
+        url = (
+                reverse("admin:django_spire_ai_sms_smsmessage_changelist")
+                + "?"
+                + urlencode({"sms_conversation__id": f"{obj.id}"})
+        )
+
+        return format_html('<a href="%s">%s Messages</a>' % (url, count))
+
+    view_sms_messages_link.short_description = "Messages"
+
+    class Meta:
+        ordering = ('phone_number', )
+
+
+
+@admin.register(SmsMessage)
+class SmsMessageAdmin(admin.ModelAdmin):
+    list_display = ('__str__', 'conversation', 'is_inbound', 'is_processed', 'created_datetime')
+    list_filter = ('is_inbound', 'is_processed')
+    search_fields = ('body', 'conversation__phone_number')
+    readonly_fields = ('created_datetime', )
+
+    class Meta:
+        ordering = ('created_datetime', )

django_spire/ai/sms/apps.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from django.apps import AppConfig
+
+from django_spire.utils import check_required_apps
+
+
+class SmsConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'django_spire.ai.sms'
+    label = 'django_spire_ai_sms'
+
+    REQUIRED_APPS = ('django_spire_ai', 'django_spire_ai_context')
+
+    def ready(self) -> None:
+        check_required_apps(self.label)

django_spire/ai/sms/decorators.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import functools
+import os
+
+from django.http import HttpResponseForbidden
+from twilio.request_validator import RequestValidator
+
+
+def twilio_auth_required(func):
+    @functools.wraps(func)
+    def decorated_function(request, *args, **kwargs):
+        request_validator = RequestValidator(os.environ.get('TWILIO_AUTH_TOKEN', ''))
+
+        absolute_uri = request.build_absolute_uri()
+
+        if absolute_uri[:5] == 'http:':
+            absolute_uri = 'https' + absolute_uri[4:]
+
+        request_valid = request_validator.validate(
+            absolute_uri,
+            request.POST,
+            request.META.get('HTTP_X_TWILIO_SIGNATURE', '')
+        )
+
+        if request_valid:
+            return func(request, *args, **kwargs)
+
+        return HttpResponseForbidden()
+
+    return decorated_function

django_spire/ai/sms/intel.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from dandy import BaseIntel
+
+
+class SmsIntel(BaseIntel):
+    body: str

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

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from dandy.recorder import recorder_to_html_file
+
+from django_spire.ai.chat.intelligence.workflows.chat_workflow import chat_workflow
+from django_spire.ai.sms.intel import SmsIntel
+
+if TYPE_CHECKING:
+    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=message_intel.render_to_str()
+    )

django_spire/ai/sms/migrations/0001_initial.py

@@ -0,0 +1,56 @@
+# Generated by Django 5.2.1 on 2025-06-04 23:48
+
+import django.db.models.deletion
+import django.utils.timezone
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='SmsConversation',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('is_active', models.BooleanField(default=True, editable=False)),
+                ('is_deleted', models.BooleanField(default=False, editable=False)),
+                ('created_datetime', models.DateTimeField(default=django.utils.timezone.localtime, editable=False)),
+                ('phone_number', models.CharField(max_length=20)),
+                ('last_message_datetime', models.DateTimeField(default=django.utils.timezone.now, editable=False)),
+                ('user', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='sms_conversations', related_query_name='sms_conversation', to=settings.AUTH_USER_MODEL)),
+            ],
+            options={
+                'verbose_name': 'SMS Conversation',
+                'verbose_name_plural': 'SMS Conversations',
+                'db_table': 'django_spire_ai_sms_conversation',
+                'ordering': ('-last_message_datetime',),
+            },
+        ),
+        migrations.CreateModel(
+            name='SmsMessage',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('is_active', models.BooleanField(default=True, editable=False)),
+                ('is_deleted', models.BooleanField(default=False, editable=False)),
+                ('created_datetime', models.DateTimeField(default=django.utils.timezone.localtime, editable=False)),
+                ('body', models.TextField()),
+                ('is_inbound', models.BooleanField(default=False)),
+                ('twilio_sid', models.CharField(blank=True, max_length=64, null=True)),
+                ('is_processed', models.BooleanField(default=False)),
+                ('conversation', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='messages', related_query_name='message', to='django_spire_ai_sms.smsconversation')),
+            ],
+            options={
+                'verbose_name': 'SMS Message',
+                'verbose_name_plural': 'SMS Messages',
+                'db_table': 'django_spire_ai_sms_message',
+                'ordering': ('-created_datetime',),
+            },
+        ),
+    ]

django_spire/ai/sms/models.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+from dandy.llm.request.message import MessageHistory, RoleLiteralStr
+from django.contrib.auth.models import User
+from django.db import models
+from django.utils.timezone import now
+
+from django_spire.ai.sms.querysets import SmsConversationQuerySet, SmsMessageQuerySet
+from django_spire.history.mixins import HistoryModelMixin
+
+
+class SmsConversation(HistoryModelMixin):
+    user = models.ForeignKey(
+        User,
+        blank=True,
+        null=True,
+        on_delete=models.SET_NULL,
+        related_name='sms_conversations',
+        related_query_name='sms_conversation'
+    )
+
+    phone_number = models.CharField(max_length=20)
+    last_message_datetime = models.DateTimeField(default=now, editable=False)
+
+    objects = SmsConversationQuerySet.as_manager()
+
+    def __str__(self):
+        return f"SMS Conversation with {self.phone_number}"
+
+    def add_message(
+        self,
+        body: str,
+        is_inbound: bool,
+        twilio_sid: str,
+        is_processed: bool = False
+    ):
+        message = self.messages.create(
+            body=body,
+            is_inbound=is_inbound,
+            twilio_sid=twilio_sid,
+            is_processed=is_processed,
+        )
+
+        self.last_message_datetime = now()
+        self.save()
+
+        return message
+
+    def generate_message_history(
+        self,
+        message_count: int = 20,
+        exclude_last_message: bool = True
+    ) -> MessageHistory:
+        message_history = MessageHistory()
+
+        messages = self.messages.newest_by_count(message_count)
+
+        if exclude_last_message:
+            messages = messages[1:]
+
+        messages = list(reversed(messages))
+
+        for message in messages:
+            message_history.add_message(
+                role=message.role,
+                content=message.body
+            )
+
+        return message_history
+
+    @property
+    def is_empty(self) -> bool:
+        return self.messages.count() == 0
+
+    class Meta:
+        db_table = 'django_spire_ai_sms_conversation'
+        verbose_name = 'SMS Conversation'
+        verbose_name_plural = 'SMS Conversations'
+        ordering = ('-last_message_datetime',)
+
+
+class SmsMessage(HistoryModelMixin):
+    conversation = models.ForeignKey(
+        SmsConversation,
+        on_delete=models.CASCADE,
+        related_name='messages',
+        related_query_name='message'
+    )
+
+    body = models.TextField()
+
+    is_inbound = models.BooleanField(default=False)
+
+    twilio_sid = models.CharField(max_length=64, blank=True, null=True)
+
+    is_processed = models.BooleanField(default=False)
+
+    objects = SmsMessageQuerySet.as_manager()
+
+    def __str__(self):
+        if len(self.body) < 64:
+            return f"{self.direction}: {self.body}"
+
+        return f"{self.direction}: {self.body[:64]}..."
+
+    @property
+    def direction(self) -> str:
+        return "Inbound" if self.is_inbound else "Outbound"
+
+    @property
+    def is_outbound(self) -> bool:
+        return not self.is_inbound
+
+    @property
+    def role(self) -> RoleLiteralStr:
+        if self.is_inbound:
+            return 'user'
+
+        if self.is_outbound:
+            return 'assistant'
+
+        return 'system'
+
+    class Meta:
+        db_table = 'django_spire_ai_sms_message'
+        verbose_name = 'SMS Message'
+        verbose_name_plural = 'SMS Messages'
+        ordering = ('-created_datetime',)

django_spire/ai/sms/querysets.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from django_spire.history.querysets import HistoryQuerySet
+
+
+class SmsConversationQuerySet(HistoryQuerySet):
+    def by_phone_number(self, phone_number: str):
+        return self.filter(
+            phone_number=phone_number,
+        )
+
+
+class SmsMessageQuerySet(HistoryQuerySet):
+    def newest_by_count(self, count: int = 20):
+        return self.order_by('-created_datetime')[:count]
+
+    def newest_by_count_reversed(self, count: int = 20):
+        return self.order_by('-created_datetime')[:count][::-1]

django_spire/ai/sms/tests/test_sms.py

@@ -0,0 +1,30 @@
+from django.test import TestCase
+
+from django_spire.ai.sms.models import SmsConversation
+
+
+class SmsModelTests(TestCase):
+    def test_conversation_creation(self):
+        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 = 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)
+
+        self.assertEqual(conversation.messages.count(), 2)
+        self.assertFalse(conversation.is_empty)
+

django_spire/ai/sms/tests/test_webhook.py

@@ -0,0 +1,38 @@
+from unittest.mock import patch
+
+from django.urls import reverse
+
+from django_spire.ai.sms.models import SmsConversation
+from django_spire.core.tests.test_cases import BaseTestCase
+
+
+class SmsWebhookTests(BaseTestCase):
+    def setUp(self):
+        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):
+        mock_validate.return_value = True
+
+        response = self.client.post(
+            self.webhook_url,
+            {
+                'From': '+15551234567',
+                'Body': 'Hello',
+                'MessageSid': 'SM123456789'
+            }
+        )
+
+        self.assertEqual(response.status_code, 200)
+
+        conversation = SmsConversation.objects.get(phone_number='+15551234567')
+        self.assertEqual(conversation.messages.count(), 2)  # Inbound and outbound
+
+        inbound_message = conversation.messages.filter(is_inbound=True).first()
+        self.assertEqual(inbound_message.body, 'Hello')
+        self.assertEqual(inbound_message.twilio_sid, 'SM123456789')
+
+        outbound_message = conversation.messages.filter(is_inbound=False).first()
+        self.assertTrue(len(outbound_message.body) > 0)

django_spire/ai/sms/urls.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from django.urls import path
+
+from django_spire.ai.sms import views
+
+
+app_name = 'sms'
+
+urlpatterns = [
+    path('webhook/', views.webhook_view, name='webhook'),
+]