django-spire 0.21.1__py3-none-any.whl → 0.22.1__py3-none-any.whl

django_spire/consts.py

@@ -1,4 +1,4 @@
-__VERSION__ = '0.21.1'
+__VERSION__ = '0.22.1'
 
 MAINTENANCE_MODE_SETTINGS_NAME = 'MAINTENANCE_MODE'
 

django_spire/contrib/generic_views/portal_views.py

@@ -270,6 +270,49 @@ def model_form_view(
     )
 
 
+def table_view(
+    request: WSGIRequest,
+    *,
+    queryset: QuerySet,
+    queryset_name: str,
+    template: str,
+    context_data: dict[str, Any] | None = None
+) -> TemplateResponse:
+    if context_data is None:
+        context_data = {}
+
+    default_batch_size = 25
+
+    page = int(request.GET.get('page', 1))
+
+    batch_size = (
+        context_data.get('batch_size')
+        if 'batch_size' in context_data
+        else request.GET.get('batch_size', default_batch_size)
+    )
+
+    batch_size = int(batch_size)
+    offset = (page - 1) * batch_size
+
+    total_count = queryset.count()
+    object_list = queryset[offset:offset + batch_size]
+    has_next = offset + batch_size < total_count
+
+    base_context_data = {
+        queryset_name: object_list,
+        'has_next': has_next,
+        'total_count': total_count,
+    }
+
+    context_data.update(base_context_data)
+
+    return TemplateResponse(
+        request,
+        context=context_data,
+        template=template
+    )
+
+
 def template_view(
     request: WSGIRequest,
     page_title: str,

django_spire/core/models.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+# These imports are for the migrations to work as a single app "django_spire_core"
+
+from django_spire.core.tag import models
+
+# Must assert to stop unused import removals.
+
+assert models

django_spire/core/static/django_spire/css/bootstrap-extension.css

@@ -378,6 +378,47 @@ h1, h2, h3, h4, h5, h6 {
     transform: translateX(0);
 }
 
+.skeleton-box {
+    background: linear-gradient(
+        90deg,
+        rgba(var(--bs-secondary-rgb), 0.1) 0%,
+        rgba(var(--bs-secondary-rgb), 0.2) 50%,
+        rgba(var(--bs-secondary-rgb), 0.1) 100%
+    );
+    background-size: 200% 100%;
+    animation: skeleton-loading 1.5s ease-in-out infinite;
+    border-radius: 4px;
+    display: inline-block;
+}
+
+@keyframes skeleton-loading {
+    0% {
+        background-position: 200% 0;
+    }
+    100% {
+        background-position: -200% 0;
+    }
+}
+
+.skeleton-row {
+    pointer-events: none;
+    user-select: none;
+}
+
+.table tbody {
+    transition: opacity 0.15s ease-in-out;
+}
+
+.table-fixed {
+    table-layout: fixed;
+}
+
+.table-fixed th,
+.table-fixed td {
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
 .text-200 {
     font-weight: 200 !important;
 }

django_spire/core/static/django_spire/css/bootstrap-override.css

@@ -135,11 +135,11 @@
     --bs-popover-header-bg: var(--app-layer-two);
     --bs-popover-header-color: var(--app-default-text-color);
 
-    --bs-table-bg: transparent;
-    --bs-table-border-color: var(--app-layer-three);
+    --bs-table-bg: var(--app-table-row-color);
+    --bs-table-border-color: var(--bs-border-color);
     --bs-table-color: var(--app-default-text-color);
-    --bs-table-hover-bg: var(--app-layer-two);
-    --bs-table-striped-bg: var(--app-layer-two);
+    --bs-table-hover-bg: var(--app-table-row-hover-color);
+    --bs-table-striped-bg: var(--app-table-row-alt-color);
 
     --bs-tooltip-bg: var(--app-dark);
     --bs-tooltip-color: var(--app-light);
@@ -263,6 +263,30 @@
     background-color: var(--app-primary);
 }
 
+.table > :not(caption) > * > * {
+    color: var(--app-default-text-color);
+}
+
+.table-striped tbody tr:nth-of-type(4n+1),
+.table-striped tbody tr:nth-of-type(4n+2) {
+    --bs-table-bg-type: var(--app-table-row-alt-color);
+    background-color: var(--app-table-row-alt-color);
+    color: var(--app-default-text-color);
+}
+
+.table-striped tbody tr:nth-of-type(4n+3),
+.table-striped tbody tr:nth-of-type(4n+4) {
+    --bs-table-bg-type: color-mix(in srgb, var(--app-secondary) 10%, transparent);
+    background-color: color-mix(in srgb, var(--app-secondary) 10%, transparent);
+    color: var(--app-default-text-color);
+}
+
+.table-hover > tbody > tr:hover > * {
+    --bs-table-bg-state: var(--app-table-row-hover-color);
+    background-color: var(--app-table-row-hover-color);
+    color: var(--app-default-text-color);
+}
+
 .ce-block__content [data-placeholder]:empty::before,
 .ce-block__content [data-placeholder][data-empty="true"]::before {
     color: var(--app-primary) !important;

django_spire/core/{tags → tag}/intelligence/tag_set_bot.py

@@ -13,10 +13,11 @@ class TagSetBot(Bot):
         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.',
+            'Include tags that help searchability.',
+            '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 common acronyms in addition to the tags.',
         ])
     )
 

django_spire/core/tag/mixins.py

@@ -0,0 +1,23 @@
+from django.db import models
+
+from django_spire.core.tag.models import Tag
+from django_spire.core.tag.tools import simplify_and_weight_tag_set_to_dict, simplify_tag_set
+
+
+class TagModelMixin(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 simplified_tag_set(self) -> set[str]:
+        return simplify_tag_set(self.tag_set)
+
+    @property
+    def simplified_and_weighted_tag_dict(self) -> dict[str, int]:
+        return simplify_and_weight_tag_set_to_dict(self.tag_set)

django_spire/core/{tags → tag}/models.py

@@ -3,7 +3,7 @@ from typing import Sequence, Self
 from django.db import models
 from django.utils.text import slugify
 
-from django_spire.core.tags.querysets import TagQuerySet
+from django_spire.core.tag.querysets import TagQuerySet
 
 
 class Tag(models.Model):
@@ -35,4 +35,3 @@ class Tag(models.Model):
         db_table = 'django_spire_core_tag'
         verbose_name = 'Tag'
         verbose_name_plural = 'Tags'
-

django_spire/core/tag/service/tag_service.py

@@ -0,0 +1,72 @@
+from abc import abstractmethod, ABC
+from typing import Generic
+
+from django.db.models import QuerySet
+
+from django_spire.contrib.constructor.django_model_constructor import TypeDjangoModel
+from django_spire.contrib.service import BaseDjangoModelService
+from django_spire.core.tag import tools
+from django_spire.core.tag.models import Tag
+from django_spire.core.tag.tools import get_score_percentage_from_tag_set_weighted
+
+
+class BaseTagService(
+    BaseDjangoModelService[TypeDjangoModel],
+    ABC,
+    Generic[TypeDjangoModel]
+):
+    obj: TypeDjangoModel
+
+    @abstractmethod
+    def process_and_set_tags(self):
+        raise NotImplementedError
+
+    def add_tags_from_tag_set(self, tag_set: set[str]):
+        self._update_global_tags_from_set(tag_set)
+
+        self.obj.tags.add(*Tag.objects.in_tag_set(tag_set))
+
+    def clear_tags(self):
+        self.obj.tags.clear()
+
+    def get_matching_tags_from_tag_set(self, tag_set: set[str]) -> QuerySet:
+        return self.obj.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.obj.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.obj.tag_set)
+
+    def get_score_percentage_from_tag_set_weighted(self, tag_set: set[str]) -> float:
+        return get_score_percentage_from_tag_set_weighted(
+            tag_set_actual=tag_set,
+            tag_set_reference=self.obj.tag_set
+        )
+
+    def get_simplified_and_weighted_tag_dict_above_minimum(self, minimum_weight: int = 1) -> dict[str, int]:
+        above_minimum_tag_dict = self.obj.simplified_and_weighted_tag_dict
+
+        return {
+            tag: weight
+            for tag, weight in above_minimum_tag_dict.items()
+            if weight >= minimum_weight
+        }
+
+    def has_tags_in_tag_set(self, tag_set: set[str]) -> bool:
+        return self.obj.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.obj.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.obj.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/core/{tags → tag}/tests/test_intelligence.py

@@ -1,6 +1,6 @@
 from unittest import TestCase
 
-from django_spire.core.tags.intelligence.tag_set_bot import TagSetBot
+from django_spire.core.tag.intelligence.tag_set_bot import TagSetBot
 
 TEST_INPUT = """
     I love reading books about science fiction, fantasy, and adventure, especially ones

django_spire/core/tag/tests/test_tags.py

@@ -0,0 +1,102 @@
+from django.test import TestCase
+
+from django_spire.core.tag.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.services.tag.add_tags_from_tag_set(self.tag_set_a)
+        self.collection.services.tag.add_tags_from_tag_set(self.tag_set_b)
+        self.collection.services.tag.add_tags_from_tag_set(self.tag_set_c)
+
+        self.collection.services.tag.add_tags_from_tag_set(self.mixed_tag_set)
+
+        self.collection.services.tag.add_tags_from_tag_set(self.dirty_tag_set)
+
+    def test_tag_removal(self):
+        self.assertIn('apple', self.collection.tag_set)
+
+        self.collection.services.tag.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.services.tag.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.services.tag.remove_tags_by_tag_set(self.tag_set_a)
+
+        self.assertEqual(self.collection.tags.count(), 9)
+
+    def test_tag_bool_methods(self):
+        self.collection.services.tag.remove_tags_by_tag_set(self.tag_set_b)
+
+        self.assertTrue(self.collection.services.tag.has_tags_in_tag_set(self.tag_set_c))
+        self.assertFalse(self.collection.services.tag.has_tags_in_tag_set(self.mixed_tag_set))
+
+    def test_tag_matching_methods(self):
+        self.assertEqual(len(self.collection.services.tag.get_matching_tags_from_tag_set(self.tag_set_a)), 3)
+
+        self.collection.services.tag.remove_tags_by_tag_set(self.tag_set_a)
+
+        self.assertEqual(len(self.collection.services.tag.get_matching_tags_from_tag_set(self.tag_set_a)), 0)
+        self.assertEqual(len(self.collection.services.tag.get_matching_tags_from_tag_set(self.tag_set_b)), 3)
+        self.assertEqual(len(self.collection.services.tag.get_matching_tags_from_tag_set(self.mixed_tag_set)), 2)
+
+        self.collection.services.tag.remove_tags_by_tag_set(self.tag_set_b)
+
+        self.assertEqual(len(self.collection.services.tag.get_matching_tags_from_tag_set(self.tag_set_b)), 0)
+
+        self.assertEqual(len(self.collection.services.tag.get_matching_tags_from_tag_set(self.mixed_tag_set)), 1)
+
+    def test_tag_metric_methods(self):
+        self.assertAlmostEqual(
+            self.collection.services.tag.get_matching_percentage_of_tag_set(self.tag_set_a),
+            1.00,
+            2
+        )
+
+        self.assertAlmostEqual(
+            self.collection.services.tag.get_matching_percentage_of_model_tags_from_tag_set(self.tag_set_b),
+            0.25,
+            2
+        )
+
+        self.collection.services.tag.remove_tags_by_tag_set(self.mixed_tag_set)
+
+        self.assertAlmostEqual(
+            self.collection.services.tag.get_matching_percentage_of_tag_set(self.tag_set_a),
+            0.666,
+            2
+        )
+
+
+        self.assertAlmostEqual(
+            self.collection.services.tag.get_matching_percentage_of_model_tags_from_tag_set(self.tag_set_b),
+            0.222,
+            2
+        )
+

django_spire/core/tag/tools.py

@@ -0,0 +1,66 @@
+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
+
+
+def get_score_percentage_from_tag_set_weighted(tag_set_actual: set[str], tag_set_reference: set[str]) -> float:
+    total_points = len(simplify_tag_set(tag_set_reference))
+
+    multiplier = get_matching_count_from_tag_sets(tag_set_actual, tag_set_reference)
+
+    weighted_points = sum(
+        weight
+        for tag, weight in simplify_and_weight_tag_set_to_dict(tag_set_reference).items()
+        if tag in tag_set_actual
+    )
+
+    if weighted_points == 0 or total_points == 0:
+        return 0.0
+
+    return (weighted_points / total_points) * multiplier
+
+
+def simplify_tag_set(tag_set: set[str]) -> set[str]:
+    return set(simplify_tag_set_to_list(tag_set))
+
+
+def simplify_tag_set_to_list(tag_set: set[str]) -> list[str]:
+    simplified_tag_words = []
+
+    for tag in tag_set:
+        tag_words = tag.split('-')
+        simplified_tag_words.extend(tag_words)
+
+    return simplified_tag_words
+
+
+def simplify_and_weight_tag_set_to_dict(tag_set: set[str]) -> dict[str, int]:
+    simplified_and_weighted_tag_words = {}
+
+    for tag_word in simplify_tag_set_to_list(tag_set):
+        simplified_and_weighted_tag_words[tag_word] = simplified_and_weighted_tag_words.get(tag_word, 0) + 1
+
+    return dict(
+        sorted(
+            simplified_and_weighted_tag_words.items(),
+            key=lambda item: item[1],
+            reverse=True
+        )
+    )

django_spire/core/templates/django_spire/dropdown/ellipsis_table_dropdown.html

@@ -0,0 +1,26 @@
+{% extends 'django_spire/dropdown/dropdown.html' %}
+
+{% block dropdown_position %}start-0 top-100{% endblock %}
+
+{% block dropdown_trigger %}
+    <span
+        class="bi bi-three-dots-vertical px-1 {% block ellipsis_class %}{% endblock %}"
+        style="overflow: visible;"
+        x-bind="trigger"
+    >
+    </span>
+{% endblock %}
+
+{% block dropdown_content %}
+    {% if view_url %}
+        {% include 'django_spire/dropdown/element/ellipsis_dropdown_modal_link_element.html' with view_url=view_url link_text='View' %}
+    {% endif %}
+
+    {% if edit_url %}
+        {% include 'django_spire/dropdown/element/ellipsis_dropdown_modal_link_element.html' with view_url=edit_url link_text='Edit' %}
+    {% endif %}
+
+    {% if delete_url %}
+        {% include 'django_spire/dropdown/element/ellipsis_dropdown_modal_link_element.html' with view_url=delete_url link_text='Delete' link_css='text-app-danger' %}
+    {% endif %}
+{% endblock %}

django_spire/core/templates/django_spire/filtering/form/base_session_filter_form.html

@@ -1,7 +1,7 @@
 <form
-        method="get"
-        action="{% block session_filter_url %}{% endblock %}"
-        class="row border-bottom"
+    method="get"
+    action="{% block session_filter_url %}{% endblock %}"
+    class="row border-bottom"
 >
     <div class="col-12">
         <input type="text" hidden value="{% block session_filter_key %}{% endblock %}" name="session_filter_key">
@@ -9,7 +9,7 @@
         {% block filter_content %}{% endblock %}
 
         {% block filter_buttons %}
-            <div class="py-2">
+            <div class="pt-2 pb-5">
                 <input
                     type="submit"
                     name="action"

django_spire/core/templates/django_spire/modal/content/dispatch_modal_delete_confirmation_content.html

@@ -1,7 +1,7 @@
 {% extends 'django_spire/modal/content/modal_title_content.html' %}
 
 {% block modal_content_title %}
-	{{ form_title }}
+	{{ form_title|truncatechars:75 }}
 {% endblock %}
 
 {% block modal_content_content %}
@@ -16,14 +16,16 @@
         }"
     >
         {% csrf_token %}
+
         {{ form_description }}
 
         {% include 'django_glue/form/field/input_field.html' with glue_field='should_delete' %}
 
         <div class="d-flex mt-3">
-            {% include 'django_spire/contrib/form/button/form_submit_button.html' with button_text='Delete' button_class='btn-app-danger btn-sm shadow-sm' %}
-            <span class="ms-2" @click="close_modal()" >
-                {% include 'django_spire/button/secondary_button.html' with button_text='Cancel' %}
+            {% include 'django_spire/contrib/form/button/form_submit_button.html' with button_text='Delete' button_class='btn-app-danger shadow-sm' %}
+
+            <span class="ms-2" @click="close_modal()">
+                {% include 'django_spire/button/secondary_button.html' with button_text='Cancel' button_class='btn' %}
             </span>
         </div>
     </form>