django-spire 0.19.5__tar.gz → 0.20.1__tar.gz

{django_spire-0.19.5 → django_spire-0.20.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-spire
-Version: 0.19.5
+Version: 0.20.1
 Summary: A project for Django Spire
 Author-email: Brayden Carlson <braydenc@stratusadv.com>, Nathan Johnson <nathanj@stratusadv.com>
 License: Copyright (c) 2024 Stratus Advanced Technologies and Contributors.
@@ -49,7 +49,7 @@ Requires-Dist: beautifulsoup4>=4.14.2
 Requires-Dist: boto3>=1.34.0
 Requires-Dist: botocore>=1.34.0
 Requires-Dist: crispy-bootstrap5==2024.10
-Requires-Dist: dandy>=1.3.1
+Requires-Dist: dandy>=1.3.3
 Requires-Dist: django>=5.1.8
 Requires-Dist: django-crispy-forms==2.3
 Requires-Dist: django-glue>=0.8.1

{django_spire-0.19.5 → django_spire-0.20.1}/django_spire/ai/chat/intelligence/decoders/tools.py

@@ -5,6 +5,8 @@ from typing import Callable, TYPE_CHECKING
 from dandy import Decoder
 
 from django_spire.auth.controller.controller import AppAuthController
+from django_spire.conf import settings
+from django_spire.core.utils import get_callable_from_module_string_and_validate_arguments
 from django_spire.knowledge.intelligence.workflows.knowledge_workflow import knowledge_search_workflow
 
 if TYPE_CHECKING:
@@ -20,8 +22,11 @@ def generate_intent_decoder(
     if AppAuthController(app_name='knowledge', request=request).can_view():
         intent_dict['The user is looking for information or knowledge on something.'] = knowledge_search_workflow
 
-    if default_callable is not None:
-        intent_dict['None of the above choices match the user\'s intent'] = default_callable
+    if settings.AI_CHAT_DEFAULT_CALLABLE is not None:
+        intent_dict['None of the above choices match the user\'s intent'] = get_callable_from_module_string_and_validate_arguments(
+            settings.AI_CHAT_DEFAULT_CALLABLE,
+            ['request', 'user_input', 'message_history']
+        )
 
     return Decoder(
         mapping_keys_description='Intent of the User\'s Request',

{django_spire-0.19.5 → django_spire-0.20.1}/django_spire/ai/chat/intelligence/workflows/chat_workflow.py

@@ -8,25 +8,15 @@ from dandy.recorder import recorder_to_html_file
 from django_spire.ai.chat.intelligence.decoders.tools import generate_intent_decoder
 from django_spire.ai.chat.message_intel import BaseMessageIntel, DefaultMessageIntel
 from django_spire.ai.decorators import log_ai_interaction_from_recorder
+from django_spire.conf import settings
+from django_spire.core.utils import get_callable_from_module_string_and_validate_arguments
 
 if TYPE_CHECKING:
     from dandy.llm.request.message import MessageHistory
     from django.core.handlers.wsgi import WSGIRequest
 
 
-def SpireChatWorkflow(
-    request: WSGIRequest,
-    user_input: str,
-    message_history: MessageHistory | None = None
-) -> BaseMessageIntel:
-    return chat_workflow(
-        request=request,
-        user_input=user_input,
-        message_history=message_history
-    )
-
-
-def default_chat_response(
+def default_chat_callable(
     request: WSGIRequest,
     user_input: str,
     message_history: MessageHistory | None = None
@@ -45,13 +35,6 @@ def chat_workflow(
     user_input: str,
     message_history: MessageHistory | None = None
 ) -> BaseMessageIntel:
-    intent_decoder = generate_intent_decoder(
-        request=request,
-        default_callable=default_chat_response,
-    )
-
-    intent_process = intent_decoder.process(user_input, max_return_values=1)[0]
-
     @log_ai_interaction_from_recorder(request.user)
     def run_workflow_process(callable_: Callable) -> BaseMessageIntel | None:
         return callable_(
@@ -60,11 +43,28 @@ def chat_workflow(
             message_history=message_history,
         )
 
-    message_intel = run_workflow_process(intent_process)
+    if settings.AI_CHAT_CALLABLE is not None:
+        chat_callable = get_callable_from_module_string_and_validate_arguments(
+            settings.AI_CHAT_CALLABLE,
+            ['request', 'user_input', 'message_history']
+        )
+
+        message_intel = run_workflow_process(chat_callable)
+
+    else:
+
+        intent_decoder = generate_intent_decoder(
+            request=request,
+            default_callable=default_chat_callable,
+        )
+
+        intent_process = intent_decoder.process(user_input, max_return_values=1)[0]
+
+        message_intel = run_workflow_process(intent_process)
 
     if not isinstance(message_intel, BaseMessageIntel):
         if message_intel is None:
-            return default_chat_response(
+            return default_chat_callable(
                 request=request,
                 user_input=user_input,
                 message_history=message_history

{django_spire-0.19.5 → django_spire-0.20.1}/django_spire/consts.py

@@ -1,4 +1,4 @@
-__VERSION__ = '0.19.5'
+__VERSION__ = '0.20.1'
 
 MAINTENANCE_MODE_SETTINGS_NAME = 'MAINTENANCE_MODE'
 

django_spire-0.20.1/django_spire/core/migrations/0001_initial.py

@@ -0,0 +1,26 @@
+# Generated by Django 5.2.7 on 2025-11-09 05:02
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Tag',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.SlugField(max_length=128, unique=True)),
+            ],
+            options={
+                'verbose_name': 'Tag',
+                'verbose_name_plural': 'Tags',
+                'db_table': 'django_spire_core_tag',
+            },
+        ),
+    ]

django_spire-0.20.1/django_spire/core/tags/intelligence/tag_set_bot.py

@@ -0,0 +1,41 @@
+from dandy import Bot, Prompt, BaseListIntel
+from django.utils.text import slugify
+
+
+class TagsIntel(BaseListIntel[list[str]]):
+    tags: list[str]
+
+
+class TagSetBot(Bot):
+    llm_role = 'Tag Identifier'
+    llm_task = 'Read through the provided content and return a list of tags.'
+    llm_guidelines = (
+        Prompt()
+        .list([
+            'Make sure to have enough tags to properly cover all the provided content.',
+            'Focus on tagging the words in the content',
+            'Only add additional words that are very relevant to the content.'
+            'Use spaces to separate words in tags',
+            'Include known acronyms along with the full tags.',
+        ])
+    )
+
+    def process(self, content: Prompt | str) -> set[str]:
+        tags_intel = self.llm.prompt_to_intel(
+            prompt=(
+                Prompt()
+                .heading('Content to be Tagged:')
+                .line_break()
+                .text(content)
+            ),
+            intel_class=TagsIntel
+        )
+
+        for tag in tags_intel:
+            word_segments = tag.split(" ")
+
+            if len(word_segments) > 1:
+                for word_segment in word_segments:
+                    tags_intel.append(word_segment)
+
+        return {slugify(tag) for tag in tags_intel}

django_spire-0.20.1/django_spire/core/tags/mixins.py

@@ -0,0 +1,61 @@
+from django.db import models
+from django.db.models import QuerySet
+
+from django_spire.core.tags.models import Tag
+from django_spire.core.tags import tools
+
+
+class TagsModelMixin(models.Model):
+    tags = models.ManyToManyField(Tag, related_name='+', null=True, blank=True, editable=False)
+
+    class Meta:
+        abstract = True
+
+    @property
+    def tag_set(self) -> set[str]:
+        return set(self.tags.values_list('name', flat=True))
+
+    @property
+    def tag_set_simplified(self) -> set[str]:
+        simplified_tag_words = []
+
+        for tag in self.tag_set:
+            tag_words = tag.split('-')
+            simplified_tag_words.extend(tag_words)
+
+        return set(simplified_tag_words)
+
+    def add_tags_from_tag_set(self, tag_set: set[str]):
+        self._update_global_tags_from_set(tag_set)
+
+        self.tags.add(*Tag.objects.in_tag_set(tag_set))
+
+    def clear_tags(self):
+        self.tags.clear()
+
+    def get_matching_tags_from_tag_set(self, tag_set: set[str]) -> QuerySet:
+        return self.tags.in_tag_set(tag_set)
+
+    def get_matching_percentage_of_tag_set(self, tag_set: set[str]) -> float:
+        return tools.get_matching_a_percentage_from_tag_sets(tag_set, self.tag_set)
+
+    def get_matching_percentage_of_model_tags_from_tag_set(self, tag_set: set[str]) -> float:
+        return tools.get_matching_b_percentage_from_tag_sets(tag_set, self.tag_set)
+
+    def has_tags_in_tag_set(self, tag_set: set[str]) -> bool:
+        return self.tag_set.issuperset(tag_set)
+
+    def remove_tags_by_tag_set(self, tag_set: set[str]):
+        tag_objects = Tag.objects.in_tag_set(tag_set)
+
+        self.tags.remove(*tag_objects)
+
+    def set_tags_from_tag_set(self, tag_set: set[str]):
+        self._update_global_tags_from_set(tag_set)
+
+        tag_objects = Tag.objects.in_tag_set(tag_set)
+        self.tags.set(tag_objects)
+
+    @staticmethod
+    def _update_global_tags_from_set(tag_set: set[str]):
+        Tag.add_tags([Tag(name=tag) for tag in tag_set])

django_spire-0.20.1/django_spire/core/tags/models.py

@@ -0,0 +1,38 @@
+from typing import Sequence, Self
+
+from django.db import models
+from django.utils.text import slugify
+
+from django_spire.core.tags.querysets import TagQuerySet
+
+
+class Tag(models.Model):
+    name = models.SlugField(
+        max_length=128,
+        unique=True
+    )
+
+    objects = TagQuerySet.as_manager()
+
+    def __init__(self, *args, **kwargs):
+        name = kwargs.get('name')
+        if name:
+            kwargs['name'] = slugify(name)
+
+        super().__init__(*args, **kwargs)
+
+    def __str__(self):
+        return self.name
+
+    @classmethod
+    def add_tags(cls, tags: Sequence[Self]):
+        cls.objects.bulk_create(
+            tags,
+            ignore_conflicts=True
+        )
+
+    class Meta:
+        db_table = 'django_spire_core_tag'
+        verbose_name = 'Tag'
+        verbose_name_plural = 'Tags'
+

django_spire-0.20.1/django_spire/core/tags/querysets.py

@@ -0,0 +1,9 @@
+from django.db.models import QuerySet
+from django.utils.text import slugify
+
+
+class TagQuerySet(QuerySet):
+    def in_tag_set(self, tag_set: set[str]):
+        slugified_tag_set = set(map(slugify, tag_set))
+
+        return self.filter(name__in=slugified_tag_set)

django_spire-0.20.1/django_spire/core/tags/tests/test_intelligence.py

@@ -0,0 +1,28 @@
+from unittest import TestCase
+
+from django_spire.core.tags.intelligence.tag_set_bot import TagSetBot
+
+TEST_INPUT = """
+    I love reading books about science fiction, fantasy, and adventure, especially ones
+    that feature artificial intelligence, machine learning, and natural language processing.
+    Some of my favorite authors include Isaac Asimov, J.R.R. Tolkien, and Neil Gaiman.
+    I'm also interested in learning more about data science, programming languages like Python
+    and Java, and emerging technologies like blockchain and the Internet of Things (IoT).
+    Can you recommend some books or resources that align with these interests?
+    """
+
+
+class TestTagIntelligence(TestCase):
+    def setUp(self):
+        pass
+
+    def test_tag_set_bot(self):
+        tag_set = TagSetBot().process(TEST_INPUT)
+
+        self.assertIn('science', tag_set)
+        self.assertIn('artificial', tag_set)
+        self.assertIn('fantasy', tag_set)
+
+        self.assertNotIn('camping', tag_set)
+        self.assertNotIn('art', tag_set)
+        self.assertNotIn('hate', tag_set)

django_spire-0.20.1/django_spire/core/tags/tests/test_tags.py

@@ -0,0 +1,102 @@
+from django.test import TestCase
+
+from django_spire.core.tags.models import Tag
+from django_spire.knowledge.collection.models import Collection
+
+
+class TestTags(TestCase):
+    def setUp(self):
+        self.collection = Collection.objects.create(
+            name='Test Collection', description='Test Collection Description'
+        )
+
+        self.tag_set_a = {'apple', 'banana', 'orange'}
+        self.tag_set_b = {'grape', 'kiwi', 'pear'}
+        self.tag_set_c = {'lemon', 'lime', 'mango'}
+
+        self.mixed_tag_set = {'apple', 'grape', 'lemon'}
+
+        self.dirty_tag_set = {'HaT~', 'four* tacos', '123 hoop!!'}
+
+        self.collection.add_tags_from_tag_set(self.tag_set_a)
+        self.collection.add_tags_from_tag_set(self.tag_set_b)
+        self.collection.add_tags_from_tag_set(self.tag_set_c)
+
+        self.collection.add_tags_from_tag_set(self.mixed_tag_set)
+
+        self.collection.add_tags_from_tag_set(self.dirty_tag_set)
+
+    def test_tag_removal(self):
+        self.assertIn('apple', self.collection.tag_set)
+
+        self.collection.remove_tags_by_tag_set(self.mixed_tag_set)
+
+        self.assertNotIn('lemon', self.collection.tag_set)
+
+        self.assertIn('kiwi', self.collection.tag_set)
+
+    def test_tag_add_and_set(self):
+        self.collection.set_tags_from_tag_set(self.mixed_tag_set)
+
+        self.assertIn('lemon', self.collection.tag_set)
+
+        self.assertNotIn('banana', self.collection.tag_set)
+
+    def test_tag_count(self):
+        self.assertEqual(Tag.objects.count(), 12)
+        self.assertEqual(self.collection.tags.count(), 12)
+
+    def test_tag_removal(self):
+        self.collection.remove_tags_by_tag_set(self.tag_set_a)
+
+        self.assertEqual(self.collection.tags.count(), 9)
+
+    def test_tag_bool_methods(self):
+        self.collection.remove_tags_by_tag_set(self.tag_set_b)
+
+        self.assertTrue(self.collection.has_tags_in_tag_set(self.tag_set_c))
+        self.assertFalse(self.collection.has_tags_in_tag_set(self.mixed_tag_set))
+
+    def test_tag_matching_methods(self):
+        self.assertEqual(len(self.collection.get_matching_tags_from_tag_set(self.tag_set_a)), 3)
+
+        self.collection.remove_tags_by_tag_set(self.tag_set_a)
+
+        self.assertEqual(len(self.collection.get_matching_tags_from_tag_set(self.tag_set_a)), 0)
+        self.assertEqual(len(self.collection.get_matching_tags_from_tag_set(self.tag_set_b)), 3)
+        self.assertEqual(len(self.collection.get_matching_tags_from_tag_set(self.mixed_tag_set)), 2)
+
+        self.collection.remove_tags_by_tag_set(self.tag_set_b)
+
+        self.assertEqual(len(self.collection.get_matching_tags_from_tag_set(self.tag_set_b)), 0)
+
+        self.assertEqual(len(self.collection.get_matching_tags_from_tag_set(self.mixed_tag_set)), 1)
+
+    def test_tag_metric_methods(self):
+        self.assertAlmostEqual(
+            self.collection.get_matching_percentage_of_tag_set(self.tag_set_a),
+            1.00,
+            2
+        )
+
+        self.assertAlmostEqual(
+            self.collection.get_matching_percentage_of_model_tags_from_tag_set(self.tag_set_b),
+            0.25,
+            2
+        )
+
+        self.collection.remove_tags_by_tag_set(self.mixed_tag_set)
+
+        self.assertAlmostEqual(
+            self.collection.get_matching_percentage_of_tag_set(self.tag_set_a),
+            0.666,
+            2
+        )
+
+
+        self.assertAlmostEqual(
+            self.collection.get_matching_percentage_of_model_tags_from_tag_set(self.tag_set_b),
+            0.222,
+            2
+        )
+

django_spire-0.20.1/django_spire/core/tags/tools.py

@@ -0,0 +1,20 @@
+def get_matching_tag_set_from_tag_sets(tag_set_a: set[str], tag_set_b: set[str]) -> set[str]:
+    return tag_set_a.intersection(tag_set_b)
+
+
+def get_matching_count_from_tag_sets(tag_set_a: set[str], tag_set_b: set[str]) -> int:
+    return len(get_matching_tag_set_from_tag_sets(tag_set_a, tag_set_b))
+
+
+def get_matching_a_percentage_from_tag_sets(tag_set_a: set[str], tag_set_b: set[str]) -> float:
+    try:
+        return get_matching_count_from_tag_sets(tag_set_a, tag_set_b) / len(tag_set_a)
+    except ZeroDivisionError:
+        return 0.0
+
+
+def get_matching_b_percentage_from_tag_sets(tag_set_a: set[str], tag_set_b: set[str]) -> float:
+    try:
+        return get_matching_count_from_tag_sets(tag_set_a, tag_set_b) / len(tag_set_b)
+    except ZeroDivisionError:
+        return 0.0

django_spire-0.20.1/django_spire/knowledge/collection/admin.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from django.contrib import admin
+from django.db.models import QuerySet
+from django.contrib import messages
+
+from .models import Collection, CollectionGroup
+
+
+@admin.register(Collection)
+class CollectionAdmin(admin.ModelAdmin):
+    list_display = ['id', 'name', 'parent', 'is_deleted', 'tag_count']
+    list_select_related = ['parent']
+    list_filter = ['is_deleted', 'is_active']
+    search_fields = ['id', 'name', 'description', 'parent__name']
+    ordering = ['name']
+    autocomplete_fields = ['parent']
+    actions = ['set_tags_for_collections']
+
+    @admin.action(description="Set Tags for Collections (Allow 5 Seconds Per)")
+    def set_tags_for_collections(self, request, queryset: QuerySet[Collection]):
+        processed = 0
+        for collection in queryset:
+            collection.services.tag.process_and_set_tags()
+            processed += 1
+
+        messages.success(request, f'Successfully processed {processed} collections.')
+
+    def tag_count(self, collection: Collection):
+        return collection.tags.count()
+
+    tag_count.short_description = 'Tags'
+
+
+@admin.register(CollectionGroup)
+class CollectionGroupAdmin(admin.ModelAdmin):
+    list_display = ['id', 'collection', 'auth_group']
+    list_select_related = ['collection', 'auth_group']
+    search_fields = ['id', 'collection__name', 'auth_group__name']
+
+

{django_spire-0.19.5 → django_spire-0.20.1}/django_spire/knowledge/collection/models.py

@@ -5,6 +5,7 @@ from django.db import models
 from django_spire.auth.group.models import AuthGroup
 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.querysets import CollectionQuerySet
@@ -12,7 +13,11 @@ from django_spire.knowledge.collection.services.service import CollectionGroupSe
     CollectionService
 
 
-class Collection(HistoryModelMixin, OrderingModelMixin):
+class Collection(
+    HistoryModelMixin,
+    OrderingModelMixin,
+    TagsModelMixin,
+):
     parent = models.ForeignKey(
         'self',
         on_delete=models.CASCADE,

{django_spire-0.19.5 → django_spire-0.20.1}/django_spire/knowledge/collection/services/service.py

@@ -10,6 +10,7 @@ from django_spire.knowledge.collection.services.ordering_service import \
     CollectionOrderingService
 from django_spire.knowledge.collection.services.processor_service import \
     CollectionProcessorService
+from django_spire.knowledge.collection.services.tag_service import CollectionTagService
 from django_spire.knowledge.collection.services.transformation_service import \
     CollectionTransformationService
 
@@ -22,6 +23,7 @@ class CollectionService(BaseDjangoModelService['Collection']):
 
     ordering = CollectionOrderingService()
     processor = CollectionProcessorService()
+    tag = CollectionTagService()
     transformation = CollectionTransformationService()
 
     def save_model_obj(self, **field_data) -> tuple[Collection, bool]:

django_spire-0.20.1/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-0.19.5 → django_spire-0.20.1}/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-0.19.5 → django_spire-0.20.1}/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-0.19.5 → django_spire-0.20.1}/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-0.19.5 → django_spire-0.20.1}/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()