django-spire 0.23.4__py3-none-any.whl

django_spire/core/static/django_spire/js/theme.js

@@ -0,0 +1,262 @@
+document.addEventListener('alpine:init', () => {
+    Alpine.store('theme', {
+        config: null,
+        current: window.django_spire?.theme?.active || 'default-light',
+        loading_config: false,
+
+        async load_config() {
+            if (this.config || this.loading_config) {
+                return this.config;
+            }
+
+            this.loading_config = true;
+
+            try {
+                let response = await ajax_request(
+                    'GET',
+                    '/django_spire/theme/json/get_config/'
+                );
+
+                if (response && response.data) {
+                    this.config = response.data.data;
+                }
+            } catch (error) {
+                console.error('Failed to load theme config:', error);
+            }
+
+            this.loading_config = false;
+            return this.config;
+        },
+
+        parse(value) {
+            let parts = value.split('-');
+            let mode = parts.pop();
+            let family = parts.join('-');
+            return { family, mode };
+        },
+
+        build(family, mode) {
+            return `${family}-${mode}`;
+        },
+
+        get_family_display_name(family) {
+            if (this.config && this.config.families && this.config.families[family]) {
+                return this.config.families[family].name;
+            }
+
+            return family;
+        },
+
+        get_current_theme() {
+            let { family, mode } = this.parse(this.current);
+            let path = window.django_spire?.theme?.path || '/static/django_spire/css/themes/{family}/app-{mode}.css';
+            let family_name = this.get_family_display_name(family);
+
+            return {
+                family: family,
+                family_name: family_name,
+                mode: mode,
+                value: this.build(family, mode),
+                display: `${family_name} - ${mode.charAt(0).toUpperCase() + mode.slice(1)}`,
+                is_dark: mode === 'dark',
+                stylesheet: path.replace('{family}', family).replace('{mode}', mode)
+            };
+        },
+
+        get_current_display_name() {
+            let { family, mode } = this.parse(this.current);
+            let family_name = this.get_family_display_name(family);
+            return `${family_name} - ${mode.charAt(0).toUpperCase() + mode.slice(1)}`;
+        },
+
+        get_current_family_name() {
+            let { family } = this.parse(this.current);
+            return family;
+        },
+
+        async families() {
+            let config = await this.load_config();
+
+            if (!config || !config.families) {
+                return [];
+            }
+
+            return Object.entries(config.families).map(([key, value]) => ({
+                value: key,
+                name: value.name
+            }));
+        },
+
+        apply() {
+            let theme = this.get_current_theme();
+
+            if (theme.is_dark) {
+                document.documentElement.setAttribute('data-theme', 'dark');
+            } else {
+                document.documentElement.removeAttribute('data-theme');
+            }
+
+            document.documentElement.setAttribute('data-theme-family', theme.family);
+            this.load_theme_css(theme.family, theme.mode);
+
+            if (window.django_spire && window.django_spire.theme) {
+                window.django_spire.theme.active = theme.value;
+            }
+
+            if (!document.querySelector('link[data-input-css]')) {
+                let link = document.createElement('link');
+                link.rel = 'stylesheet';
+                link.href = '/static/django_spire/css/themes/input.css';
+                link.setAttribute('data-input-css', 'true');
+
+                document.head.appendChild(link);
+            }
+
+            setTimeout(() => this.apply_input_icon_theme(), 100);
+        },
+
+        apply_input_icon_theme() {
+            // This is a fix for a Chromium-based browser. We have to dynamically
+            // target the input field icon, otherwise it won't be styled properly.
+
+            let text_color = getComputedStyle(document.documentElement).getPropertyValue('--app-default-text-color').trim();
+
+            if (!text_color) return;
+
+            let hex = text_color.replace('#', '%23');
+            let style_id = 'calendar-icon-theme';
+            let existing = document.getElementById(style_id);
+
+            if (existing) {
+                existing.remove();
+            }
+
+            let calendar_svg = `data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="none" stroke="${hex}" stroke-width="1.5" viewBox="0 0 16 16"><rect x="2" y="3" width="12" height="11" rx="1"/><path d="M2 6h12M5 1v3M11 1v3"/><circle cx="5" cy="9" r="0.5" fill="${hex}"/><circle cx="8" cy="9" r="0.5" fill="${hex}"/><circle cx="11" cy="9" r="0.5" fill="${hex}"/><circle cx="5" cy="12" r="0.5" fill="${hex}"/><circle cx="8" cy="12" r="0.5" fill="${hex}"/><circle cx="11" cy="12" r="0.5" fill="${hex}"/></svg>`;
+            let clock_svg = `data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="${hex}"><path d="M8 3.5a.5.5 0 0 0-1 0V9a.5.5 0 0 0 .252.434l3.5 2a.5.5 0 0 0 .496-.868L8 8.71V3.5z"/><path d="M8 16A8 8 0 1 0 8 0a8 8 0 0 0 0 16zm7-8A7 7 0 1 1 1 8a7 7 0 0 1 14 0z"/></svg>`;
+
+            let style = document.createElement('style');
+            style.id = style_id;
+
+            style.textContent = `
+                input[type="datetime-local"]::-webkit-calendar-picker-indicator,
+                input[type="date"]::-webkit-calendar-picker-indicator,
+                input[type="week"]::-webkit-calendar-picker-indicator,
+                input[type="month"]::-webkit-calendar-picker-indicator {
+                    background-image: url('${calendar_svg}');
+                }
+
+                input[type="time"]::-webkit-calendar-picker-indicator {
+                    background-image: url('${clock_svg}');
+                }
+            `;
+            document.head.appendChild(style);
+        },
+
+        load_theme_css(family, mode) {
+            let existing = document.querySelector('link[data-theme-css]');
+            let path = window.django_spire?.theme?.path;
+
+            if (!path) {
+                console.error('Theme path is not defined');
+                return;
+            }
+
+            if (!family || !mode) {
+                console.error('Missing family or mode:', family, mode);
+                return;
+            }
+
+            let href = path.replace('{family}', family).replace('{mode}', mode);
+            let absolute = new URL(href, window.location).href;
+
+            if (existing && existing.href === absolute) {
+                return;
+            }
+
+            let link = document.createElement('link');
+            link.rel = 'stylesheet';
+            link.href = href;
+            link.setAttribute('data-theme-css', 'true');
+
+            link.onload = () => {
+                if (existing) {
+                    existing.remove();
+                }
+
+                this.apply_input_icon_theme();
+
+                let theme = this.get_current_theme();
+                window.dispatchEvent(new CustomEvent('theme-changed', { detail: theme }));
+            };
+
+            document.head.appendChild(link);
+        },
+
+        async persist_to_server(value) {
+            await ajax_request(
+                'POST',
+                '/django_spire/theme/json/set_theme/',
+                { theme: value }
+            );
+        },
+
+        async set(value) {
+            this.current = value;
+            this.apply();
+
+            await this.persist_to_server(value);
+        },
+
+        async set_family(family) {
+            let { mode } = this.parse(this.current);
+            let config = await this.load_config();
+
+            if (config && config.families && config.families[family]) {
+                if (!config.families[family].modes.includes(mode)) {
+                    mode = config.families[family].modes[0];
+                }
+            }
+
+            await this.set(this.build(family, mode));
+        },
+
+        async toggle() {
+            let { family, mode } = this.parse(this.current);
+            let newmode = mode === 'dark' ? 'light' : 'dark';
+            await this.set(this.build(family, newmode));
+        },
+
+        is_family(family) {
+            let { family: current } = this.parse(this.current);
+            return current === family;
+        },
+
+        is_mode(mode) {
+            let { mode: current } = this.parse(this.current);
+            return current === mode;
+        },
+
+        init() {
+            this.apply();
+        }
+    });
+});
+
+window.get_echarts_theme = function() {
+    let styles = getComputedStyle(document.documentElement);
+    let is_dark = document.documentElement.getAttribute('data-theme') === 'dark';
+
+    return {
+        text: styles.getPropertyValue('--app-default-text-color').trim(),
+        primary: styles.getPropertyValue('--app-primary').trim(),
+        primary_dark: styles.getPropertyValue('--app-primary-dark').trim(),
+        secondary: styles.getPropertyValue('--app-secondary').trim(),
+        secondary_dark: styles.getPropertyValue('--app-secondary-dark').trim(),
+        border: styles.getPropertyValue('--bs-border-color').trim(),
+        bg: styles.getPropertyValue('--app-layer-one').trim(),
+        layer_two: styles.getPropertyValue('--app-layer-two').trim(),
+        layer_three: styles.getPropertyValue('--app-layer-three').trim(),
+        layer_four: styles.getPropertyValue('--app-layer-four').trim(),
+        is_dark: is_dark,
+    };
+};

django_spire/core/static/django_spire/js/ui.js

@@ -0,0 +1,24 @@
+function toggle_loading_overlay() {
+    let body = document.body;
+    let spinner = document.getElementById('loading-icon');
+
+    if (body.classList.contains('darken-background')) {
+        body.classList.remove('darken-background');
+        spinner.classList.add('d-none');
+    } else {
+        body.classList.add('darken-background');
+        spinner.classList.remove('d-none');
+    }
+}
+
+function has_content(el) {
+    return Array.from(el.childNodes).some(
+        node => {
+            if (node.nodeType === Node.TEXT_NODE) {
+                return node.textContent.trim() !== '';
+            }
+            return node.nodeType === Node.ELEMENT_NODE;
+
+        }
+    )
+}

django_spire/core/table/enums.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from enum import StrEnum
+
+
+class ResponsiveMode(StrEnum):
+    """
+    It defines how tables handle responsive behavior at different viewport sizes.
+
+    Collapse: Any columns with breakpoint attributes are hidden at smaller viewports
+        and shown at their specified breakpoint.
+
+    Scroll: All columns remain visible regardless of viewport size. The table
+        container enables horizontal scrolling to accommodate the full width.
+    """
+
+    COLLAPSE = 'collapse'
+    SCROLL = 'scroll'

django_spire/core/tag/intelligence/tag_set_bot.py

@@ -0,0 +1,42 @@
+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.',
+            '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.',
+        ])
+    )
+
+    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/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/tag/models.py

@@ -0,0 +1,37 @@
+from typing import Sequence, Self
+
+from django.db import models
+from django.utils.text import slugify
+
+from django_spire.core.tag.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/core/tag/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/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/tag/tests/test_intelligence.py

@@ -0,0 +1,28 @@
+from unittest import TestCase
+
+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
+    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/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
+        )
+