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

django_spire/knowledge/entry/views/page_views.py

@@ -1,12 +1,18 @@
-from django.core.handlers.wsgi import WSGIRequest
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
 from django.shortcuts import get_object_or_404
-from django.template.response import TemplateResponse
 from django.urls import reverse
 
 from django_spire.auth.controller.controller import AppAuthController
 from django_spire.contrib.generic_views import portal_views
 from django_spire.knowledge.entry.models import Entry
 
+if TYPE_CHECKING:
+    from django.core.handlers.wsgi import WSGIRequest
+    from django.template.response import TemplateResponse
+
 
 @AppAuthController('knowledge').permission_required('can_delete')
 def delete_view(request: WSGIRequest, pk: int) -> TemplateResponse:

django_spire/knowledge/entry/views/template_views.py

@@ -1,4 +1,7 @@
-from django.core.handlers.wsgi import WSGIRequest
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
 from django.template.response import TemplateResponse
 from django.urls import reverse
 
@@ -7,6 +10,9 @@ from django_spire.contrib import Breadcrumbs
 from django_spire.knowledge.collection.models import Collection
 from django_spire.knowledge.entry.models import Entry
 
+if TYPE_CHECKING:
+    from django.core.handlers.wsgi import WSGIRequest
+
 
 @AppAuthController('knowledge').permission_required('can_view')
 def file_list_view(request: WSGIRequest, collection_pk: int = 0) -> TemplateResponse:

django_spire/knowledge/exceptions.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
 
-class KnowledgeBaseConversionException(Exception):
+
+class KnowledgeBaseConversionError(Exception):
     pass

django_spire/knowledge/intelligence/intel/answer_intel.py

@@ -1,5 +1,6 @@
-from dandy import BaseIntel
+from __future__ import annotations
 
+from dandy import BaseIntel
 
 
 class AnswerIntel(BaseIntel):

django_spire/knowledge/intelligence/intel/entry_intel.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-
 from dandy import BaseIntel, BaseListIntel
 
 from django_spire.knowledge.entry.models import Entry

django_spire/knowledge/intelligence/workflows/knowledge_workflow.py

@@ -15,15 +15,16 @@ if TYPE_CHECKING:
     from django.core.handlers.wsgi import WSGIRequest
     from dandy.llm.request.message import MessageHistory
 
+
 NO_KNOWLEDGE_MESSAGE_INTEL = DefaultMessageIntel(
     text='Sorry, I could not find any information on that.'
 )
 
 
 def knowledge_search_workflow(
-        request: WSGIRequest,
-        user_input: str,
-        message_history: MessageHistory | None = None,
+    request: WSGIRequest,
+    user_input: str,
+    message_history: MessageHistory | None = None
 ) -> BaseMessageIntel | None:
     user_tag_set = TagSetBot().process(user_input)
 
@@ -76,8 +77,6 @@ def knowledge_search_workflow(
         entries=entries
     )
 
-    print(entries_intel_future.result)
-
     return KnowledgeMessageIntel(
         answer_intel=answer_intel_future.result,
         entries_intel=entries_intel_future.result,

django_spire/knowledge/models.py

@@ -4,8 +4,7 @@ from __future__ import annotations
 
 from django_spire.knowledge.entry import models as entry_models
 from django_spire.knowledge.entry.version import models as entry_version_models
-from django_spire.knowledge.entry.version.block import models as \
-    entry_version_block_models
+from django_spire.knowledge.entry.version.block import models as entry_version_block_models
 from django_spire.knowledge.collection import models as collection_models
 
 # Must assert to stop unused import removals.

django_spire/knowledge/tests/test_templatetags.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.knowledge.templatetags.spire_knowledge_tags import format_to_html
+
+
+class SpireKnowledgeTagsTests(BaseTestCase):
+    def test_format_to_html_empty_string(self):
+        result = format_to_html('')
+        assert result == ' '
+
+    def test_format_to_html_none(self):
+        result = format_to_html(None)
+        assert result == ' '
+
+    def test_format_to_html_line_breaks(self):
+        result = format_to_html('Line1\nLine2')
+        assert '<br>' in result
+
+    def test_format_to_html_bold(self):
+        result = format_to_html('**bold text**')
+        assert '<span class="fw-bold">bold text</span>' in result
+
+    def test_format_to_html_italic(self):
+        result = format_to_html('*italic text*')
+        assert '<span class="fst-italic">italic text</span>' in result
+
+    def test_format_to_html_strikethrough(self):
+        result = format_to_html('~~strikethrough~~')
+        assert '<span class="text-decoration-line-through">strikethrough</span>' in result
+
+    def test_format_to_html_mixed(self):
+        result = format_to_html('**bold** and *italic* and ~~strike~~')
+        assert '<span class="fw-bold">bold</span>' in result
+        assert '<span class="fst-italic">italic</span>' in result
+        assert '<span class="text-decoration-line-through">strike</span>' in result
+
+    def test_format_to_html_plain_text(self):
+        result = format_to_html('plain text')
+        assert result == 'plain text'

django_spire/knowledge/tests/test_urls/test_page_urls.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from django.urls import reverse
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.knowledge.collection.tests.factories import create_test_collection
+
+
+class KnowledgePageUrlsTests(BaseTestCase):
+    def setUp(self):
+        super().setUp()
+        self.collection = create_test_collection()
+
+    def test_home_view_url_path(self):
+        response = self.client.get(
+            reverse('django_spire:knowledge:page:home')
+        )
+        assert response.status_code == 200
+
+    def test_home_view_contains_collections(self):
+        response = self.client.get(
+            reverse('django_spire:knowledge:page:home')
+        )
+        assert 'collections' in response.context

django_spire/knowledge/urls/__init__.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from django.urls import include, path
 
 

django_spire/knowledge/urls/page_urls.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from django.urls import path
 
 from django_spire.knowledge.views import page_views

django_spire/knowledge/views/page_views.py

@@ -1,16 +1,21 @@
 from __future__ import annotations
 
-from django.core.handlers.wsgi import WSGIRequest
-from django.template.response import TemplateResponse
+from typing import TYPE_CHECKING
 
 from django_spire.auth.controller.controller import AppAuthController
 from django_spire.contrib.generic_views import portal_views
 from django_spire.knowledge.collection.models import Collection
 
+if TYPE_CHECKING:
+    from django.template.response import TemplateResponse
+    from django.core.handlers.wsgi import WSGIRequest
+
+    from django_spire.contrib.breadcrumb import Breadcrumbs
+
 
 @AppAuthController('knowledge').permission_required('can_view')
 def home_view(request: WSGIRequest) -> TemplateResponse:
-    def breadcrumbs_func(breadcrumbs):
+    def breadcrumbs_func(breadcrumbs: Breadcrumbs):
         breadcrumbs.add_breadcrumb(name='Knowledge')
 
     return portal_views.list_view(

django_spire/notification/admin.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from django.contrib import admin
 from django.utils.html import format_html
 
@@ -25,7 +27,7 @@ class NotificationAdmin(admin.ModelAdmin):
 
     def url_link(self, notification: models.Notification) -> str:
         if notification.url:
-            return format_html(f'<a href="{notification.url}" target="_blank">Link</a>')
+            return format_html('<a href="{}" target="_blank">Link</a>', notification.url)
 
         return 'No URL'
 

django_spire/notification/app/admin.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from django.contrib import admin
 
 from django_spire.notification.app.models import AppNotification

django_spire/notification/app/apps.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from django.apps import AppConfig
 
 from django_spire.utils import check_required_apps
@@ -11,4 +13,4 @@ class NotificationAppConfig(AppConfig):
     REQUIRED_APPS = ('django_spire_core', 'django_spire_notification')
 
     def ready(self) -> None:
-        check_required_apps(self.label)
+        check_required_apps(self.label)

django_spire/notification/app/exceptions.py

@@ -1,5 +1,12 @@
-from django_spire.exceptions import DjangoSpireException
+from __future__ import annotations
 
+from django_spire.exceptions import DjangoSpireError
 
-class AppNotificationException(DjangoSpireException):
+
+class AppNotificationError(DjangoSpireError):
     pass
+
+
+class MissingUserError(AppNotificationError):
+    def __init__(self) -> None:
+        super().__init__('AppNotifications must have a user associated with them')

django_spire/notification/app/models.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import json
 
 from django.db import models
@@ -36,12 +38,14 @@ class AppNotification(ViewedModelMixin, HistoryModelMixin):
 
         if days > 0:
             return f"{int(days)} day{'s' if days != 1 else ''} ago"
-        elif hours > 0:
+
+        if hours > 0:
             return f"{int(hours)} hour{'s' if hours != 1 else ''} ago"
-        elif minutes > 0:
+
+        if minutes > 0:
             return f"{int(minutes)} minute{'s' if minutes != 1 else ''} ago"
-        else:
-            return "just now"
+
+        return 'just now'
 
     def as_dict(self) -> dict:
         return {

django_spire/notification/app/processor.py

@@ -1,32 +1,36 @@
+from __future__ import annotations
+
 from django.utils.timezone import now
 
-from django_spire.notification.app.exceptions import AppNotificationException
-from django_spire.notification.choices import NotificationTypeChoices, \
+from django_spire.notification.app.exceptions import MissingUserError
+from django_spire.notification.choices import (
+    NotificationTypeChoices,
     NotificationStatusChoices
-from django_spire.notification.exceptions import NotificationException
+)
+from django_spire.notification.exceptions import InvalidNotificationTypeError
 from django_spire.notification.models import Notification
 from django_spire.notification.processors.processor import BaseNotificationProcessor
 
 
 class AppNotificationProcessor(BaseNotificationProcessor):
-    def process(self, notification: Notification):
-        try:
-            if notification.type != NotificationTypeChoices.APP:
-                raise NotificationException(
-                    f'AppNotificationProcessor only processes '
-                    f'App notifications. Was provided {notification.type}'
-                )
+    def _validate_notification_type(self, notification: Notification):
+        if notification.type != NotificationTypeChoices.APP:
+            raise InvalidNotificationTypeError(NotificationTypeChoices.APP, notification.type)
 
-            if notification.user_id is None:
-                raise AppNotificationException(
-                    'AppNotifications must have a user associated with them'
-                )
+    def _validate_user(self, notification: Notification):
+        if notification.user_id is None:
+            raise MissingUserError
 
+    def process(self, notification: Notification):
+        try:
+            self._validate_notification_type(notification)
+            self._validate_user(notification)
         except Exception as e:
             notification.status = NotificationStatusChoices.ERRORED
             notification.status_message = str(e)
             notification.save()
-            raise e
+
+            raise
 
         notification.status = NotificationStatusChoices.SENT
         notification.sent_datetime = now()
@@ -38,16 +42,8 @@ class AppNotificationProcessor(BaseNotificationProcessor):
 
         for notification in notifications:
             try:
-                if notification.type != NotificationTypeChoices.APP:
-                    raise NotificationException(
-                        f'AppNotificationProcessor only processes '
-                        f'App notifications. Was provided {notification.type}'
-                    )
-
-                if notification.user_id is None:
-                    raise AppNotificationException(
-                        'AppNotifications must have a user associated with them'
-                    )
+                self._validate_notification_type(notification)
+                self._validate_user(notification)
 
                 notification.status = NotificationStatusChoices.SENT
                 notification.sent_datetime = now()
@@ -60,7 +56,7 @@ class AppNotificationProcessor(BaseNotificationProcessor):
                     notifications,
                     ['status', 'sent_datetime', 'status_message']
                 )
-                raise e
+                raise
 
         Notification.objects.bulk_update(
             notifications,

django_spire/notification/app/querysets.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
+
 from typing import TYPE_CHECKING
+
 from django.db.models import QuerySet, Value, When, Case, BooleanField, IntegerField
 
 from django_spire.history.querysets import HistoryQuerySet

django_spire/notification/app/tests/factories.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from django.contrib.auth.models import User
+from django.utils.timezone import now
+
+from django_spire.notification.app.models import AppNotification
+from django_spire.notification.choices import (
+    NotificationStatusChoices,
+    NotificationTypeChoices,
+)
+from django_spire.notification.models import Notification
+
+
+def create_test_app_notification(**kwargs) -> AppNotification:
+    if 'notification' not in kwargs:
+        user = kwargs.pop('user', None) or User.objects.first()
+        notification = Notification.objects.create(
+            user=user,
+            type=NotificationTypeChoices.APP,
+            title=kwargs.pop('title', 'Test App Notification'),
+            body=kwargs.pop('body', 'This is a test app notification.'),
+            url=kwargs.pop('url', 'https://example.com'),
+            status=kwargs.pop('status', NotificationStatusChoices.SENT),
+            priority=kwargs.pop('priority', 'low'),
+            sent_datetime=kwargs.pop('sent_datetime', now()),
+        )
+        kwargs['notification'] = notification
+
+    data = {
+        'template': 'django_spire/notification/app/item/notification_item.html',
+        'context_data': {},
+    }
+    data.update(kwargs)
+    return AppNotification.objects.create(**data)

django_spire/notification/app/tests/test_apps.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from django.apps import apps
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.notification.app.apps import NotificationAppConfig
+
+
+class NotificationAppConfigTests(BaseTestCase):
+    def test_app_name(self):
+        assert NotificationAppConfig.name == 'django_spire.notification.app'
+
+    def test_app_label(self):
+        assert NotificationAppConfig.label == 'django_spire_notification_app'
+
+    def test_default_auto_field(self):
+        assert NotificationAppConfig.default_auto_field == 'django.db.models.BigAutoField'
+
+    def test_required_apps(self):
+        expected = ('django_spire_core', 'django_spire_notification')
+        assert expected == NotificationAppConfig.REQUIRED_APPS
+
+    def test_app_is_installed(self):
+        assert apps.is_installed('django_spire.notification.app')

django_spire/notification/app/tests/test_models.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from django.utils.timezone import now, timedelta
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.notification.app.tests.factories import create_test_app_notification
+from django_spire.notification.models import Notification
+
+
+class AppNotificationModelTests(BaseTestCase):
+    def setUp(self):
+        super().setUp()
+        self.app_notification = create_test_app_notification()
+
+    def test_str(self):
+        assert str(self.app_notification) == self.app_notification.notification.title
+
+    def test_verbose_time_since_delivered_just_now(self):
+        self.app_notification.notification.sent_datetime = now()
+        self.app_notification.notification.save()
+
+        assert self.app_notification.verbose_time_since_delivered == 'just now'
+
+    def test_verbose_time_since_delivered_minutes(self):
+        self.app_notification.notification.sent_datetime = now() - timedelta(minutes=5)
+        self.app_notification.notification.save()
+
+        assert '5 minutes ago' in self.app_notification.verbose_time_since_delivered
+
+    def test_verbose_time_since_delivered_hours(self):
+        self.app_notification.notification.sent_datetime = now() - timedelta(hours=3)
+        self.app_notification.notification.save()
+
+        assert '3 hours ago' in self.app_notification.verbose_time_since_delivered
+
+    def test_verbose_time_since_delivered_days(self):
+        self.app_notification.notification.sent_datetime = now() - timedelta(days=2)
+        self.app_notification.notification.save()
+
+        assert '2 days ago' in self.app_notification.verbose_time_since_delivered
+
+    def test_verbose_time_since_delivered_singular_day(self):
+        self.app_notification.notification.sent_datetime = now() - timedelta(days=1)
+        self.app_notification.notification.save()
+
+        assert '1 day ago' in self.app_notification.verbose_time_since_delivered
+
+    def test_as_dict(self):
+        result = self.app_notification.as_dict()
+
+        assert result['id'] == self.app_notification.id
+        assert result['title'] == self.app_notification.notification.title
+        assert result['body'] == self.app_notification.notification.body
+        assert result['url'] == self.app_notification.notification.url
+        assert result['priority'] == self.app_notification.notification.priority
+        assert 'time_since_delivered' in result
+        assert 'context_data' in result
+
+    def test_as_json(self):
+        result = self.app_notification.as_json()
+        assert isinstance(result, str)
+        assert self.app_notification.notification.title in result
+
+    def test_notification_relationship(self):
+        assert self.app_notification.notification is not None
+        assert isinstance(self.app_notification.notification, Notification)
+
+    def test_default_template(self):
+        assert self.app_notification.template == 'django_spire/notification/app/item/notification_item.html'
+
+    def test_default_context_data(self):
+        assert self.app_notification.context_data == {}

django_spire/notification/app/tests/test_processor.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+import pytest
+
+from django_spire.auth.user.tests.factories import create_user
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.notification.app.exceptions import AppNotificationError
+from django_spire.notification.app.models import AppNotification
+from django_spire.notification.app.processor import AppNotificationProcessor
+from django_spire.notification.choices import (
+    NotificationStatusChoices,
+    NotificationTypeChoices,
+)
+from django_spire.notification.exceptions import NotificationError
+from django_spire.notification.models import Notification
+
+
+class AppNotificationProcessorTests(BaseTestCase):
+    def setUp(self):
+        super().setUp()
+        self.user = create_user(username='test_processor_user')
+        self.processor = AppNotificationProcessor()
+
+    def _create_notification(self, **kwargs) -> Notification:
+        data = {
+            'user': self.user,
+            'type': NotificationTypeChoices.APP,
+            'title': 'Test Notification',
+            'body': 'Test body',
+            'status': NotificationStatusChoices.PENDING,
+        }
+        data.update(kwargs)
+        notification = Notification.objects.create(**data)
+        AppNotification.objects.create(notification=notification)
+        return notification
+
+    def test_process_sets_status_to_sent(self):
+        notification = self._create_notification()
+
+        self.processor.process(notification)
+
+        notification.refresh_from_db()
+        assert notification.status == NotificationStatusChoices.SENT
+
+    def test_process_sets_sent_datetime(self):
+        notification = self._create_notification()
+
+        self.processor.process(notification)
+
+        notification.refresh_from_db()
+        assert notification.sent_datetime is not None
+
+    def test_process_raises_error_for_wrong_type(self):
+        notification = self._create_notification(type=NotificationTypeChoices.EMAIL)
+
+        with pytest.raises(NotificationError):
+            self.processor.process(notification)
+
+    def test_process_raises_error_for_missing_user(self):
+        notification = Notification.objects.create(
+            user=None,
+            type=NotificationTypeChoices.APP,
+            title='Test',
+            body='Test',
+            status=NotificationStatusChoices.PENDING,
+        )
+        AppNotification.objects.create(notification=notification)
+
+        with pytest.raises(AppNotificationError):
+            self.processor.process(notification)
+
+    def test_process_list(self):
+        notifications = [self._create_notification() for _ in range(3)]
+
+        self.processor.process_list(notifications)
+
+        for notification in notifications:
+            notification.refresh_from_db()
+            assert notification.status == NotificationStatusChoices.SENT
+            assert notification.sent_datetime is not None
+
+    def test_process_list_raises_error_for_wrong_type(self):
+        notifications = [
+            self._create_notification(),
+            self._create_notification(type=NotificationTypeChoices.EMAIL),
+        ]
+
+        with pytest.raises(NotificationError):
+            self.processor.process_list(notifications)
+
+    def test_process_ready(self):
+        pending_notification = self._create_notification()
+
+        sent_notification = self._create_notification(
+            status=NotificationStatusChoices.SENT
+        )
+
+        self.processor.process_ready()
+
+        pending_notification.refresh_from_db()
+        assert pending_notification.status == NotificationStatusChoices.SENT
+
+    def test_process_errored(self):
+        errored_notification = self._create_notification(
+            status=NotificationStatusChoices.ERRORED
+        )
+
+        self.processor.process_errored()
+
+        errored_notification.refresh_from_db()
+        assert errored_notification.status == NotificationStatusChoices.SENT