django-spire 0.19.4__py3-none-any.whl → 0.20.0__py3-none-any.whl

django_spire/knowledge/collection/services/tag_service.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from dandy import Prompt
+
+from django_spire.contrib.service import BaseDjangoModelService
+from django_spire.core.tags.intelligence.tag_set_bot import TagSetBot
+
+if TYPE_CHECKING:
+    from django_spire.knowledge.collection.models import Collection
+
+
+class CollectionTagService(BaseDjangoModelService['Collection']):
+    obj: Collection
+
+    def process_and_set_tags(self):
+        collection_prompt = Prompt()
+
+        collection_prompt.sub_heading(self.obj.name)
+        collection_prompt.text(self.obj.description)
+
+        tag_set = TagSetBot().process(
+            content=collection_prompt
+        )
+
+        self.obj.set_tags_from_tag_set(
+            tag_set=tag_set,
+        )
+
+    def get_aggregated_tag_set(self):
+        tag_set = self.obj.tag_set
+
+        for collection in self.obj.children.active():
+            tag_set.update(collection.services.tag.get_aggregated_tag_set())
+
+        for entry in self.obj.entries.active():
+            tag_set.update(entry.tag_set)
+
+        return tag_set
+
+    def get_aggregated_tag_set_simplified(self):
+        tag_set = self.obj.tag_set_simplified
+
+        for collection in self.obj.children.active():
+            tag_set.update(collection.services.tag.get_aggregated_tag_set())
+
+        for entry in self.obj.entries.active():
+            tag_set.update(entry.tag_set_simplified)
+
+        return tag_set
+

django_spire/knowledge/collection/views/form_views.py

@@ -61,6 +61,8 @@ def form_view(
                 collection=collection,
             )
 
+            collection.services.tag.process_and_set_tags()
+
             if collection.parent_id:
                 return_url = reverse(
                     'django_spire:knowledge:collection:page:top_level',

django_spire/knowledge/entry/admin.py

@@ -1,4 +1,5 @@
-from django.contrib import admin
+from django.contrib import admin, messages
+from django.db.models import QuerySet
 from django.urls import reverse
 from django.utils.html import format_html
 from django.utils.http import urlencode
@@ -8,12 +9,13 @@ from django_spire.knowledge.entry.models import Entry
 
 @admin.register(Entry)
 class EntryAdmin(admin.ModelAdmin):
-    list_display = ['name', 'current_version_link', 'collection', 'is_deleted']
+    list_display = ['name', 'current_version_link', 'collection', 'is_deleted', 'tag_count']
     list_select_related = ['collection', 'current_version']
     list_filter = ['is_deleted', 'is_active']
     search_fields = ['name', 'collection__name']
     ordering = ['name']
     autocomplete_fields = ['collection', 'current_version']
+    actions = ['set_tags_for_entries']
 
     def current_version_link(self, entry: Entry) -> str:
         url = (
@@ -26,3 +28,17 @@ class EntryAdmin(admin.ModelAdmin):
 
     current_version_link.short_description = 'Current Version'
     current_version_link.allow_tags = True
+
+    @admin.action(description="Set Tags for Entries (Allow 5 Seconds Per)")
+    def set_tags_for_entries(self, request, queryset: QuerySet[Entry]):
+        processed = 0
+        for entry in queryset:
+            entry.services.tag.process_and_set_tags()
+            processed += 1
+
+        messages.success(request, f'Successfully processed {processed} entries.')
+
+    def tag_count(self, entry: Entry):
+        return entry.tags.count()
+
+    tag_count.short_description = 'Tags'

django_spire/knowledge/entry/models.py

@@ -3,6 +3,7 @@ from django.urls import reverse
 
 from django_spire.contrib import Breadcrumbs
 from django_spire.contrib.ordering.mixins import OrderingModelMixin
+from django_spire.core.tags.mixins import TagsModelMixin
 from django_spire.contrib.utils import truncate_string
 from django_spire.history.mixins import HistoryModelMixin
 from django_spire.knowledge.collection.models import Collection
@@ -11,7 +12,11 @@ from django_spire.knowledge.entry.services.service import EntryService
 from django_spire.knowledge.entry.version.models import EntryVersion
 
 
-class Entry(HistoryModelMixin, OrderingModelMixin):
+class Entry(
+    HistoryModelMixin,
+    OrderingModelMixin,
+    TagsModelMixin
+):
     collection = models.ForeignKey(
         Collection,
         on_delete=models.CASCADE,

django_spire/knowledge/entry/services/service.py

@@ -10,6 +10,7 @@ from django_spire.knowledge.entry.services.automation_service import \
 from django_spire.knowledge.entry.services.factory_service import EntryFactoryService
 from django_spire.knowledge.entry.services.processor_service import \
     EntryProcessorService
+from django_spire.knowledge.entry.services.tag_service import EntryTagService
 from django_spire.knowledge.entry.services.tool_service import EntryToolService
 from django_spire.knowledge.entry.services.transformation_services import \
     EntryTransformationService
@@ -26,6 +27,7 @@ class EntryService(BaseDjangoModelService['Entry']):
     factory = EntryFactoryService()
     ordering = OrderingService()
     processor = EntryProcessorService()
+    tag = EntryTagService()
     tool = EntryToolService()
     transformation = EntryTransformationService()
 

django_spire/knowledge/entry/services/tag_service.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from dandy import Prompt
+
+from django_spire.contrib.service import BaseDjangoModelService
+from django_spire.core.tags.intelligence.tag_set_bot import TagSetBot
+
+if TYPE_CHECKING:
+    from django_spire.knowledge.entry.models import Entry
+
+
+
+class EntryTagService(BaseDjangoModelService['Entry']):
+    obj: Entry
+
+    def process_and_set_tags(self):
+        entry_prompt = Prompt()
+
+        entry_prompt.text(self.obj.name)
+
+        for version_block in self.obj.current_version.blocks.all():
+            entry_prompt.text(f'{version_block.render_to_text()}')
+
+        tag_set = TagSetBot().process(
+            content=entry_prompt
+        )
+
+        self.obj.set_tags_from_tag_set(
+            tag_set=tag_set,
+        )
+
+

django_spire/knowledge/entry/version/urls/json_urls.py

@@ -9,8 +9,12 @@ app_name = 'json'
 urlpatterns = [
     path(
         '<int:pk>/update_blocks/',
-
         json_views.update_blocks_view,
         name='update_blocks',
     ),
+    path(
+        '<int:pk>/update_entry_from_version/',
+        json_views.update_entry_from_version_view,
+        name='update_entry_from_version',
+    ),
 ]

django_spire/knowledge/entry/version/views/json_views.py

@@ -21,3 +21,12 @@ def update_blocks_view(request: WSGIRequest, pk: int) -> JsonResponse:
     entry_version.services.processor.add_update_delete_blocks(block_data_list)
 
     return JsonResponse({'type': 'success'})
+
+@valid_ajax_request_required
+@AppAuthController('knowledge').permission_required('can_change')
+def update_entry_from_version_view(request: WSGIRequest, pk: int) -> JsonResponse:
+    entry_version = get_object_or_404(EntryVersion, pk=pk)
+
+    entry_version.entry.services.tag.process_and_set_tags()
+
+    return JsonResponse({'type': 'success'})

django_spire/knowledge/intelligence/decoders/collection_decoder.py

@@ -7,13 +7,13 @@ from django_spire.knowledge.collection.models import Collection
 
 def get_collection_decoder() -> Decoder:
     class CollectionDecoder(Decoder):
-        mapping_keys_description = 'Knowledge Collection Titles'
+        mapping_keys_description = 'Knowledge Collections Tags'
         mapping = {
             **{
-                f'{collection.name}: {collection.description}': collection
+                f'{collection.services.tag.get_aggregated_tag_set_simplified()}': collection
                 for collection in Collection.objects.all().annotate_entry_count()
             },
-            'No Matching Knowledge Collection Titles': None,
+            'No Matching Knowledge Collection Tags': None,
         }
 
-    return CollectionDecoder()
+    return CollectionDecoder()

django_spire/knowledge/intelligence/decoders/entry_decoder.py

@@ -7,10 +7,10 @@ from django_spire.knowledge.collection.models import Collection
 
 def get_entry_decoder(collection: Collection) -> Decoder:
     class EntryDecoder(Decoder):
-        mapping_keys_description = 'Knowledge Entries'
+        mapping_keys_description = 'Knowledge Entries Tags'
         mapping = {
             **{
-                entry.name: entry
+                f'{entry.tag_set}': entry
                 for entry in collection.entries.all()
               },
             'No Matching Knowledge Entries': None

django_spire/knowledge/intelligence/workflows/knowledge_workflow.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 from django.core.handlers.wsgi import WSGIRequest
+
+from django_spire.ai.chat.message_intel import DefaultMessageIntel, BaseMessageIntel
 from django_spire.knowledge.intelligence.bots.entry_search_llm_bot import EntrySearchBot
 from django_spire.knowledge.intelligence.intel.entry_intel import EntriesIntel
 from django_spire.knowledge.intelligence.intel.message_intel import KnowledgeMessageIntel
@@ -13,17 +15,21 @@ 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,
-) -> KnowledgeMessageIntel | None:
+) -> BaseMessageIntel | None:
     collection_decoder = get_collection_decoder()
     collections = collection_decoder.process(user_input).values
 
     if collections[0] is None:
-        return None
+        return NO_KNOWLEDGE_MESSAGE_INTEL
 
     entries = []
 
@@ -36,7 +42,7 @@ def knowledge_search_workflow(
     entries = [entry for entry in entries if entry is not None]
 
     if not entries:
-        return None
+        return NO_KNOWLEDGE_MESSAGE_INTEL
 
     entries_intel = EntriesIntel(entry_intel_list=[])
 

django_spire/knowledge/migrations/0008_collection_tags_entry_tags.py

@@ -0,0 +1,24 @@
+# Generated by Django 5.2.7 on 2025-11-12 16:48
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('django_spire_core', '0001_initial'),
+        ('django_spire_knowledge', '0007_alter_collection_options'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='collection',
+            name='tags',
+            field=models.ManyToManyField(blank=True, editable=False, null=True, related_name='+', to='django_spire_core.tag'),
+        ),
+        migrations.AddField(
+            model_name='entry',
+            name='tags',
+            field=models.ManyToManyField(blank=True, editable=False, null=True, related_name='+', to='django_spire_core.tag'),
+        ),
+    ]

django_spire/knowledge/templates/django_spire/knowledge/collection/page/display_page.html

@@ -46,4 +46,20 @@
             Last Edits ETC
         </div>
     </div>
+    <div class="row">
+        <div class="col-12 col-lg-8 mx-auto pb-4">
+            Tags:
+            {% for tag in collection.tags.all %}
+                <span class="badge bg-secondary">{{ tag.name }}</span>
+            {% endfor %}
+        </div>
+    </div>
+    <div class="row">
+        <div class="col-12 col-lg-8 mx-auto pb-4">
+            Aggregated Tags:
+            {% for tag in collection.services.tag.get_aggregated_tag_set %}
+                <span class="badge bg-secondary">{{ tag }}</span>
+            {% endfor %}
+        </div>
+    </div>
 {% endblock %}

django_spire/knowledge/templates/django_spire/knowledge/entry/version/container/{detail_container.html → editor_container.html}

@@ -21,6 +21,12 @@
                     KNOWLEDGE_ENTRY_VERSION_EDITOR?.readOnly?.toggle()
                     this.editor_is_readonly = KNOWLEDGE_ENTRY_VERSION_EDITOR?.readOnly?.isEnabled
 
+                    if (this.editor_is_readonly) {
+                        django_glue_fetch(
+                            '{% url "django_spire:knowledge:entry:version:json:update_entry_from_version" pk=entry.id %}',
+                        )
+                    }
+
                     let view_mode = this.editor_is_readonly ? 'readonly' : 'edit'
 
                     let url = new URL(window.location)

django_spire/knowledge/templates/django_spire/knowledge/entry/version/page/editor_page.html

@@ -16,32 +16,47 @@
 {% endblock %}
 
 {% block full_page_info_navigation %}
-    <div>
-        <div class="mb-3">
+    <div class="row">
+        <div class="col-12 mb-3">
             {% include 'django_spire/element/attribute_element.html' with attribute_title='Author' attribute_value=entry.current_version.author.get_full_name %}
         </div>
+    </div>
 
-        <div class="mb-3">
+    <div class="row">
+        <div class="col-12 mb-3">
             {% include 'django_spire/element/attribute_element.html' with attribute_title='Status' %}
             {% include 'django_spire/knowledge/entry/badge/entry_status_badge.html' with status=entry.current_version.status %}
         </div>
+    </div>
 
-        {% if entry.current_version.published_datetime %}
-            <div class="mb-3">
+    {% if entry.current_version.published_datetime %}
+        <div class="row">
+            <div class="col-12 mb-3">
                 {% include 'django_spire/element/attribute_element.html' with attribute_title='Published' attribute_value=entry.current_version.published_datetime %}
             </div>
-        {% endif %}
+        </div>
+    {% endif %}
 
-        <div class="mb-3">
+    <div class="row">
+        <div class="col-12 mb-3">
             {% include 'django_spire/element/attribute_element.html' with attribute_title='Last Edit' attribute_value=entry.current_version.last_edit_datetime %}
         </div>
     </div>
+
+    <div class="row">
+        <div class="col-12 mb-3">
+            {% include 'django_spire/element/attribute_element.html' with attribute_title='Tags' %}
+            {% for tag in entry.tags.all %}
+            	<span class="badge bg-secondary">{{ tag.name }}</span>
+            {% endfor %}
+        </div>
+    </div>
 {% endblock %}
 
 {% block knowledge_full_page_content %}
     <div class="row justify-content-center ps-3">
         <div class="col-12">
-            {% include 'django_spire/knowledge/entry/version/container/detail_container.html' %}
+            {% include 'django_spire/knowledge/entry/version/container/editor_container.html' %}
         </div>
     </div>
 {% endblock %}
@@ -49,6 +64,8 @@
 {% block base_body_additional_bottom_js %}
     {{ block.super }}
 
-    <script src="{% static 'django_spire/knowledge/entry/version/js/null_paragraph.js' %}?v={{ DJANGO_SPIRE_VERSION }}" type="application/javascript"></script>
-    <script src="{% static 'django_spire/knowledge/entry/version/js/editor.js' %}?v={{ DJANGO_SPIRE_VERSION }}" type="application/javascript"></script>
+    <script src="{% static 'django_spire/knowledge/entry/version/js/null_paragraph.js' %}?v={{ DJANGO_SPIRE_VERSION }}"
+            type="application/javascript"></script>
+    <script src="{% static 'django_spire/knowledge/entry/version/js/editor.js' %}?v={{ DJANGO_SPIRE_VERSION }}"
+            type="application/javascript"></script>
 {% endblock %}

django_spire/theme/enums.py

@@ -7,15 +7,12 @@ class ThemeFamily(StrEnum):
     AYU = 'ayu'
     CATPPUCCIN = 'catppuccin'
     DEFAULT = 'default'
-    DRACULA = 'dracula'
     GRUVBOX = 'gruvbox'
     MATERIAL = 'material'
     NORD = 'nord'
-    OCEANIC_NEXT = 'oceanic-next'
     ONE_DARK = 'one-dark'
     PALENIGHT = 'palenight'
     ROSE_PINE = 'rose-pine'
-    SYNTHWAVE = 'synthwave'
     TOKYO_NIGHT = 'tokyo-night'
 
 

django_spire/theme/models.py

@@ -19,15 +19,12 @@ class Theme:
         ThemeFamily.AYU: 'Ayu',
         ThemeFamily.CATPPUCCIN: 'Catppuccin',
         ThemeFamily.DEFAULT: 'Default',
-        ThemeFamily.DRACULA: 'Dracula',
         ThemeFamily.GRUVBOX: 'Gruvbox',
         ThemeFamily.MATERIAL: 'Material',
         ThemeFamily.NORD: 'Nord',
-        ThemeFamily.OCEANIC_NEXT: 'Oceanic Next',
         ThemeFamily.ONE_DARK: 'One Dark Pro',
         ThemeFamily.PALENIGHT: 'Palenight',
         ThemeFamily.ROSE_PINE: 'Rose Pine',
-        ThemeFamily.SYNTHWAVE: 'Synthwave',
         ThemeFamily.TOKYO_NIGHT: 'Tokyo Night',
     }
 

django_spire/theme/tests/test_context_processor.py

@@ -18,14 +18,14 @@ class ThemeContextProcessorTests(TestCase):
         request = self.factory.get('/')
         request.COOKIES = {}
 
-        with patch('django_spire.conf.settings.DJANGO_SPIRE_DEFAULT_THEME', 'dracula-dark'):
+        with patch('django_spire.conf.settings.DJANGO_SPIRE_DEFAULT_THEME', 'gruvbox-dark'):
             context = theme_context(request)
 
-        self.assertEqual(context['DJANGO_SPIRE_DEFAULT_THEME'], 'dracula-dark')
+        self.assertEqual(context['DJANGO_SPIRE_DEFAULT_THEME'], 'gruvbox-dark')
         self.assertIn('theme', context)
 
         data = context['theme']
-        self.assertEqual(data['family'], 'dracula')
+        self.assertEqual(data['family'], 'gruvbox')
         self.assertEqual(data['mode'], 'dark')
 
     def test_theme_context_with_cookie(self) -> None:
@@ -45,11 +45,11 @@ class ThemeContextProcessorTests(TestCase):
         cookie_name = get_theme_cookie_name()
         request.COOKIES = {cookie_name: 'invalid-theme'}
 
-        with patch('django_spire.conf.settings.DJANGO_SPIRE_DEFAULT_THEME', 'dracula-dark'):
+        with patch('django_spire.conf.settings.DJANGO_SPIRE_DEFAULT_THEME', 'gruvbox-dark'):
             context = theme_context(request)
 
         data = context['theme']
-        self.assertEqual(data['family'], 'dracula')
+        self.assertEqual(data['family'], 'gruvbox')
         self.assertEqual(data['mode'], 'dark')
 
     def test_theme_context_path_setting(self) -> None:
@@ -70,7 +70,7 @@ class ThemeContextProcessorIntegrationTests(BaseTestCase):
 
     def test_theme_context_with_authenticated_client(self) -> None:
         cookie_name = get_theme_cookie_name()
-        self.client.cookies[cookie_name] = 'dracula-dark'
+        self.client.cookies[cookie_name] = 'gruvbox-dark'
         response = self.client.get('/')
         self.assertEqual(response.status_code, 200)
 

django_spire/theme/tests/test_enums.py

@@ -11,15 +11,12 @@ class ThemeEnumTests(TestCase):
             'ayu',
             'catppuccin',
             'default',
-            'dracula',
             'gruvbox',
             'material',
             'nord',
-            'oceanic-next',
             'one-dark',
             'palenight',
             'rose-pine',
-            'synthwave',
             'tokyo-night'
         }
 

django_spire/theme/tests/test_integration.py

@@ -40,9 +40,9 @@ class ThemeIntegrationTests(BaseTestCase):
             self.assertEqual(response.status_code, 200)
 
     def test_theme_media_integration(self) -> None:
-        theme = Theme(family=ThemeFamily.DRACULA, mode='dark')
+        theme = Theme(family=ThemeFamily.GRUVBOX, mode='dark')
         stylesheet = theme.stylesheet
 
         self.assertIn('django_spire/css/themes/', stylesheet)
-        self.assertIn('dracula', stylesheet)
+        self.assertIn('gruvbox', stylesheet)
         self.assertIn('app-dark.css', stylesheet)

django_spire/theme/tests/test_model.py

@@ -27,13 +27,13 @@ class ThemeModelTests(TestCase):
             self.assertIn(family, Theme.FAMILY_DISPLAY_NAMES)
 
     def test_theme_initialization_with_enums(self) -> None:
-        theme = Theme(family=ThemeFamily.DRACULA, mode=ThemeMode.DARK)
-        self.assertEqual(theme.family, ThemeFamily.DRACULA)
+        theme = Theme(family=ThemeFamily.GRUVBOX, mode=ThemeMode.DARK)
+        self.assertEqual(theme.family, ThemeFamily.GRUVBOX)
         self.assertEqual(theme.mode, ThemeMode.DARK)
 
     def test_theme_initialization_with_strings(self) -> None:
-        theme = Theme(family='dracula', mode='dark')
-        self.assertEqual(theme.family, ThemeFamily.DRACULA)
+        theme = Theme(family='gruvbox', mode='dark')
+        self.assertEqual(theme.family, ThemeFamily.GRUVBOX)
         self.assertEqual(theme.mode, ThemeMode.DARK)
 
     def test_theme_initialization_invalid_family(self) -> None:
@@ -43,16 +43,15 @@ class ThemeModelTests(TestCase):
 
     def test_theme_initialization_invalid_mode(self) -> None:
         with pytest.raises(ValueError) as ctx:
-            Theme(family='dracula', mode='invalid-mode')
+            Theme(family='gruvbox', mode='invalid-mode')
         self.assertIn('Invalid theme mode', str(ctx.value))
 
     def test_from_string_valid(self) -> None:
         cases = [
             ('default-light', ThemeFamily.DEFAULT, ThemeMode.LIGHT),
-            ('dracula-dark', ThemeFamily.DRACULA, ThemeMode.DARK),
+            ('gruvbox-dark', ThemeFamily.GRUVBOX, ThemeMode.DARK),
             ('one-dark-light', ThemeFamily.ONE_DARK, ThemeMode.LIGHT),
             ('tokyo-night-dark', ThemeFamily.TOKYO_NIGHT, ThemeMode.DARK),
-            ('oceanic-next-light', ThemeFamily.OCEANIC_NEXT, ThemeMode.LIGHT),
         ]
 
         for string, family, mode in cases:
@@ -62,7 +61,7 @@ class ThemeModelTests(TestCase):
                 self.assertEqual(theme.mode, mode)
 
     def test_from_string_empty_with_default(self) -> None:
-        default = Theme(family=ThemeFamily.DRACULA, mode=ThemeMode.DARK)
+        default = Theme(family=ThemeFamily.GRUVBOX, mode=ThemeMode.DARK)
         theme = Theme.from_string('', default=default)
         self.assertEqual(theme, default)
 
@@ -72,7 +71,7 @@ class ThemeModelTests(TestCase):
         self.assertEqual(theme.mode, Theme.DEFAULT_MODE)
 
     def test_from_string_invalid_with_default(self) -> None:
-        default = Theme(family=ThemeFamily.DRACULA, mode=ThemeMode.DARK)
+        default = Theme(family=ThemeFamily.GRUVBOX, mode=ThemeMode.DARK)
         theme = Theme.from_string('invalid', default=default)
         self.assertEqual(theme, default)
 
@@ -97,27 +96,27 @@ class ThemeModelTests(TestCase):
         self.assertEqual(default.mode, Theme.DEFAULT_MODE)
 
     def test_display_property(self) -> None:
-        theme = Theme(family=ThemeFamily.DRACULA, mode=ThemeMode.DARK)
-        self.assertEqual(theme.display, 'Dracula - Dark')
+        theme = Theme(family=ThemeFamily.GRUVBOX, mode=ThemeMode.DARK)
+        self.assertEqual(theme.display, 'Gruvbox - Dark')
 
         theme = Theme(family=ThemeFamily.ONE_DARK, mode=ThemeMode.LIGHT)
         self.assertEqual(theme.display, 'One Dark Pro - Light')
 
     def test_family_display_property(self) -> None:
-        theme = Theme(family=ThemeFamily.OCEANIC_NEXT, mode=ThemeMode.DARK)
-        self.assertEqual(theme.family_display, 'Oceanic Next')
+        theme = Theme(family=ThemeFamily.ONE_DARK, mode=ThemeMode.DARK)
+        self.assertEqual(theme.family_display, 'One Dark Pro')
 
     def test_is_dark_property(self) -> None:
-        dark = Theme(family=ThemeFamily.DRACULA, mode=ThemeMode.DARK)
+        dark = Theme(family=ThemeFamily.GRUVBOX, mode=ThemeMode.DARK)
         self.assertTrue(dark.is_dark)
 
-        light = Theme(family=ThemeFamily.DRACULA, mode=ThemeMode.LIGHT)
+        light = Theme(family=ThemeFamily.GRUVBOX, mode=ThemeMode.LIGHT)
         self.assertFalse(light.is_dark)
 
     def test_stylesheet_property(self) -> None:
         cases = [
             (ThemeFamily.DEFAULT, ThemeMode.LIGHT, 'django_spire/css/themes/default/app-light.css'),
-            (ThemeFamily.DRACULA, ThemeMode.DARK, 'django_spire/css/themes/dracula/app-dark.css'),
+            (ThemeFamily.GRUVBOX, ThemeMode.DARK, 'django_spire/css/themes/gruvbox/app-dark.css'),
             (ThemeFamily.ONE_DARK, ThemeMode.LIGHT, 'django_spire/css/themes/one-dark/app-light.css'),
             (ThemeFamily.TOKYO_NIGHT, ThemeMode.DARK, 'django_spire/css/themes/tokyo-night/app-dark.css'),
         ]
@@ -130,7 +129,7 @@ class ThemeModelTests(TestCase):
     def test_value_property(self) -> None:
         cases = [
             (ThemeFamily.DEFAULT, ThemeMode.LIGHT, 'default-light'),
-            (ThemeFamily.DRACULA, ThemeMode.DARK, 'dracula-dark'),
+            (ThemeFamily.GRUVBOX, ThemeMode.DARK, 'gruvbox-dark'),
             (ThemeFamily.ONE_DARK, ThemeMode.LIGHT, 'one-dark-light'),
             (ThemeFamily.TOKYO_NIGHT, ThemeMode.DARK, 'tokyo-night-dark'),
         ]
@@ -141,7 +140,7 @@ class ThemeModelTests(TestCase):
                 self.assertEqual(theme.value, value)
 
     def test_to_dict(self) -> None:
-        theme = Theme(family=ThemeFamily.DRACULA, mode=ThemeMode.DARK)
+        theme = Theme(family=ThemeFamily.GRUVBOX, mode=ThemeMode.DARK)
         result = theme.to_dict()
 
         keys = {
@@ -156,16 +155,16 @@ class ThemeModelTests(TestCase):
 
         self.assertEqual(set(result.keys()), keys)
 
-        self.assertEqual(result['display'], 'Dracula - Dark')
-        self.assertEqual(result['family'], 'dracula')
-        self.assertEqual(result['family_display'], 'Dracula')
-        self.assertEqual(result['full'], 'dracula-dark')
+        self.assertEqual(result['display'], 'Gruvbox - Dark')
+        self.assertEqual(result['family'], 'gruvbox')
+        self.assertEqual(result['family_display'], 'Gruvbox')
+        self.assertEqual(result['full'], 'gruvbox-dark')
         self.assertTrue(result['is_dark'])
         self.assertEqual(result['mode'], 'dark')
-        self.assertEqual(result['stylesheet'], 'django_spire/css/themes/dracula/app-dark.css')
+        self.assertEqual(result['stylesheet'], 'django_spire/css/themes/gruvbox/app-dark.css')
 
     def test_theme_immutability(self) -> None:
-        theme = Theme(family=ThemeFamily.DRACULA, mode=ThemeMode.DARK)
+        theme = Theme(family=ThemeFamily.GRUVBOX, mode=ThemeMode.DARK)
 
         with pytest.raises(AttributeError):
             theme.family = ThemeFamily.DEFAULT