django-spire 0.25.1__py3-none-any.whl → 0.25.2__py3-none-any.whl

django_spire/knowledge/intelligence/bots/knowledge_answer_bot.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from enum import StrEnum
 from typing import TYPE_CHECKING
 
 from dandy import Bot, Prompt
@@ -7,9 +8,28 @@ from dandy import Bot, Prompt
 from django_spire.knowledge.intelligence.intel.answer_intel import AnswerIntel
 
 if TYPE_CHECKING:
+    from dandy.llm.request.message import MessageHistory
+
     from django_spire.knowledge.entry.models import Entry
 
 
+class BlockType(StrEnum):
+    HEADING = 'HEADING'
+    SUBHEADING = 'SUBHEADING'
+
+
+class MarkerType(StrEnum):
+    ARTICLE = 'ARTICLE'
+    END_ARTICLE = 'END ARTICLE'
+
+
+def format_marker(marker: MarkerType, label: str | None = None) -> str:
+    if label:
+        return f'[{marker}: {label}]'
+
+    return f'[{marker}]'
+
+
 class KnowledgeAnswerBot(Bot):
     llm_role = 'Knowledge Entry Search Assistant'
     llm_task = 'Read through the knowledge and answer the users request.'
@@ -18,13 +38,20 @@ class KnowledgeAnswerBot(Bot):
         .list([
             'Make sure the answer is relevant and reflects knowledge entries.',
             'Do not make up information use the provided knowledge entries as a source of truth.',
-            'Use line breaks to separate sections of the answer and use 2 if you need to separate the section from the previous.'
+            'Use line breaks to separate sections of the answer and use 2 if you need to separate the section from the previous.',
+            'Use the conversation history to understand context and references like "before that", "my last query", etc.',
+            'When a user asks about an article or section by title, summarize the content of that article or section.',
+            f'Content under a [{BlockType.HEADING}] or [{BlockType.SUBHEADING}] belongs to that section.',
         ])
     )
     llm_intel_class = AnswerIntel
 
-    def process(self, user_input: str, entries: list[Entry]) -> AnswerIntel:
-
+    def process(
+        self,
+        user_input: str,
+        entries: list[Entry],
+        message_history: MessageHistory | None = None
+    ) -> AnswerIntel:
         entry_prompt = Prompt()
         entry_prompt.sub_heading('User Request')
         entry_prompt.line_break()
@@ -34,11 +61,18 @@ class KnowledgeAnswerBot(Bot):
         entry_prompt.line_break()
 
         for entry in entries:
+            entry_prompt.text(format_marker(MarkerType.ARTICLE, entry.name))
+
             for version_block in entry.current_version.blocks.all():
-                if version_block.render_to_text() != '\n':
-                    entry_prompt.text(f'{version_block.render_to_text()}')
+                text = version_block.render_to_text()
+
+                if text and text != '\n':
+                    entry_prompt.text(f'[{version_block.type.upper()}] {text}')
+
+            entry_prompt.text(format_marker(MarkerType.END_ARTICLE))
+            entry_prompt.line_break()
 
         return self.llm.prompt_to_intel(
             prompt=entry_prompt,
+            message_history=message_history,
         )
-

django_spire/knowledge/intelligence/bots/knowledge_entries_bot.py

@@ -25,7 +25,6 @@ class KnowledgeEntriesBot(Bot):
     llm_intel_class = EntriesIntel
 
     def process(self, user_input: str, entries: list[Entry]) -> EntriesIntel:
-
         entry_prompt = Prompt()
         entry_prompt.sub_heading('User Request')
         entry_prompt.line_break()
@@ -35,11 +34,14 @@ class KnowledgeEntriesBot(Bot):
         entry_prompt.line_break()
 
         for entry in entries:
+            entry_prompt.text(f'Entry: {entry.name}')
+
             for version_block in entry.current_version.blocks.all():
                 if version_block.render_to_text() != '\n':
                     entry_prompt.text(f'{version_block.id}: {version_block.render_to_text()}')
 
+            entry_prompt.line_break()
+
         return self.llm.prompt_to_intel(
             prompt=entry_prompt,
         )
-

django_spire/knowledge/intelligence/bots/search_preprocessing_bot.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from dandy import BaseIntel, Bot, Prompt
+
+
+class PreprocessedQueryIntel(BaseIntel):
+    corrected_query: str
+    meaningful_words: list[str]
+    expanded_terms: list[str]
+    search_phrases: list[str]
+
+
+class SearchPreprocessingBot(Bot):
+    llm_intel_class = PreprocessedQueryIntel
+    llm_role = 'Search Query Preprocessor'
+    llm_task = 'Process a user search query to optimize it for knowledge base retrieval.'
+    llm_guidelines = (
+        Prompt()
+        .list([
+            'Correct any obvious spelling or grammar mistakes while preserving intent.',
+            'Identify meaningful words by removing stop words (the, a, an, is, are, how, what, can, do, etc.).',
+            'Keep technical terms, acronyms, nouns, verbs, and domain-specific vocabulary as meaningful words.',
+            'Generate 3-5 synonyms or related terms for key concepts in expanded_terms.',
+            'Provide 2-3 alternative search phrases in search_phrases.',
+            'Do not change proper nouns or technical terminology.',
+        ])
+    )
+
+    def process(self, query: str) -> PreprocessedQueryIntel:
+        return self.llm.prompt_to_intel(
+            prompt=f'Process this search query: {query}'
+        )

django_spire/knowledge/intelligence/intel/entry_intel.py

@@ -23,3 +23,15 @@ class EntryIntel(BaseIntel):
 
 class EntriesIntel(BaseListIntel[EntryIntel]):
     entry_intel_list: list[EntryIntel]
+
+    @property
+    def unique(self) -> list[EntryIntel]:
+        seen = set()
+        result = []
+
+        for entry_intel in self:
+            if entry_intel.relevant_heading_text not in seen:
+                seen.add(entry_intel.relevant_heading_text)
+                result.append(entry_intel)
+
+        return result

django_spire/knowledge/intelligence/router.py

@@ -2,25 +2,68 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+from dandy import Bot, Prompt
+
+from django_spire.ai.chat.message_intel import BaseMessageIntel, DefaultMessageIntel
 from django_spire.ai.chat.router import BaseChatRouter
-from django_spire.knowledge.intelligence.workflows.knowledge_workflow import knowledge_search_workflow
+from django_spire.conf import settings
+from django_spire.knowledge.intelligence.workflows.knowledge_workflow import (
+    NO_KNOWLEDGE_MESSAGE_INTEL,
+    knowledge_search_workflow,
+)
 
 if TYPE_CHECKING:
     from dandy.llm.request.message import MessageHistory
     from django.core.handlers.wsgi import WSGIRequest
 
-    from django_spire.ai.chat.message_intel import BaseMessageIntel
-
 
 class KnowledgeSearchRouter(BaseChatRouter):
+    def _default_chat_callable(
+        self,
+        request: WSGIRequest,
+        user_input: str,
+        message_history: MessageHistory | None = None
+    ) -> BaseMessageIntel:
+        persona_name = getattr(settings, 'DJANGO_SPIRE_AI_PERSONA_NAME', 'AI Assistant')
+
+        system_prompt = (
+            Prompt()
+            .text(f'You are {persona_name}, a helpful AI assistant.')
+            .line_break()
+            .text('Important rules:')
+            .list([
+                f'You should always identify yourself as {persona_name}.',
+                'Please never mention being Qwen, Claude, GPT, or any other model name.',
+                'Be helpful, friendly, and professional.',
+            ])
+        )
+
+        bot = Bot()
+        bot.llm_role = system_prompt
+
+        return bot.llm.prompt_to_intel(
+            prompt=user_input,
+            intel_class=DefaultMessageIntel,
+            message_history=message_history,
+        )
+
     def workflow(
         self,
         request: WSGIRequest,
         user_input: str,
         message_history: MessageHistory | None = None
     ) -> BaseMessageIntel:
-        return knowledge_search_workflow(
+        knowledge_result = knowledge_search_workflow(
             request=request,
             user_input=user_input,
             message_history=message_history
         )
+
+        if knowledge_result == NO_KNOWLEDGE_MESSAGE_INTEL:
+            return self._default_chat_callable(
+                request=request,
+                user_input=user_input,
+                message_history=message_history
+            )
+
+        return knowledge_result

django_spire/knowledge/intelligence/workflows/knowledge_workflow.py

@@ -2,18 +2,17 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from django.core.handlers.wsgi import WSGIRequest
+from django.db.models import Prefetch
 
-from django_spire.ai.chat.message_intel import DefaultMessageIntel, BaseMessageIntel
-from django_spire.core.tag.intelligence.tag_set_bot import TagSetBot
-from django_spire.knowledge.collection.models import Collection
+from django_spire.ai.chat.message_intel import BaseMessageIntel, DefaultMessageIntel
+from django_spire.knowledge.entry.models import Entry
 from django_spire.knowledge.intelligence.bots.knowledge_answer_bot import KnowledgeAnswerBot
 from django_spire.knowledge.intelligence.bots.knowledge_entries_bot import KnowledgeEntriesBot
 from django_spire.knowledge.intelligence.intel.message_intel import KnowledgeMessageIntel
 
 if TYPE_CHECKING:
-    from django.core.handlers.wsgi import WSGIRequest
     from dandy.llm.request.message import MessageHistory
+    from django.core.handlers.wsgi import WSGIRequest
 
 
 NO_KNOWLEDGE_MESSAGE_INTEL = DefaultMessageIntel(
@@ -24,52 +23,35 @@ NO_KNOWLEDGE_MESSAGE_INTEL = DefaultMessageIntel(
 def knowledge_search_workflow(
     request: WSGIRequest,
     user_input: str,
-    message_history: MessageHistory | None = None
+    message_history: MessageHistory | None = None,
+    max_results: int = 10,
+    use_llm_preprocessing: bool = True,
 ) -> BaseMessageIntel | None:
-    user_tag_set = TagSetBot().process(user_input)
-
-    def get_top_scored_from_dict_to_list(
-            scored_dict: dict[str, float],
-            score_floor: float = 0.05
-    ) -> list:
-        if not scored_dict:
-            return []
-
-        min_score = min(scored_dict.values())
-        max_score = max(scored_dict.values())
-
-        if min_score == 0 and max_score == 0:
-            return []
-
-        median_score = (max_score - min_score) / 2
+    from django_spire.knowledge.entry.version.block.models import EntryVersionBlock
 
-        top_scored_list = []
-
-        for key, value in scored_dict.items():
-            if value >= score_floor and value >= median_score:
-                top_scored_list.append(key)
-
-        return top_scored_list
-
-    collections = get_top_scored_from_dict_to_list({
-        collection: collection.services.tag.get_score_percentage_from_aggregated_tag_set_weighted(
-            user_tag_set
+    entries = list(
+        Entry.services.search
+        .search(
+            query=user_input,
+            use_llm_preprocessing=use_llm_preprocessing,
         )
-        for collection in Collection.objects.all().annotate_entry_count()
-    })
-
-    entries = get_top_scored_from_dict_to_list({
-        entry: entry.services.tag.get_score_percentage_from_tag_set_weighted(user_tag_set)
-        for collection in collections
-        for entry in collection.entries.all()
-    })
+        .user_has_access(user=request.user)
+        .select_related('current_version', 'current_version__author', 'collection')
+        .prefetch_related(
+            Prefetch(
+                'current_version__blocks',
+                queryset=EntryVersionBlock.objects.active().order_by('order')
+            )
+        )[:max_results]
+    )
 
     if not entries:
         return NO_KNOWLEDGE_MESSAGE_INTEL
 
     answer_intel_future = KnowledgeAnswerBot(llm_temperature=0.5).process_to_future(
         user_input=user_input,
-        entries=entries
+        entries=entries,
+        message_history=message_history,
     )
 
     entries_intel_future = KnowledgeEntriesBot(llm_temperature=0.5).process_to_future(

django_spire/knowledge/intelligence/workflows/search_preprocessing_workflow.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import hashlib
+
+from dataclasses import dataclass
+
+from django.core.cache import cache
+
+from django_spire.knowledge.intelligence.bots.search_preprocessing_bot import (
+    PreprocessedQueryIntel,
+    SearchPreprocessingBot,
+)
+
+
+PREPROCESSING_CACHE_TIMEOUT = 3600
+
+
+def _get_cache_key(query: str) -> str:
+    normalized = query.lower().strip()
+    query_hash = hashlib.sha256(normalized.encode()).hexdigest()
+    return f'knowledge_search_preprocess:{query_hash}'
+
+
+@dataclass
+class PreprocessedSearchQuery:
+    corrected_query: str
+    expanded_terms: list[str]
+    meaningful_words: list[str]
+    original_query: str
+    search_phrases: list[str]
+
+    @property
+    def all_search_terms(self) -> set[str]:
+        terms = set(self.meaningful_words)
+        terms.update(self.expanded_terms)
+
+        if not terms:
+            terms.add(self.corrected_query or self.original_query)
+
+        return terms
+
+    @property
+    def primary_search_query(self) -> str:
+        if self.meaningful_words:
+            return ' '.join(self.meaningful_words)
+
+        return self.corrected_query or self.original_query
+
+
+def preprocess_search_query(
+    query: str,
+    use_cache: bool = True,
+    llm_temperature: float = 0.3
+) -> PreprocessedSearchQuery:
+    if use_cache:
+        cache_key = _get_cache_key(query)
+        cached = cache.get(cache_key)
+
+        if cached:
+            return cached
+
+    intel: PreprocessedQueryIntel = (
+        SearchPreprocessingBot(llm_temperature=llm_temperature)
+        .process(query=query)
+    )
+
+    result = PreprocessedSearchQuery(
+        corrected_query=intel.corrected_query,
+        expanded_terms=intel.expanded_terms,
+        meaningful_words=intel.meaningful_words,
+        original_query=query,
+        search_phrases=intel.search_phrases,
+    )
+
+    if use_cache:
+        cache.set(cache_key, result, PREPROCESSING_CACHE_TIMEOUT)
+
+    return result

django_spire/knowledge/management/commands/rebuild_knowledge_search_index.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from django.core.management.base import BaseCommand
+
+from django_spire.knowledge.entry.models import Entry
+
+
+class Command(BaseCommand):
+    help = 'Rebuilds the search index for all knowledge base entries.'
+
+    def handle(self, *args, **options):
+        self.stdout.write('Rebuilding search indexes...')
+
+        Entry.services.search_index.rebuild_all_search_indexes()
+
+        self.stdout.write(self.style.SUCCESS('Search indexes rebuilt successfully.'))

django_spire/knowledge/migrations/0010_entry__search_text_entry__search_vector_and_more.py

@@ -0,0 +1,40 @@
+# Generated by Django 5.1.15 on 2026-01-23 16:22
+
+import django.contrib.postgres.indexes
+import django.contrib.postgres.search
+from django.contrib.postgres.operations import TrigramExtension
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('django_spire_core', '0001_initial'),
+        ('django_spire_knowledge', '0009_alter_collection_tags_alter_entry_tags'),
+    ]
+
+    operations = [
+        TrigramExtension(),
+        migrations.AddField(
+            model_name='entry',
+            name='_search_text',
+            field=models.TextField(blank=True, default=''),
+        ),
+        migrations.AddField(
+            model_name='entry',
+            name='_search_vector',
+            field=django.contrib.postgres.search.SearchVectorField(null=True),
+        ),
+        migrations.AddIndex(
+            model_name='entry',
+            index=django.contrib.postgres.indexes.GinIndex(fields=['_search_vector'], name='entry_search_vector_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='entry',
+            index=django.contrib.postgres.indexes.GinIndex(fields=['name'], name='entry_name_trgm_idx', opclasses=['gin_trgm_ops']),
+        ),
+        migrations.AddIndex(
+            model_name='entry',
+            index=django.contrib.postgres.indexes.GinIndex(fields=['_search_text'], name='entry_search_text_trgm_idx', opclasses=['gin_trgm_ops']),
+        ),
+    ]

django_spire/knowledge/templates/django_spire/knowledge/message/knowledge_message_intel.html

@@ -1,32 +1,40 @@
 {% extends 'django_spire/ai/chat/message/message.html' %}
 
+{% load spire_ai_chat_tags %}
+
 {% block message_content %}
     <div class="row">
-        <div class="col">
-            {{ message_intel.answer_intel.answer|linebreaksbr }}
+        <div class="col ai-message-content">
+            {{ message_intel.answer_intel.answer|render_markdown }}
         </div>
     </div>
 
-    <div class="row mt-2 p-1" x-data="{show_resources: false}">
-        <div class="col-auto mx-2 ps-1 pe-2 py-1 fs-7 rounded-3 border border-primary-subtle">
-            <span class="text-muted cursor-pointer" x-on:click="show_resources = !show_resources">
-                <i class="bi bi-caret-right" x-show="!show_resources"></i>
-                <i class="bi bi-caret-down" x-show="show_resources"></i>
-                Sources
-            </span>
-
-            <ul class="my-0 me-3" x-show="show_resources">
-                {% for entry_intel in message_intel.entries_intel %}
-                    <li class="pb-1">
-                        <a href="{% url 'django_spire:knowledge:entry:version:page:editor' pk=entry_intel.entry.id %}?show_sub_nav=false&block_id={{ entry_intel.relevant_block_id }}"
-                           target="_blank">
-                            {{ entry_intel.relevant_heading_text }}
-                        </a>
-                    </li>
-                {% endfor %}
-            </ul>
+    {% if message_intel.entries_intel %}
+        <div class="row mt-2 p-1" x-data="{show_resources: false}">
+            <div class="col-auto mx-2 ps-1 pe-2 py-1 fs-7 rounded-3 border border-primary-subtle">
+                <span class="text-muted cursor-pointer" x-on:click="show_resources = !show_resources">
+                    <i class="bi bi-caret-right" x-show="!show_resources"></i>
+                    <i class="bi bi-caret-down" x-show="show_resources"></i>
+                    Sources
+                </span>
 
+                <ul class="my-0 me-3" x-show="show_resources">
+                    {% for entry_intel in message_intel.entries_intel.unique %}
+                        {% if entry_intel.entry and entry_intel.entry.id %}
+                            <li class="pb-1">
+                                <a href="{% url 'django_spire:knowledge:entry:version:page:editor' pk=entry_intel.entry.id %}?show_sub_nav=false&block_id={{ entry_intel.relevant_block_id }}"
+                                   target="_blank">
+                                    {{ entry_intel.relevant_heading_text }}
+                                </a>
+                            </li>
+                        {% else %}
+                            <li class="pb-1 text-muted">
+                                {{ entry_intel.relevant_heading_text }} (source unavailable)
+                            </li>
+                        {% endif %}
+                    {% endfor %}
+                </ul>
+            </div>
         </div>
-    </div>
-
-{% endblock %}
+    {% endif %}
+{% endblock %}

django_spire/metric/report/enums.py

@@ -1,14 +1,20 @@
-from enum import Enum
+from enum import StrEnum
 
 
-class ColumnType(str, Enum):
+class ColumnType(StrEnum):
     TEXT = 'text'
     CHOICE = 'choice'
     NUMBER = 'number'
-    DECIMAL_1 = 'decimal_1'
-    DECIMAL_2 = 'decimal_2'
-    DECIMAL_3 = 'decimal_3'
+    NUMBER_1 = 'decimal_1'
+    NUMBER_2 = 'decimal_2'
+    NUMBER_3 = 'decimal_3'
     DOLLAR = 'dollar'
+    DOLLAR_1 = 'dollar_1'
+    DOLLAR_2 = 'dollar_2'
+    DOLLAR_3 = 'dollar_3'
     PERCENT = 'percent'
+    PERCENT_1 = 'percent_1'
+    PERCENT_2 = 'percent_2'
+    PERCENT_3 = 'percent_3'
 
 

django_spire/metric/report/report.py

@@ -2,14 +2,12 @@ import inspect
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from dataclasses import field
-from typing import Literal, Callable, Any
+from typing import Callable, Any
 
 from django_spire.metric.report.enums import ColumnType
 from django_spire.metric.report.helper import Helper
 from django_spire.metric.report.tools import get_text_alignment_css_class
 
-ColumnLiteralType = Literal['text', 'choice', 'number', 'dollar', 'percent']
-
 
 @dataclass
 class ReportColumn:
@@ -35,17 +33,31 @@ class ReportCell:
     @staticmethod
     def cell_value_verbose(value, cell_type):
         if cell_type == ColumnType.DOLLAR:
-            return f"${float(value):,.2f}"
+            return f"${float(value):,.0f}"
+        elif cell_type == ColumnType.DOLLAR_1:
+            return f"${float(value):,.1f}%"
+        elif cell_type == ColumnType.DOLLAR_2:
+            return f"${float(value):,.2f}%"
+        elif cell_type == ColumnType.DOLLAR_3:
+            return f"${float(value):,.3f}%"
+
+        elif cell_type == ColumnType.PERCENT:
+            return f"{float(value):,.0f}%"
+        elif cell_type == ColumnType.PERCENT_1:
+            return f"{float(value):,.1f}%"
+        elif cell_type == ColumnType.PERCENT_2:
+            return f"{float(value):,.2f}%"
+        elif cell_type == ColumnType.PERCENT_3:
+            return f"{float(value):,.3f}%"
+
         elif cell_type == ColumnType.NUMBER:
             return f"{float(value):,.0f}"
-        elif cell_type == ColumnType.PERCENT:
-            return f"{float(value):.1f}%"
-        elif cell_type == ColumnType.DECIMAL_1:
-            return f"{float(value):.1f}"
-        elif cell_type == ColumnType.DECIMAL_2:
-            return f"{float(value):.2f}"
-        elif cell_type == ColumnType.DECIMAL_3:
-            return f"{float(value):.3f}"
+        elif cell_type == ColumnType.NUMBER_1:
+            return f"{float(value):,.1f}"
+        elif cell_type == ColumnType.NUMBER_2:
+            return f"{float(value):,.2f}"
+        elif cell_type == ColumnType.NUMBER_3:
+            return f"{float(value):,.3f}"
 
         return str(value)
 

django_spire/metric/report/tools.py

@@ -4,8 +4,20 @@ from django_spire.metric.report.enums import ColumnType
 
 
 def get_text_alignment_css_class(column_type: ColumnType) -> str:
-    if column_type in (ColumnType.DOLLAR, ColumnType.NUMBER, ColumnType.PERCENT, ColumnType.DECIMAL_1,
-                     ColumnType.DECIMAL_2, ColumnType.DECIMAL_3):
+    if column_type in (
+            ColumnType.DOLLAR,
+            ColumnType.DOLLAR_1,
+            ColumnType.DOLLAR_2,
+            ColumnType.DOLLAR_3,
+            ColumnType.PERCENT,
+            ColumnType.PERCENT_1,
+            ColumnType.PERCENT_2,
+            ColumnType.PERCENT_3,
+            ColumnType.NUMBER,
+            ColumnType.NUMBER_1,
+            ColumnType.NUMBER_2,
+            ColumnType.NUMBER_3
+    ):
         return 'text-end'
     if column_type == ColumnType.CHOICE:
         return 'text-center'

django_spire/testing/playwright/fixtures.py

@@ -5,16 +5,11 @@ import pytest
 
 from typing import Any, TYPE_CHECKING
 
-from django.contrib.auth import get_user_model
-
 if TYPE_CHECKING:
     from playwright.sync_api import Page
     from pytest_django.plugin import _LiveServer
 
 
-User = get_user_model()
-
-
 def pytest_configure(config: Any) -> None:
     os.environ['DJANGO_ALLOW_ASYNC_UNSAFE'] = 'true'
 
@@ -38,6 +33,10 @@ def browser_type_launch_args(browser_type_launch_args: dict[str, Any]) -> dict[s
 
 @pytest.fixture
 def authenticated_page(page: Page, live_server: _LiveServer, transactional_db: None) -> Page:
+    from django.contrib.auth import get_user_model
+
+    User = get_user_model()
+
     User.objects.create_user(
         username='testuser',
         password='testpass123',

{django_spire-0.25.1.dist-info → django_spire-0.25.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-spire
-Version: 0.25.1
+Version: 0.25.2
 Summary: A project for Django Spire
 Author-email: Brayden Carlson <braydenc@stratusadv.com>, Nathan Johnson <nathanj@stratusadv.com>
 License: Copyright (c) 2025 Stratus Advanced Technologies and Contributors.