django-spire 0.17.11__py3-none-any.whl → 0.18.0__py3-none-any.whl

django_spire/consts.py

@@ -1,4 +1,4 @@
-__VERSION__ = '0.17.11'
+__VERSION__ = '0.18.0'
 
 
 AI_CHAT_WORKFLOW_SENDER_SETTINGS_NAME = 'AI_CHAT_WORKFLOW_NAME'

django_spire/contrib/seeding/model/base.py

@@ -2,7 +2,7 @@ from abc import ABC, abstractmethod
 
 from dandy.recorder import recorder_to_html_file
 from dandy import SqliteCache
-from dandy import generate_cache_key
+from dandy.cache.tools import generate_cache_key
 
 from django_spire.contrib.seeding.field.override import FieldOverride
 from django_spire.contrib.seeding.model.config import FieldsConfig

django_spire/knowledge/entry/services/automation_service.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import traceback
 from typing import TYPE_CHECKING
 
 import json
@@ -34,15 +35,17 @@ class EntryAutomationService(BaseDjangoModelService['Entry']):
                     entry_version=entry_pk_map[file_object.object_id].current_version,
                 )
             except Exception as e:
-                errored.append({'file': file_object.name, 'error': str(e)})
+                errored.append({'file': file_object.name, 'error': traceback.format_exc()})
                 file_object.set_deleted()
             else:
                 file_object.set_deleted()
 
         message = f'Files Converted: {len(file_objects) - len(errored)}'
         if errored:
-            raise KnowledgeBaseConversionException(
-                f'\n{message}\nFiles Errored: {json.dumps(errored, indent=4)}'
-            )
+            error_string = f'\n{message}\nFiles Errored:'
+            for error in errored:
+                error_string += f'    File Name: {error["file"]}\n    Error: {error["error"]}'
+
+            raise KnowledgeBaseConversionException(error_string)
 
         return message

django_spire/knowledge/entry/services/transformation_services.py

@@ -72,9 +72,9 @@ class EntryTransformationService(BaseDjangoModelService['Entry']):
             'edit_version_url': f'''
                 {site}{
                     reverse(
-                        'django_spire:knowledge:entry:version:form:update',
+                        'django_spire:knowledge:entry:version:page:detail',
                         kwargs={'pk': current_version.pk},
                     )
-                }
+                }?view_mode=edit
             '''
         }

django_spire/knowledge/entry/version/block/choices.py

@@ -4,5 +4,4 @@ from django.db.models import TextChoices
 class BlockTypeChoices(TextChoices):
     TEXT = 'text'
     HEADING = 'heading'
-    SUB_HEADING = 'sub_heading'
-    LIST_ITEM = 'list_item'
+    LIST = 'list'

django_spire/knowledge/entry/version/block/data/data.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class BaseEditorBlockData(BaseModel):
+    """
+    This class serves as a foundational abstract model for EditorJS tool data objects.
+
+    Note that it does not represent the top level editor block itself,
+    but rather the data that is stored within it.
+    See https://editorjs.io/getting-started/#tools-installation for a
+    list of EditorJS and their associated data models.
+    """
+
+    def render_to_text(self) -> str:
+        """
+        Renders the content to text format.
+
+        This method should be implemented in a subclass to define how the
+        content will be rendered into a string. It is meant to be overridden and
+        raises a NotImplementedError by default.
+
+        This method is mainly used for providing knowledge base
+        content in a digestible format for the AI Chat's LLM connector.
+
+        Returns:
+            str: The rendered text output.
+
+        Raises:
+            NotImplementedError: If the method is not implemented in a subclass.
+        """
+        raise NotImplementedError

django_spire/knowledge/entry/version/block/data/heading_data.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from django_spire.knowledge.entry.version.block.data.data import BaseEditorBlockData
+
+
+class HeadingEditorBlockData(BaseEditorBlockData):
+    text: str
+    level: int
+
+    def render_to_text(self) -> str:
+        from django_spire.knowledge.entry.version.converters.markdown_converter import \
+            MarkdownConverter
+
+        text = MarkdownConverter.html_to_markdown(self.text)
+        return f'{"#" * self.level} {text}\n'

django_spire/knowledge/entry/version/block/data/list/choices.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from django.db.models import TextChoices
+
+
+class ListEditorBlockDataStyle(TextChoices):
+    UNORDERED = 'unordered'
+    ORDERED = 'ordered'
+    CHECKLIST = 'checklist'
+
+
+class OrderedListCounterType(TextChoices):
+    NUMERIC = 'numeric'
+    UPPER_ROMAN = 'upper-roman'
+    LOWER_ROMAN = 'lower-roman'
+    UPPER_ALPHA = 'upper-alpha'
+    LOWER_ALPHA = 'lower-alpha'

django_spire/knowledge/entry/version/block/data/list/data.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from pydantic import model_validator, BaseModel
+
+from django_spire.knowledge.entry.version.block.constants import SPACES_PER_INDENT
+from django_spire.knowledge.entry.version.block.data.data import BaseEditorBlockData
+from django_spire.knowledge.entry.version.block.data.list.meta import ChecklistItemMeta, \
+    OrderedListItemMeta
+from django_spire.knowledge.entry.version.block.data.list.choices import \
+    ListEditorBlockDataStyle
+
+
+class ListEditorBlockData(BaseEditorBlockData):
+    style: ListEditorBlockDataStyle | str
+    meta: ChecklistItemMeta | OrderedListItemMeta | None = None
+    items: list[ListItemEditorBlockData]
+
+    def render_to_text(self) -> str:
+        render_string = ''
+        for i, item in enumerate(self.items):
+            render_string += item.render_to_text(self.style, 0, i)
+
+        return render_string
+
+    @model_validator(mode='before')
+    @classmethod
+    def validate_meta(cls, values: dict) -> dict:
+        values['style'] = ListEditorBlockDataStyle(values.get('style'))
+
+        if values['style'] == ListEditorBlockDataStyle.ORDERED and 'meta' in values:
+            values['meta'] = OrderedListItemMeta(**values['meta'])
+
+        for item in values['items']:
+            item = ListItemEditorBlockData.style_aware_create_from_dict(item, values['style'])
+
+        return values
+
+
+class ListItemEditorBlockData(BaseModel):
+    content: str
+    meta: ChecklistItemMeta | OrderedListItemMeta | dict | None = None
+    items: Optional[list[ListItemEditorBlockData]] = []
+
+    def get_prefix(
+            self,
+            style: ListEditorBlockDataStyle,
+            indent_level: int,
+            index = None
+    ):
+        prefix = ' ' * indent_level * SPACES_PER_INDENT
+
+        if style == ListEditorBlockDataStyle.ORDERED:
+            index = index or 0
+            start = self.meta.start or 1
+            prefix += f'{start + index}.'
+
+        elif style == ListEditorBlockDataStyle.CHECKLIST:
+            prefix += f'[{"X" if self.meta.checked else " "}]'
+
+        else:
+            prefix += '-'
+
+        return prefix
+
+    def render_to_text(
+        self,
+        style: ListEditorBlockDataStyle,
+        indent_level: int,
+        index: int
+    ) -> str:
+        from django_spire.knowledge.entry.version.converters.markdown_converter import \
+            MarkdownConverter
+
+        prefix = self.get_prefix(style, indent_level, index)
+        parsed_content = MarkdownConverter.html_to_markdown(self.content)
+        render_string = f'{prefix} {parsed_content}\n'
+        for i, item in enumerate(self.items):
+            render_string += item.render_to_text(style, indent_level + 1, i)
+
+        return render_string
+
+    @classmethod
+    def style_aware_create_from_dict(
+        cls,
+        values: dict,
+        style: ListEditorBlockDataStyle
+    ) -> ListItemEditorBlockData:
+        from django_spire.knowledge.entry.version.block.data.list.maps import \
+            LIST_BLOCK_DATA_META_MAP
+
+        if 'meta' in values:
+            meta_type = LIST_BLOCK_DATA_META_MAP[style]
+
+            if isinstance(values['meta'], dict):
+                values['meta'] = meta_type(**values['meta']) if meta_type else None
+
+        for item in values['items']:
+            item = ListItemEditorBlockData.style_aware_create_from_dict(item, style)
+
+        return ListItemEditorBlockData(**values)

django_spire/knowledge/entry/version/block/data/list/maps.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from django_spire.knowledge.entry.version.block.data.list import choices, meta
+
+LIST_BLOCK_DATA_META_MAP = {
+    choices.ListEditorBlockDataStyle.ORDERED: meta.OrderedListItemMeta,
+    choices.ListEditorBlockDataStyle.CHECKLIST: meta.ChecklistItemMeta,
+    choices.ListEditorBlockDataStyle.UNORDERED: None,
+}
+LIST_BLOCK_DATA_REVERSE_META_MAP = {
+    meta.OrderedListItemMeta: choices.ListEditorBlockDataStyle.ORDERED,
+    meta.ChecklistItemMeta: choices.ListEditorBlockDataStyle.CHECKLIST,
+    None: choices.ListEditorBlockDataStyle.UNORDERED,
+}

django_spire/knowledge/entry/version/block/data/list/meta.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from django_spire.knowledge.entry.version.block.data.list.choices import \
+    OrderedListCounterType
+
+
+class ChecklistItemMeta(BaseModel):
+    checked: bool = False
+
+
+class OrderedListItemMeta(BaseModel):
+    start: int | None = None
+    counterType: OrderedListCounterType | str | None = None

django_spire/knowledge/entry/version/block/data/maps.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from django_spire.knowledge.entry.version.block.choices import BlockTypeChoices
+from django_spire.knowledge.entry.version.block.data.heading_data import \
+    HeadingEditorBlockData
+from django_spire.knowledge.entry.version.block.data.list.data import \
+    ListEditorBlockData
+from django_spire.knowledge.entry.version.block.data.text_data import \
+    TextEditorBlockData
+
+
+EDITOR_BLOCK_DATA_MAP = {
+    BlockTypeChoices.TEXT: TextEditorBlockData,
+    BlockTypeChoices.HEADING: HeadingEditorBlockData,
+    BlockTypeChoices.LIST: ListEditorBlockData,
+}
+
+
+EDITOR_BLOCK_DATA_REVERSE_MAP = {
+    TextEditorBlockData: BlockTypeChoices.TEXT,
+    HeadingEditorBlockData: BlockTypeChoices.HEADING,
+    ListEditorBlockData: BlockTypeChoices.LIST
+}

django_spire/knowledge/entry/version/block/data/text_data.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from django_spire.knowledge.entry.version.block.data.data import BaseEditorBlockData
+
+
+class TextEditorBlockData(BaseEditorBlockData):
+    text: str
+
+    def render_to_text(self) -> str:
+        from django_spire.knowledge.entry.version.converters.markdown_converter import \
+            MarkdownConverter
+
+        return f'{MarkdownConverter.html_to_markdown(self.text)}\n'

django_spire/knowledge/entry/version/block/models.py

@@ -1,17 +1,17 @@
 from __future__ import annotations
 
 from django.db import models
-from django.forms import model_to_dict
-from django.template.loader import render_to_string
 
 from django_spire.contrib.ordering.mixins import OrderingModelMixin
 from django_spire.history.mixins import HistoryModelMixin
 from django_spire.knowledge.entry.version.block.choices import BlockTypeChoices
-from django_spire.knowledge.entry.version.block.maps import ENTRY_BLOCK_MAP
-from django_spire.knowledge.entry.version.block.services.service import EntryVersionBlockService
-from django_spire.knowledge.entry.version.block.blocks.block import BaseBlock
+from django_spire.knowledge.entry.version.block.data.data import BaseEditorBlockData
+from django_spire.knowledge.entry.version.block.data.maps import EDITOR_BLOCK_DATA_MAP
+from django_spire.knowledge.entry.version.block.querysets import \
+    EntryVersionBlockQuerySet
+from django_spire.knowledge.entry.version.block.services.service import \
+    EntryVersionBlockService
 from django_spire.knowledge.entry.version.models import EntryVersion
-from django_spire.knowledge.entry.version.block.querysets import EntryVersionBlockQuerySet
 
 
 class EntryVersionBlock(HistoryModelMixin, OrderingModelMixin):
@@ -21,29 +21,37 @@ class EntryVersionBlock(HistoryModelMixin, OrderingModelMixin):
         related_name='blocks',
         related_query_name='block'
     )
+
     type = models.CharField(
         max_length=32,
         choices=BlockTypeChoices,
         default=BlockTypeChoices.TEXT
     )
+
     _block_data = models.JSONField()
     _text_data = models.TextField()
 
+    # contains data related to EditorJS tunes,
+    # which are additional modifications to blocks (e.g. footnotes, etc.)
+    # https://editorjs.io/block-tunes-api/
+    _tunes_data = models.JSONField(null=True, blank=True)
+
     objects = EntryVersionBlockQuerySet.as_manager()
     services = EntryVersionBlockService()
 
     @property
-    def block(self) -> BaseBlock:
-        return ENTRY_BLOCK_MAP[self.type](**self._block_data)
-
-    @block.setter
-    def block(self, value: BaseBlock):
-        self.type = value.type
-        self._block_data = value.model_dump()
+    def editor_block_data(self) -> BaseEditorBlockData:
+        return EDITOR_BLOCK_DATA_MAP[self.type](**self._block_data)
+
+    @editor_block_data.setter
+    def editor_block_data(self, value: BaseEditorBlockData):
+        # exclude_none=True ensures that block meta objects aren't autofilled with keys,
+        # which can mess up editor rendering
+        self._block_data = value.model_dump(exclude_none=True)
         self._text_data = value.render_to_text()
 
     def render_to_text(self) -> str:
-        return self.block.render_to_text()
+        return self.editor_block_data.render_to_text()
 
     class Meta:
         verbose_name = 'Block'

django_spire/knowledge/entry/version/block/querysets.py

@@ -1,15 +1,25 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from django.db.models.functions import Coalesce
+from django.db.models import JSONField
 
 from django_spire.contrib.ordering.querysets import OrderingQuerySetMixin
 from django_spire.history.querysets import HistoryQuerySet
-
-if TYPE_CHECKING:
-    from django.db.models import QuerySet
-    from django_spire.knowledge.entry.version.block.models import EntryVersionBlock
+from django.db.models import Value
 
 
 class EntryVersionBlockQuerySet(HistoryQuerySet, OrderingQuerySetMixin):
-    def by_version_id(self, entry_version_id: int) -> QuerySet[EntryVersionBlock]:
-        return self.filter(version_id=entry_version_id)
+    def format_for_editor(self):
+        coalesce_json_field = lambda field_name: Coalesce(
+            field_name,
+            Value({}, output_field=JSONField())
+        )
+
+        return (
+            self.annotate(
+                data=coalesce_json_field('_block_data'),
+                tunes=coalesce_json_field('_tunes_data'),
+            )
+            .order_by('order')
+            .values('id', 'type', 'data', 'tunes')
+        )