notionary 0.2.28__py3-none-any.whl → 0.3.1__py3-none-any.whl

notionary/page/content/parser/parsers/numbered_list.py

@@ -6,13 +6,13 @@ from notionary.blocks.rich_text.markdown_rich_text_converter import (
 from notionary.blocks.schemas import (
     BlockColor,
     CreateNumberedListItemBlock,
-    NumberedListItemData,
+    CreateNumberedListItemData,
 )
 from notionary.page.content.parser.parsers.base import (
     BlockParsingContext,
     LineParser,
 )
-from notionary.page.content.syntax.service import SyntaxRegistry
+from notionary.page.content.syntax import SyntaxRegistry
 
 
 class NumberedListParser(LineParser):
@@ -25,21 +25,65 @@ class NumberedListParser(LineParser):
     def _can_handle(self, context: BlockParsingContext) -> bool:
         if context.is_inside_parent_context():
             return False
-        return self._syntax.regex_pattern.match(context.line) is not None
+        return self._is_numbered_list_line(context.line)
+
+    def _is_numbered_list_line(self, line: str) -> bool:
+        return self._syntax.regex_pattern.match(line) is not None
 
     @override
     async def _process(self, context: BlockParsingContext) -> None:
         block = await self._create_numbered_list_block(context.line)
-        if block:
-            context.result_blocks.append(block)
+        if not block:
+            return
+
+        await self._process_nested_children(block, context)
+        context.result_blocks.append(block)
+
+    async def _process_nested_children(self, block: CreateNumberedListItemBlock, context: BlockParsingContext) -> None:
+        child_lines = self._collect_child_lines(context)
+        if not child_lines:
+            return
+
+        child_blocks = await self._parse_child_blocks(child_lines, context)
+        if child_blocks:
+            block.numbered_list_item.children = child_blocks
+
+        context.lines_consumed = len(child_lines)
+
+    def _collect_child_lines(self, context: BlockParsingContext) -> list[str]:
+        parent_indent_level = context.get_line_indentation_level()
+        return context.collect_indented_child_lines(parent_indent_level)
+
+    async def _parse_child_blocks(
+        self, child_lines: list[str], context: BlockParsingContext
+    ) -> list[CreateNumberedListItemBlock]:
+        stripped_lines = self._remove_parent_indentation(child_lines, context)
+        children_text = self._convert_lines_to_text(stripped_lines)
+        return await context.parse_nested_markdown(children_text)
+
+    def _remove_parent_indentation(self, lines: list[str], context: BlockParsingContext) -> list[str]:
+        return context.strip_indentation_level(lines, levels=1)
+
+    def _convert_lines_to_text(self, lines: list[str]) -> str:
+        return "\n".join(lines)
 
     async def _create_numbered_list_block(self, text: str) -> CreateNumberedListItemBlock | None:
+        content = self._extract_list_content(text)
+        if content is None:
+            return None
+
+        rich_text = await self._convert_to_rich_text(content)
+        return self._build_block(rich_text)
+
+    def _extract_list_content(self, text: str) -> str | None:
         match = self._syntax.regex_pattern.match(text)
         if not match:
             return None
+        return match.group(3)
 
-        content = match.group(3)
-        rich_text = await self._rich_text_converter.to_rich_text(content)
+    async def _convert_to_rich_text(self, content: str):
+        return await self._rich_text_converter.to_rich_text(content)
 
-        numbered_list_content = NumberedListItemData(rich_text=rich_text, color=BlockColor.DEFAULT)
+    def _build_block(self, rich_text) -> CreateNumberedListItemBlock:
+        numbered_list_content = CreateNumberedListItemData(rich_text=rich_text, color=BlockColor.DEFAULT)
         return CreateNumberedListItemBlock(numbered_list_item=numbered_list_content)

notionary/page/content/parser/parsers/paragraph.py

@@ -1,9 +1,10 @@
 from typing import override
 
+from notionary.blocks.enums import BlockColor
 from notionary.blocks.rich_text.markdown_rich_text_converter import (
     MarkdownRichTextConverter,
 )
-from notionary.blocks.schemas import BlockColor, CreateParagraphBlock, ParagraphData
+from notionary.blocks.schemas import CreateParagraphBlock, CreateParagraphData
 from notionary.page.content.parser.parsers.base import (
     BlockParsingContext,
     LineParser,
@@ -32,5 +33,5 @@ class ParagraphParser(LineParser):
             return None
 
         rich_text = await self._rich_text_converter.to_rich_text(text)
-        paragraph_content = ParagraphData(rich_text=rich_text, color=BlockColor.DEFAULT)
+        paragraph_content = CreateParagraphData(rich_text=rich_text, color=BlockColor.DEFAULT)
         return CreateParagraphBlock(paragraph=paragraph_content)

notionary/page/content/parser/parsers/pdf.py

@@ -9,7 +9,7 @@ from notionary.blocks.schemas import (
     FileType,
 )
 from notionary.page.content.parser.parsers.base import BlockParsingContext, LineParser
-from notionary.page.content.syntax.service import SyntaxRegistry
+from notionary.page.content.syntax import SyntaxRegistry
 
 
 class PdfParser(LineParser):

notionary/page/content/parser/parsers/quote.py

@@ -6,7 +6,7 @@ from notionary.page.content.parser.parsers.base import (
     BlockParsingContext,
     LineParser,
 )
-from notionary.page.content.syntax.service import SyntaxRegistry
+from notionary.page.content.syntax import SyntaxRegistry
 
 
 class QuoteParser(LineParser):
@@ -21,15 +21,22 @@ class QuoteParser(LineParser):
             return False
         return self._is_quote(context.line)
 
+    def _is_quote(self, line: str) -> bool:
+        return self._syntax.regex_pattern.match(line) is not None
+
     @override
     async def _process(self, context: BlockParsingContext) -> None:
         quote_lines = self._collect_quote_lines(context)
-        lines_consumed = len(quote_lines)
 
         block = await self._create_quote_block(quote_lines)
-        if block:
-            context.result_blocks.append(block)
-            context.lines_consumed = lines_consumed
+        if not block:
+            return
+
+        # Lines consumed: all quote lines minus the current line (which is already being processed)
+        context.lines_consumed = len(quote_lines) - 1
+
+        await self._process_nested_children(block, context, quote_lines)
+        context.result_blocks.append(block)
 
     def _collect_quote_lines(self, context: BlockParsingContext) -> list[str]:
         quote_lines = [context.line]
@@ -39,27 +46,80 @@ class QuoteParser(LineParser):
             quote_lines.append(line)
         return quote_lines
 
-    def _is_quote(self, line: str) -> bool:
-        return self._syntax.regex_pattern.match(line) is not None
+    async def _process_nested_children(
+        self, block: CreateQuoteBlock, context: BlockParsingContext, quote_lines: list[str]
+    ) -> None:
+        # Calculate indent level after all quote lines
+        last_quote_line_index = len(quote_lines) - 1
+        child_lines = self._collect_child_lines_after_quote(context, last_quote_line_index)
+
+        if not child_lines:
+            return
+
+        child_blocks = await self._parse_child_blocks(child_lines, context)
+        if child_blocks:
+            block.quote.children = child_blocks
+
+        context.lines_consumed += len(child_lines)
+
+    def _collect_child_lines_after_quote(self, context: BlockParsingContext, last_quote_index: int) -> list[str]:
+        """Collect indented children after the quote block."""
+        parent_indent_level = context.get_line_indentation_level()
+        remaining_lines = context.get_remaining_lines()
+
+        # Skip the quote lines we already processed
+        lines_after_quote = remaining_lines[last_quote_index:]
+
+        child_lines = []
+        expected_child_indent = parent_indent_level + 1
+
+        for line in lines_after_quote:
+            if not line.strip():
+                child_lines.append(line)
+                continue
+
+            line_indent = context.get_line_indentation_level(line)
+            if line_indent >= expected_child_indent:
+                child_lines.append(line)
+            else:
+                break
+
+        return child_lines
+
+    async def _parse_child_blocks(self, child_lines: list[str], context: BlockParsingContext) -> list[CreateQuoteBlock]:
+        stripped_lines = self._remove_parent_indentation(child_lines, context)
+        children_text = self._convert_lines_to_text(stripped_lines)
+        return await context.parse_nested_markdown(children_text)
+
+    def _remove_parent_indentation(self, lines: list[str], context: BlockParsingContext) -> list[str]:
+        return context.strip_indentation_level(lines, levels=1)
+
+    def _convert_lines_to_text(self, lines: list[str]) -> str:
+        return "\n".join(lines)
 
     async def _create_quote_block(self, quote_lines: list[str]) -> CreateQuoteBlock | None:
-        if not quote_lines:
+        contents = self._extract_quote_contents(quote_lines)
+        if not contents:
             return None
 
+        content = self._join_contents_for_multiline_quote(contents)
+        rich_text = await self._convert_to_rich_text(content)
+        return self._build_block(rich_text)
+
+    def _extract_quote_contents(self, quote_lines: list[str]) -> list[str]:
         contents = []
         for line in quote_lines:
             match = self._syntax.regex_pattern.match(line)
             if match:
                 contents.append(match.group(1).strip())
+        return contents
 
-        if not contents:
-            return None
+    def _join_contents_for_multiline_quote(self, contents: list[str]) -> str:
+        return "\n".join(contents)
 
-        content = self._join_contents_for_multiline_quote(contents)
+    async def _convert_to_rich_text(self, content: str):
+        return await self._rich_text_converter.to_rich_text(content)
 
-        rich_text = await self._rich_text_converter.to_rich_text(content)
+    def _build_block(self, rich_text) -> CreateQuoteBlock:
         quote_data = CreateQuoteData(rich_text=rich_text, color=BlockColor.DEFAULT)
         return CreateQuoteBlock(quote=quote_data)
-
-    def _join_contents_for_multiline_quote(self, contents: list[str]) -> str:
-        return "\n".join(contents)

notionary/page/content/parser/parsers/space.py

@@ -1,19 +1,15 @@
 from typing import override
 
-from notionary.blocks.schemas import BlockColor, CreateParagraphBlock, ParagraphData
+from notionary.blocks.enums import BlockColor
+from notionary.blocks.schemas import CreateParagraphBlock, CreateParagraphData
 from notionary.page.content.parser.parsers.base import (
     BlockParsingContext,
     LineParser,
 )
-from notionary.page.content.syntax.service import SyntaxRegistry
+from notionary.page.content.syntax import SyntaxRegistry
 
 
 class SpaceParser(LineParser):
-    """
-    Parser for [space] markers that create empty paragraph blocks.
-    Uses SyntaxRegistry for centralized syntax definition.
-    """
-
     def __init__(self, syntax_registry: SyntaxRegistry) -> None:
         super().__init__(syntax_registry)
         self._syntax = syntax_registry.get_space_syntax()
@@ -22,8 +18,18 @@ class SpaceParser(LineParser):
     def _can_handle(self, context: BlockParsingContext) -> bool:
         if context.is_inside_parent_context():
             return False
+
+        if self._is_explicit_space_marker(context):
+            return True
+
+        return self._is_second_consecutive_empty_line(context)
+
+    def _is_explicit_space_marker(self, context: BlockParsingContext) -> bool:
         return self._syntax.regex_pattern.match(context.line.strip()) is not None
 
+    def _is_second_consecutive_empty_line(self, context: BlockParsingContext) -> bool:
+        return context.line.strip() == "" and context.is_previous_line_empty
+
     @override
     async def _process(self, context: BlockParsingContext) -> None:
         block = self._create_space_block()
@@ -31,5 +37,5 @@ class SpaceParser(LineParser):
             context.result_blocks.append(block)
 
     def _create_space_block(self) -> CreateParagraphBlock:
-        paragraph_data = ParagraphData(rich_text=[], color=BlockColor.DEFAULT)
+        paragraph_data = CreateParagraphData(rich_text=[], color=BlockColor.DEFAULT)
         return CreateParagraphBlock(paragraph=paragraph_data)

notionary/page/content/parser/parsers/table.py

@@ -4,7 +4,7 @@ from notionary.blocks.rich_text.markdown_rich_text_converter import MarkdownRich
 from notionary.blocks.rich_text.models import RichText
 from notionary.blocks.schemas import CreateTableBlock, CreateTableData, CreateTableRowBlock, TableRowData
 from notionary.page.content.parser.parsers import BlockParsingContext, LineParser
-from notionary.page.content.syntax.service import SyntaxRegistry
+from notionary.page.content.syntax import SyntaxRegistry
 
 
 class TableParser(LineParser):

notionary/page/content/parser/parsers/table_of_contents.py

@@ -5,7 +5,7 @@ from notionary.page.content.parser.parsers.base import (
     BlockParsingContext,
     LineParser,
 )
-from notionary.page.content.syntax.service import SyntaxRegistry
+from notionary.page.content.syntax import SyntaxRegistry
 
 
 class TableOfContentsParser(LineParser):

notionary/page/content/parser/parsers/todo.py

@@ -1,16 +1,14 @@
-"""Parser for todo/checkbox blocks."""
-
 from typing import override
 
 from notionary.blocks.rich_text.markdown_rich_text_converter import (
     MarkdownRichTextConverter,
 )
-from notionary.blocks.schemas import BlockColor, CreateToDoBlock, ToDoData
+from notionary.blocks.schemas import BlockColor, CreateToDoBlock, CreateToDoData
 from notionary.page.content.parser.parsers.base import (
     BlockParsingContext,
     LineParser,
 )
-from notionary.page.content.syntax.service import SyntaxRegistry
+from notionary.page.content.syntax import SyntaxRegistry
 
 
 class TodoParser(LineParser):
@@ -24,33 +22,73 @@ class TodoParser(LineParser):
     def _can_handle(self, context: BlockParsingContext) -> bool:
         if context.is_inside_parent_context():
             return False
+        return self._is_todo_line(context.line)
 
+    def _is_todo_line(self, line: str) -> bool:
         return (
-            self._syntax.regex_pattern.match(context.line) is not None
-            or self._syntax_done.regex_pattern.match(context.line) is not None
+            self._syntax.regex_pattern.match(line) is not None
+            or self._syntax_done.regex_pattern.match(line) is not None
         )
 
     @override
     async def _process(self, context: BlockParsingContext) -> None:
         block = await self._create_todo_block(context.line)
-        if block:
-            context.result_blocks.append(block)
+        if not block:
+            return
+
+        await self._process_nested_children(block, context)
+        context.result_blocks.append(block)
+
+    async def _process_nested_children(self, block: CreateToDoBlock, context: BlockParsingContext) -> None:
+        child_lines = self._collect_child_lines(context)
+        if not child_lines:
+            return
+
+        child_blocks = await self._parse_child_blocks(child_lines, context)
+        if child_blocks:
+            block.to_do.children = child_blocks
+
+        context.lines_consumed = len(child_lines)
+
+    def _collect_child_lines(self, context: BlockParsingContext) -> list[str]:
+        parent_indent_level = context.get_line_indentation_level()
+        return context.collect_indented_child_lines(parent_indent_level)
+
+    async def _parse_child_blocks(self, child_lines: list[str], context: BlockParsingContext) -> list[CreateToDoBlock]:
+        stripped_lines = self._remove_parent_indentation(child_lines, context)
+        children_text = self._convert_lines_to_text(stripped_lines)
+        return await context.parse_nested_markdown(children_text)
+
+    def _remove_parent_indentation(self, lines: list[str], context: BlockParsingContext) -> list[str]:
+        return context.strip_indentation_level(lines, levels=1)
+
+    def _convert_lines_to_text(self, lines: list[str]) -> str:
+        return "\n".join(lines)
 
     async def _create_todo_block(self, text: str) -> CreateToDoBlock | None:
-        done_match = self._syntax_done.regex_pattern.match(text)
-        todo_match = None if done_match else self._syntax.regex_pattern.match(text)
+        content, checked = self._extract_todo_content(text)
+        if content is None:
+            return None
 
+        rich_text = await self._convert_to_rich_text(content)
+        return self._build_block(rich_text, checked)
+
+    def _extract_todo_content(self, text: str) -> tuple[str | None, bool]:
+        done_match = self._syntax_done.regex_pattern.match(text)
         if done_match:
-            content = done_match.group(1)
-            checked = True
-        elif todo_match:
-            content = todo_match.group(1)
-            checked = False
-        else:
-            return None
+            return done_match.group(1), True
+
+        todo_match = self._syntax.regex_pattern.match(text)
+        if todo_match:
+            return todo_match.group(1), False
+
+        return None, False
+
+    async def _convert_to_rich_text(self, content: str):
+        return await self._rich_text_converter.to_rich_text(content)
 
-        rich_text = await self._rich_text_converter.to_rich_text(content)
-        todo_content = ToDoData(
+    def _build_block(self, rich_text, checked: bool) -> CreateToDoBlock:
+        todo_content = CreateToDoData(
             rich_text=rich_text,
             checked=checked,
             color=BlockColor.DEFAULT,

notionary/page/content/parser/parsers/toggle.py

@@ -5,9 +5,8 @@ from notionary.blocks.schemas import BlockColor, CreateToggleBlock, CreateToggle
 from notionary.page.content.parser.parsers import (
     BlockParsingContext,
     LineParser,
-    ParentBlockContext,
 )
-from notionary.page.content.syntax.service import SyntaxRegistry
+from notionary.page.content.syntax import SyntaxRegistry
 
 
 class ToggleParser(LineParser):
@@ -19,18 +18,12 @@ class ToggleParser(LineParser):
 
     @override
     def _can_handle(self, context: BlockParsingContext) -> bool:
-        return self._is_toggle_start(context) or self._is_toggle_end(context) or self._is_toggle_content(context)
+        return self._is_toggle_start(context)
 
     @override
     async def _process(self, context: BlockParsingContext) -> None:
         if self._is_toggle_start(context):
-            await self._start_toggle(context)
-
-        if self._is_toggle_end(context):
-            await self._finalize_toggle(context)
-
-        if self._is_toggle_content(context):
-            self._add_toggle_content(context)
+            await self._process_toggle(context)
 
     def _is_toggle_start(self, context: BlockParsingContext) -> bool:
         if not self._syntax.regex_pattern.match(context.line):
@@ -42,26 +35,14 @@ class ToggleParser(LineParser):
     def is_heading_start(self, line: str) -> bool:
         return self._heading_syntax.regex_pattern.match(line) is not None
 
-    def _is_toggle_end(self, context: BlockParsingContext) -> bool:
-        if not self._syntax.end_regex_pattern.match(context.line):
-            return False
-
-        if not context.parent_stack:
-            return False
-
-        current_parent = context.parent_stack[-1]
-        return isinstance(current_parent.block, CreateToggleBlock)
-
-    async def _start_toggle(self, context: BlockParsingContext) -> None:
+    async def _process_toggle(self, context: BlockParsingContext) -> None:
         block = await self._create_toggle_block(context.line)
         if not block:
             return
 
-        parent_context = ParentBlockContext(
-            block=block,
-            child_lines=[],
-        )
-        context.parent_stack.append(parent_context)
+        await self._process_nested_children(block, context)
+
+        context.result_blocks.append(block)
 
     async def _create_toggle_block(self, line: str) -> CreateToggleBlock | None:
         if not (match := self._syntax.regex_pattern.match(line)):
@@ -73,55 +54,17 @@ class ToggleParser(LineParser):
         toggle_content = CreateToggleData(rich_text=rich_text, color=BlockColor.DEFAULT, children=[])
         return CreateToggleBlock(toggle=toggle_content)
 
-    async def _finalize_toggle(self, context: BlockParsingContext) -> None:
-        toggle_context = context.parent_stack.pop()
-        await self._assign_toggle_children_if_any(toggle_context, context)
-
-        if self._is_nested_in_other_parent_context(context):
-            self._assign_to_parent_context(context, toggle_context)
-        else:
-            context.result_blocks.append(toggle_context.block)
-
-    def _is_nested_in_other_parent_context(self, context: BlockParsingContext) -> bool:
-        return context.parent_stack
+    async def _process_nested_children(self, block: CreateToggleBlock, context: BlockParsingContext) -> None:
+        parent_indent_level = context.get_line_indentation_level()
+        child_lines = context.collect_indented_child_lines(parent_indent_level)
 
-    def _assign_to_parent_context(self, context: BlockParsingContext, toggle_context: ParentBlockContext) -> None:
-        parent_context = context.parent_stack[-1]
-        parent_context.add_child_block(toggle_context.block)
-
-    async def _assign_toggle_children_if_any(
-        self, toggle_context: ParentBlockContext, context: BlockParsingContext
-    ) -> None:
-        all_children = []
-
-        # Process text lines
-        if toggle_context.child_lines:
-            children_text = "\n".join(toggle_context.child_lines)
-            text_blocks = await self._parse_nested_content(children_text, context)
-            all_children.extend(text_blocks)
-
-        if toggle_context.child_blocks:
-            all_children.extend(toggle_context.child_blocks)
-
-        toggle_context.block.toggle.children = all_children
-
-    def _is_toggle_content(self, context: BlockParsingContext) -> bool:
-        if not context.parent_stack:
-            return False
-
-        current_parent = context.parent_stack[-1]
-        if not isinstance(current_parent.block, CreateToggleBlock):
-            return False
-
-        return not (
-            self._syntax.regex_pattern.match(context.line) or self._syntax.end_regex_pattern.match(context.line)
-        )
+        if not child_lines:
+            return
 
-    def _add_toggle_content(self, context: BlockParsingContext) -> None:
-        context.parent_stack[-1].add_child_line(context.line)
+        stripped_lines = context.strip_indentation_level(child_lines, levels=1)
+        child_markdown = "\n".join(stripped_lines)
 
-    async def _parse_nested_content(self, text: str, context: BlockParsingContext) -> list:
-        if not text.strip():
-            return []
+        child_blocks = await context.parse_nested_markdown(child_markdown)
+        block.toggle.children = child_blocks
 
-        return await context.parse_nested_content(text)
+        context.lines_consumed = len(child_lines)

notionary/page/content/parser/parsers/video.py

@@ -9,7 +9,7 @@ from notionary.blocks.schemas import (
     FileType,
 )
 from notionary.page.content.parser.parsers.base import BlockParsingContext, LineParser
-from notionary.page.content.syntax.service import SyntaxRegistry
+from notionary.page.content.syntax import SyntaxRegistry
 
 
 class VideoParser(LineParser):

notionary/page/content/parser/post_processing/handlers/rich_text_length.py

@@ -65,10 +65,12 @@ class RichTextLengthTruncationPostProcessor(PostProcessor, LoggingMixin):
             self._truncate_rich_text_list(content.caption)
 
         if hasattr(content, "children"):
-            for child in content.children:
-                child_content = self._get_block_content(child)
-                if child_content:
-                    self._truncate_content(child_content)
+            children = getattr(content, "children", None)
+            if children:
+                for child in children:
+                    child_content = self._get_block_content(child)
+                    if child_content:
+                        self._truncate_content(child_content)
 
     def _truncate_rich_text_list(self, rich_text_list: list[RichText]) -> None:
         for rich_text in rich_text_list:

notionary/page/content/parser/post_processing/handlers/rich_text_length_truncation.py

@@ -14,6 +14,7 @@ type _NestedBlockList = BlockCreatePayload | list["_NestedBlockList"]
 
 class RichTextLengthTruncationPostProcessor(PostProcessor, LoggingMixin):
     NOTION_MAX_LENGTH = 2000
+    ELLIPSIS = "..."
 
     def __init__(self, max_text_length: int = NOTION_MAX_LENGTH) -> None:
         self.max_text_length = max_text_length
@@ -58,36 +59,56 @@ class RichTextLengthTruncationPostProcessor(PostProcessor, LoggingMixin):
         return None
 
     def _truncate_content(self, content: object) -> None:
+        self._truncate_rich_text_fields(content)
+        self._truncate_children_recursively(content)
+
+    def _truncate_rich_text_fields(self, content: object) -> None:
         if hasattr(content, "rich_text"):
             self._truncate_rich_text_list(content.rich_text)
 
         if hasattr(content, "caption"):
             self._truncate_rich_text_list(content.caption)
 
-        if hasattr(content, "children"):
-            for child in content.children:
-                child_content = self._get_block_content(child)
-                if child_content:
-                    self._truncate_content(child_content)
+    def _truncate_children_recursively(self, content: object) -> None:
+        if not hasattr(content, "children"):
+            return
+
+        children = getattr(content, "children", None)
+        if not children:
+            return
+
+        for child in children:
+            self._truncate_child_content(child)
+
+    def _truncate_child_content(self, child: Any) -> None:
+        child_content = self._get_block_content(child)
+        if child_content:
+            self._truncate_content(child_content)
 
     def _truncate_rich_text_list(self, rich_text_list: list[RichText]) -> None:
         for rich_text in rich_text_list:
-            if not self._is_text_type(rich_text):
-                continue
-
-            content = rich_text.text.content
-            if len(content) > self.max_text_length:
-                self.logger.warning(
-                    "Truncating text content from %d to %d characters",
-                    len(content),
-                    self.max_text_length,
-                )
-                truncated_content = self._create_truncated_text_with_ellipsis(content)
-                rich_text.text.content = truncated_content
-
-    def _create_truncated_text_with_ellipsis(self, content: str) -> str:
-        cutoff = self.max_text_length - 3
-        return content[:cutoff] + "..."
+            if self._should_truncate(rich_text):
+                self._truncate_single_rich_text(rich_text)
+
+    def _should_truncate(self, rich_text: RichText) -> bool:
+        if not self._is_text_type(rich_text):
+            return False
+
+        return len(rich_text.text.content) > self.max_text_length
+
+    def _truncate_single_rich_text(self, rich_text: RichText) -> None:
+        original_length = len(rich_text.text.content)
+        rich_text.text.content = self._create_truncated_text(rich_text.text.content)
+
+        self.logger.warning(
+            "Truncating text content from %d to %d characters",
+            original_length,
+            self.max_text_length,
+        )
+
+    def _create_truncated_text(self, content: str) -> str:
+        cutoff = self.max_text_length - len(self.ELLIPSIS)
+        return content[:cutoff] + self.ELLIPSIS
 
     def _is_text_type(self, rich_text: RichText) -> bool:
-        return rich_text.type == RichTextType.TEXT and rich_text.text and rich_text.text.content
+        return rich_text.type == RichTextType.TEXT and rich_text.text is not None and rich_text.text.content