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

django_spire/ai/sms/views.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from typing import TYPE_CHECKING
+
 from django.http import HttpResponse, HttpResponseForbidden
 from django.views.decorators.csrf import csrf_exempt
 from django.views.decorators.http import require_POST
@@ -9,11 +11,14 @@ from django_spire.ai.sms.decorators import twilio_auth_required
 from django_spire.ai.sms.intelligence.workflows.sms_conversation_workflow import sms_conversation_workflow
 from django_spire.ai.sms.models import SmsConversation
 
+if TYPE_CHECKING:
+    from django.core.handlers.wsgi import WSGIRequest
+
 
 @csrf_exempt
 @require_POST
 @twilio_auth_required
-def webhook_view(request):
+def webhook_view(request: WSGIRequest):
     from_number = request.POST.get('From', '')
 
     if len(from_number) < 11:
@@ -32,30 +37,24 @@ def webhook_view(request):
         twilio_sid=message_sid,
     )
 
-    try:
-        sms_intel = sms_conversation_workflow(
-            request=request,
-            user_input=body,
-            message_history=conversation.generate_message_history(),
-            actor=from_number,
-        )
-
-        twiml_response = MessagingResponse()
-        twiml_response.message(sms_intel.body)
-
-        conversation.add_message(
-            body=sms_intel.body,
-            is_inbound=False,
-            twilio_sid=message_sid,
-            is_processed=True
-        )
-
-        message.is_processed = True
-        message.save()
+    sms_intel = sms_conversation_workflow(
+        request=request,
+        user_input=body,
+        message_history=conversation.generate_message_history(),
+        actor=from_number,
+    )
 
-        return HttpResponse(twiml_response)
-    except:
-        raise
+    twiml_response = MessagingResponse()
+    twiml_response.message(sms_intel.body)
 
+    conversation.add_message(
+        body=sms_intel.body,
+        is_inbound=False,
+        twilio_sid=message_sid,
+        is_processed=True
+    )
 
+    message.is_processed = True
+    message.save()
 
+    return HttpResponse(twiml_response)

django_spire/ai/tests/test_ai.py

@@ -3,16 +3,20 @@ from __future__ import annotations
 from dandy import BaseIntel, Bot, recorder_to_html_file
 
 from django_spire.ai.decorators import log_ai_interaction_from_recorder
+from django_spire.ai.models import AiInteraction, AiUsage
 from django_spire.core.tests.test_cases import BaseTestCase
 
 
-class AiTestCase(BaseTestCase):
-    def test_ai_interaction_decorator(self):
-        class HorseIntel(BaseIntel):
-            first_name: str
-            breed: str
-            color: str
-            has_cone_taped_to_head: bool
+class HorseIntel(BaseIntel):
+    breed: str
+    color: str
+    first_name: str
+    has_cone_taped_to_head: bool
+
+
+class AiDecoratorTestCase(BaseTestCase):
+    def test_ai_interaction_decorator_creates_usage_record(self) -> None:
+        initial_count = AiUsage.objects.count()
 
         @log_ai_interaction_from_recorder(self.super_user, 'horse')
         @recorder_to_html_file('horse')
@@ -26,3 +30,123 @@ class AiTestCase(BaseTestCase):
         horse_intel = generate_horse_intel('Make me a magical horse that grants wishes!')
 
         assert horse_intel.first_name != ''
+        assert AiUsage.objects.count() >= initial_count
+
+    def test_ai_interaction_decorator_creates_interaction_record(self) -> None:
+        initial_count = AiInteraction.objects.count()
+
+        @log_ai_interaction_from_recorder(self.super_user, 'test_actor')
+        @recorder_to_html_file('test_interaction')
+        def generate_horse_intel(user_input: str) -> HorseIntel:
+            bot = Bot()
+            return bot.llm.prompt_to_intel(
+                prompt=user_input,
+                intel_class=HorseIntel,
+            )
+
+        generate_horse_intel('Create a horse')
+
+        assert AiInteraction.objects.count() > initial_count
+
+    def test_ai_interaction_decorator_requires_user_or_actor(self) -> None:
+        try:
+            @log_ai_interaction_from_recorder()
+            def dummy_func() -> None:
+                pass
+        except ValueError as e:
+            assert 'user or actor must be provided' in str(e)
+        else:
+            assert False, 'Expected ValueError'
+
+    def test_ai_interaction_decorator_with_actor_only(self) -> None:
+        @log_ai_interaction_from_recorder(actor='test_actor_only')
+        @recorder_to_html_file('test_actor_only')
+        def generate_horse_intel(user_input: str) -> HorseIntel:
+            bot = Bot()
+            return bot.llm.prompt_to_intel(
+                prompt=user_input,
+                intel_class=HorseIntel,
+            )
+
+        horse_intel = generate_horse_intel('Create a horse')
+
+        assert horse_intel is not None
+
+        interaction = AiInteraction.objects.filter(actor='test_actor_only').first()
+        assert interaction is not None
+        assert interaction.actor == 'test_actor_only'
+
+    def test_ai_interaction_decorator_records_module_and_callable(self) -> None:
+        @log_ai_interaction_from_recorder(self.super_user, 'module_test')
+        @recorder_to_html_file('module_test')
+        def test_callable(user_input: str) -> HorseIntel:
+            bot = Bot()
+            return bot.llm.prompt_to_intel(
+                prompt=user_input,
+                intel_class=HorseIntel,
+            )
+
+        test_callable('Test input')
+
+        interaction = AiInteraction.objects.filter(actor='module_test').first()
+        assert interaction is not None
+        assert 'test_callable' in interaction.callable_name
+
+
+class AiUsageModelTestCase(BaseTestCase):
+    def test_ai_usage_str(self) -> None:
+        ai_usage = AiUsage.objects.create()
+
+        assert 'ai usage' in str(ai_usage)
+
+    def test_ai_usage_default_values(self) -> None:
+        ai_usage = AiUsage.objects.create()
+
+        assert ai_usage.event_count == 0
+        assert ai_usage.token_usage == 0
+        assert ai_usage.run_time_seconds == 0.0
+        assert ai_usage.was_successful is True
+
+
+class AiInteractionModelTestCase(BaseTestCase):
+    def test_ai_interaction_str(self) -> None:
+        ai_usage = AiUsage.objects.create()
+        ai_interaction = AiInteraction.objects.create(
+            ai_usage=ai_usage,
+            actor='test_actor',
+            module_name='test_module',
+            callable_name='test_callable',
+        )
+
+        assert 'test_actor' in str(ai_interaction)
+        assert 'interaction' in str(ai_interaction)
+
+    def test_ai_interaction_saves_user_info(self) -> None:
+        ai_usage = AiUsage.objects.create()
+        ai_interaction = AiInteraction.objects.create(
+            ai_usage=ai_usage,
+            user=self.super_user,
+            actor=None,
+            module_name='test_module',
+            callable_name='test_callable',
+        )
+
+        assert ai_interaction.user_email == self.super_user.email
+        assert ai_interaction.user_first_name == self.super_user.first_name
+        assert ai_interaction.user_last_name == self.super_user.last_name
+
+    def test_ai_interaction_default_values(self) -> None:
+        ai_usage = AiUsage.objects.create()
+        ai_interaction = AiInteraction.objects.create(
+            ai_usage=ai_usage,
+            actor='test',
+            module_name='test',
+            callable_name='test',
+        )
+
+        assert ai_interaction.event_count == 0
+        assert ai_interaction.token_usage == 0
+        assert ai_interaction.run_time_seconds == 0.0
+        assert ai_interaction.was_successful is True
+        assert ai_interaction.exception is None
+        assert ai_interaction.stack_trace is None

django_spire/auth/apps.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from django.apps import AppConfig
 
 from django_spire.utils import check_required_apps
@@ -9,9 +11,9 @@ class AuthConfig(AppConfig):
     name = 'django_spire.auth'
 
     REQUIRED_APPS = ('django_spire_core',)
-    
+
     URLPATTERNS_INCLUDE = 'django_spire.auth.urls'
     URLPATTERNS_NAMESPACE = 'auth'
 
     def ready(self) -> None:
-        check_required_apps(self.label)
+        check_required_apps(self.label)

django_spire/auth/controller/controller.py

@@ -1,23 +1,34 @@
+from __future__ import annotations
+
 import functools
 
+from typing import TYPE_CHECKING
+
 from django.core.exceptions import PermissionDenied
-from django.core.handlers.wsgi import WSGIRequest
 
+from django_spire.auth.controller.exceptions import (
+    AuthControllerNotFoundError,
+    AuthControllerRequestError
+)
 from django_spire.auth.permissions.decorators import permission_required_decorator_function
+from django_spire.conf import settings
 from django_spire.core.utils import get_object_from_module_string
 
+if TYPE_CHECKING:
+    from typing import Any, Callable
+
+    from django.core.handlers.wsgi import WSGIRequest
+
 
 class BaseAuthController:
-    def __init__(
-            self,
-            request: WSGIRequest | None = None
-    ):
+    def __init__(self, request: WSGIRequest | None = None):
         self._request = request
 
     @property
     def request(self):
         if self._request is None:
-            raise Exception('AuthController.request is None')
+            message = 'AuthController.request is None'
+            raise AuthControllerRequestError(message)
 
         return self._request
 
@@ -26,12 +37,11 @@ class BaseAuthController:
         self._request = value
 
     def permission_required(
-            self,
-            *permissions: str,
-            all_required: bool = True
+        self,
+        *permissions: str,
+        all_required: bool = True
     ):
-
-        def decorator(method):
+        def decorator(method: Callable[..., Any]):
             @functools.wraps(method)
             def wrapper(request: WSGIRequest, *args, **kwargs):
                 self.request = request
@@ -40,12 +50,16 @@ class BaseAuthController:
 
                 for perm in permissions:
                     callable_permission = (
-                        getattr(self, perm) if hasattr(self, perm) else perm
+                        getattr(self, perm)
+                        if hasattr(self, perm)
+                        else perm
                     )
+
                     if callable(callable_permission):
                         if not all_required and callable_permission():
                             return method(request, *args, **kwargs)
-                        elif not callable_permission():
+
+                        if not callable_permission():
                             raise PermissionDenied
 
                     else:
@@ -67,18 +81,17 @@ class BaseAuthController:
 
 class AppAuthController:
     def __new__(
-            cls,
-            app_name: str,
-            request: WSGIRequest | None = None,
-            **kwargs
+        cls,
+        app_name: str,
+        request: WSGIRequest | None = None,
+        **kwargs: dict[str, Any]
     ):
-        from django_spire.conf import settings
-
         if app_name not in settings.DJANGO_SPIRE_AUTH_CONTROLLERS:
-            raise Exception(f'Controller {app_name} not found in settings.AUTH_CONTROLLERS')
+            message = f'Controller {app_name} not found in settings.AUTH_CONTROLLERS'
+            raise AuthControllerNotFoundError(message)
 
         try:
             return get_object_from_module_string(settings.DJANGO_SPIRE_AUTH_CONTROLLERS[app_name])(request)
-
-        except ModuleNotFoundError:
-            raise Exception(f'Auth Controller for {app_name} not found')
+        except ModuleNotFoundError as err:
+            message = f'Auth Controller for {app_name} not found'
+            raise AuthControllerNotFoundError(message) from err

django_spire/auth/controller/exceptions.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+
+class AuthControllerRequestError(Exception):
+    pass
+
+
+class AuthControllerNotFoundError(Exception):
+    pass

django_spire/auth/group/admin.py

@@ -5,6 +5,7 @@ from django.urls import reverse
 from django.utils.html import format_html
 
 import django_spire.auth.user.models
+
 from django_spire.auth.group import models
 from django_spire.auth.user.tools import add_user_to_all_user_group
 

django_spire/auth/group/apps.py

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

django_spire/auth/group/factories.py

@@ -3,13 +3,22 @@ from __future__ import annotations
 from django_spire.auth.group.models import AuthGroup
 
 
-def bulk_create_groups_from_names(names: list[str]):
-    existing_groups = AuthGroup.objects.all().values_list('name', flat=True)
-
-    new_groups = [
-        AuthGroup(name=name)
-        for name in names
-        if name not in existing_groups
-    ]
+def bulk_create_groups_from_names(names: list[str]) -> list[AuthGroup]:
+    existing_groups = set(AuthGroup.objects.all().values_list('name', flat=True))
+    seen_names = set()
+
+    new_groups = []
+
+    for name in names:
+        if name in existing_groups or name in seen_names:
+            continue
+
+        sanitized_name = name.replace('\x00', '')
+
+        if sanitized_name in existing_groups or sanitized_name in seen_names:
+            continue
+
+        seen_names.add(sanitized_name)
+        new_groups.append(AuthGroup(name=sanitized_name))
 
     return AuthGroup.objects.bulk_create(new_groups)

django_spire/auth/group/forms.py

@@ -12,6 +12,12 @@ class GroupNamesField(forms.CharField):
     """Receives a list of group names as a json string"""
 
     def clean(self, value) -> list[str]:
+        value = super().clean(value)
+
+        if value in (None, ''):
+            message = 'This field is required.'
+            raise forms.ValidationError(message)
+
         return json.loads(value)
 
 
@@ -31,6 +37,7 @@ class GroupForm(forms.ModelForm):
             raise forms.ValidationError(message)
 
         return name
+
     class Meta:
         model = Group
         exclude = ['permissions']

django_spire/auth/group/tests/test_factories.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+from django_spire.auth.group.factories import bulk_create_groups_from_names
+from django_spire.auth.group.models import AuthGroup
+from django_spire.core.tests.test_cases import BaseTestCase
+
+
+class BulkCreateGroupsFromNamesTestCase(BaseTestCase):
+    def test_creates_new_groups(self) -> None:
+        names = ['Group A', 'Group B', 'Group C']
+        groups = bulk_create_groups_from_names(names)
+        assert len(groups) == 3
+        assert AuthGroup.objects.filter(name__in=names).count() == 3
+
+    def test_skips_existing_groups(self) -> None:
+        AuthGroup.objects.create(name='Existing Group')
+        names = ['Existing Group', 'New Group']
+        groups = bulk_create_groups_from_names(names)
+        assert len(groups) == 1
+        assert groups[0].name == 'New Group'
+
+    def test_empty_list(self) -> None:
+        groups = bulk_create_groups_from_names([])
+        assert len(groups) == 0
+
+    def test_all_existing_groups(self) -> None:
+        AuthGroup.objects.create(name='Group A')
+        AuthGroup.objects.create(name='Group B')
+        groups = bulk_create_groups_from_names(['Group A', 'Group B'])
+        assert len(groups) == 0
+
+    def test_single_group(self) -> None:
+        groups = bulk_create_groups_from_names(['Single Group'])
+        assert len(groups) == 1
+        assert groups[0].name == 'Single Group'
+
+    def test_unique_names_only(self) -> None:
+        groups = bulk_create_groups_from_names(['Group A', 'Group B'])
+        assert len(groups) == 2
+
+    def test_groups_are_persisted(self) -> None:
+        bulk_create_groups_from_names(['Persisted Group'])
+        assert AuthGroup.objects.filter(name='Persisted Group').exists()
+
+    def test_mixed_existing_and_new(self) -> None:
+        AuthGroup.objects.create(name='Existing 1')
+        AuthGroup.objects.create(name='Existing 2')
+        names = ['Existing 1', 'New 1', 'Existing 2', 'New 2']
+        groups = bulk_create_groups_from_names(names)
+        assert len(groups) == 2
+        group_names = [g.name for g in groups]
+        assert 'New 1' in group_names
+        assert 'New 2' in group_names
+
+    def test_special_characters_in_names(self) -> None:
+        names = ['Group & Co', 'Test <Group>', 'Group "Name"']
+        groups = bulk_create_groups_from_names(names)
+        assert len(groups) == 3
+
+    def test_unicode_names(self) -> None:
+        names = ['Tëst Grøup', '日本語グループ', 'Группа']
+        groups = bulk_create_groups_from_names(names)
+        assert len(groups) == 3
+
+    def test_whitespace_names(self) -> None:
+        names = ['  Spaces  ', 'Tab\tGroup']
+        groups = bulk_create_groups_from_names(names)
+        assert len(groups) == 2
+
+    def test_many_groups(self) -> None:
+        names = [f'Group {i}' for i in range(50)]
+        groups = bulk_create_groups_from_names(names)
+        assert len(groups) == 50
+
+    def test_returns_group_instances(self) -> None:
+        groups = bulk_create_groups_from_names(['Test Group'])
+        assert isinstance(groups[0], AuthGroup)
+
+    def test_groups_have_primary_keys(self) -> None:
+        groups = bulk_create_groups_from_names(['PK Test Group'])
+        for group in groups:
+            assert group.pk is not None
+
+    def test_duplicate_names_in_input_list(self) -> None:
+        names = ['Duplicate', 'Duplicate', 'Duplicate']
+        groups = bulk_create_groups_from_names(names)
+        assert AuthGroup.objects.filter(name='Duplicate').count() >= 1
+
+    def test_empty_string_name(self) -> None:
+        names = ['', 'Valid Group']
+        groups = bulk_create_groups_from_names(names)
+        assert len(groups) >= 1
+
+    def test_very_long_name(self) -> None:
+        long_name = 'A' * 150
+        groups = bulk_create_groups_from_names([long_name])
+        assert len(groups) == 1
+        assert groups[0].name == long_name
+
+    def test_name_with_only_whitespace(self) -> None:
+        names = ['   ', '\t\t', '\n\n']
+        groups = bulk_create_groups_from_names(names)
+        assert len(groups) == 3
+
+    def test_name_with_leading_trailing_whitespace(self) -> None:
+        names = ['  Leading', 'Trailing  ', '  Both  ']
+        groups = bulk_create_groups_from_names(names)
+        assert len(groups) == 3
+
+    def test_case_sensitive_names(self) -> None:
+        names = ['group', 'Group', 'GROUP']
+        groups = bulk_create_groups_from_names(names)
+        assert len(groups) == 3
+
+    def test_numeric_names(self) -> None:
+        names = ['123', '456', '789']
+        groups = bulk_create_groups_from_names(names)
+        assert len(groups) == 3
+
+    def test_mixed_alphanumeric_names(self) -> None:
+        names = ['Group1', '2Group', 'Gr0up3']
+        groups = bulk_create_groups_from_names(names)
+        assert len(groups) == 3
+
+    def test_names_with_newlines(self) -> None:
+        names = ['Group\nWith\nNewlines']
+        groups = bulk_create_groups_from_names(names)
+        assert len(groups) == 1
+
+    def test_names_with_null_characters(self) -> None:
+        names = ['Group\x00Name']
+        groups = bulk_create_groups_from_names(names)
+        assert len(groups) == 1
+
+    def test_preserves_order_of_creation(self) -> None:
+        names = ['First', 'Second', 'Third']
+        groups = bulk_create_groups_from_names(names)
+        group_names = [g.name for g in groups]
+        assert group_names == names
+
+    def test_does_not_modify_existing_groups(self) -> None:
+        existing = AuthGroup.objects.create(name='Existing')
+        original_pk = existing.pk
+        bulk_create_groups_from_names(['Existing', 'New'])
+        existing.refresh_from_db()
+        assert existing.pk == original_pk