notionary 0.2.19__py3-none-any.whl → 0.2.21__py3-none-any.whl

notionary/page/notion_text_length_utils.py

@@ -0,0 +1,119 @@
+"""
+Utility functions for handling Notion API text length limitations.
+
+This module provides functions to fix text content that exceeds Notion's
+rich_text character limit of 2000 characters per element.
+
+Resolves API errors like:
+"validation_error - body.children[79].toggle.children[2].paragraph.rich_text[0].text.content.length
+should be ≤ 2000, instead was 2162."
+"""
+
+import logging
+import re
+
+from notionary.blocks.models import BlockCreateRequest
+
+logger = logging.getLogger(__name__)
+
+
+def fix_blocks_content_length(
+    blocks: list[BlockCreateRequest], max_text_length: int = 1900
+) -> list[BlockCreateRequest]:
+    """Check each block and ensure text content doesn't exceed Notion's limit."""
+    fixed_blocks: list[BlockCreateRequest] = []
+
+    flattened_blocks = _flatten_blocks(blocks)
+
+    for block in flattened_blocks:
+        fixed_block = _fix_single_block_content(block, max_text_length)
+        fixed_blocks.append(fixed_block)
+    return fixed_blocks
+
+
+def _fix_single_block_content(
+    block: BlockCreateRequest, max_text_length: int
+) -> BlockCreateRequest:
+    """Fix content length in a single block and its children recursively."""
+    block_copy = block.model_copy(deep=True)
+    _fix_block_rich_text_direct(block_copy, max_text_length)
+
+    return block_copy
+
+
+def _fix_block_rich_text_direct(
+    block: BlockCreateRequest, max_text_length: int
+) -> None:
+    """Fix rich text content directly on the Pydantic object."""
+    block_content = _get_block_content(block)
+    if not block_content:
+        return
+    if hasattr(block_content, "rich_text") and block_content.rich_text:
+        _fix_rich_text_objects_direct(block_content.rich_text, max_text_length)
+    if hasattr(block_content, "children") and block_content.children:
+        for child in block_content.children:
+            _fix_block_rich_text_direct(child, max_text_length)
+
+
+def _get_block_content(block: BlockCreateRequest):
+    """Get the actual content object from a create block dynamically."""
+    # Get all attributes that don't start with underscore and aren't methods
+    for attr_name in dir(block):
+        if attr_name.startswith("_") or attr_name in [
+            "model_copy",
+            "model_dump",
+            "model_validate",
+        ]:
+            continue
+
+        attr_value = getattr(block, attr_name, None)
+
+        # Skip None values, strings (like 'type'), and callable methods
+        if attr_value is None or isinstance(attr_value, str) or callable(attr_value):
+            continue
+
+        # If it's an object with rich_text or children, it's likely our content
+        if hasattr(attr_value, "rich_text") or hasattr(attr_value, "children"):
+            return attr_value
+
+    return None
+
+
+def _fix_rich_text_objects_direct(rich_text_list: list, max_text_length: int) -> None:
+    """Fix rich text objects directly without dict conversion."""
+    if not rich_text_list:
+        return
+
+    for rich_text_item in rich_text_list:
+        if not rich_text_item:
+            continue
+
+        # Check if this is a text type rich text object
+        if (
+            hasattr(rich_text_item, "text")
+            and rich_text_item.text
+            and hasattr(rich_text_item.text, "content")
+        ):
+
+            content = rich_text_item.text.content
+            if content and len(content) > max_text_length:
+                logger.warning(
+                    "Truncating text content from %d to %d chars",
+                    len(content),
+                    max_text_length,
+                )
+                # Direct assignment - no parsing needed!
+                rich_text_item.text.content = content[:max_text_length]
+
+
+def _flatten_blocks(blocks: list) -> list[BlockCreateRequest]:
+    """Flatten nested block lists."""
+    flattened = []
+    for item in blocks:
+        if isinstance(item, list):
+            # Rekursiv flatten für nested lists
+            flattened.extend(_flatten_blocks(item))
+        else:
+            # Normal block
+            flattened.append(item)
+    return flattened

notionary/page/{content/page_content_writer.py → page_content_writer.py}

@@ -1,16 +1,14 @@
-from typing import Optional
-
-from notionary.blocks import BlockRegistry
-from notionary.blocks.shared.block_client import NotionBlockClient
-from notionary.models.notion_block_response import Block
-from notionary.page.content.markdown_whitespace_processor import (
-    MarkdownWhitespaceProcessor,
-)
-from notionary.page.content.notion_text_length_utils import fix_blocks_content_length
-from notionary.page.formatting.markdown_to_notion_converter import (
-    MarkdownToNotionConverter,
-)
-
+from typing import Callable, Optional, Union
+
+from notionary.blocks.client import NotionBlockClient
+from notionary.blocks.divider import DividerElement
+from notionary.blocks.models import Block
+from notionary.blocks.registry.block_registry import BlockRegistry
+from notionary.blocks.table_of_contents import TableOfContentsElement
+from notionary.markdown.markdown_builder import MarkdownBuilder
+from notionary.page.markdown_whitespace_processor import MarkdownWhitespaceProcessor
+from notionary.page.reader.page_content_retriever import PageContentRetriever
+from notionary.page.writer.markdown_to_notion_converter import MarkdownToNotionConverter
 from notionary.util import LoggingMixin
 
 
@@ -24,53 +22,97 @@ class PageContentWriter(LoggingMixin):
             block_registry=block_registry
         )
 
-    async def append_markdown(self, markdown_text: str, append_divider=True) -> bool:
-        """Append markdown text to a Notion page, automatically handling content length limits."""
+        self._content_retriever = PageContentRetriever(block_registry=block_registry)
+
+    async def append_markdown(
+        self,
+        content: Union[str, Callable[[MarkdownBuilder], MarkdownBuilder]],
+        *,
+        append_divider: bool = True,
+        prepend_table_of_contents: bool = False,
+    ) -> Optional[str]:
+        """
+        Append markdown content to a Notion page using either text or builder callback.
+
+        Args:
+            content: Either raw markdown text OR a callback function that receives a MarkdownBuilder
+            append_divider: Whether to append a divider
+            prepend_table_of_contents: Whether to prepend table of contents
+
+        Returns:
+            str: The processed markdown content that was appended (None if failed)
+        """
+
+        if isinstance(content, str):
+            final_markdown = content
+        elif callable(content):
+            builder = MarkdownBuilder()
+            content(builder)
+            final_markdown = builder.build()
+        else:
+            raise ValueError(
+                "content must be either a string or a callable that takes a MarkdownBuilder"
+            )
+
+        # Add optional components
+        if prepend_table_of_contents:
+            self._ensure_table_of_contents_exists_in_registry()
+            final_markdown = "[toc]\n\n" + final_markdown
+
         if append_divider:
-            markdown_text = markdown_text + "---\n"
+            self._ensure_divider_exists_in_registry()
+            final_markdown = final_markdown + "\n\n---\n"
 
-        markdown_text = self._process_markdown_whitespace(markdown_text)
+        processed_markdown = self._process_markdown_whitespace(final_markdown)
 
         try:
-            blocks = self._markdown_to_notion_converter.convert(markdown_text)
-
-            fixed_blocks = fix_blocks_content_length(blocks)
+            blocks = self._markdown_to_notion_converter.convert(processed_markdown)
 
             result = await self._block_client.append_block_children(
-                block_id=self.page_id, children=fixed_blocks
+                block_id=self.page_id, children=blocks
             )
-            self.logger.debug("Append block children result: %r", result)
-            return bool(result)
-        except Exception as e:
-            import traceback
 
-            self.logger.error(
-                "Error appending markdown: %s\nTraceback:\n%s",
-                str(e),
-                traceback.format_exc(),
-            )
-            return False
+            if result:
+                self.logger.debug("Successfully appended %d blocks", len(blocks))
+                return processed_markdown
+            else:
+                self.logger.error("Failed to append blocks")
+                return None
 
-    async def clear_page_content(self) -> bool:
-        """Clear all content of the page."""
+        except Exception as e:
+            self.logger.error("Error appending markdown: %s", str(e), exc_info=True)
+            return None
+
+    async def clear_page_content(self) -> Optional[str]:
+        """Clear all content of the page and return deleted content as markdown."""
         try:
             children_response = await self._block_client.get_block_children(
                 block_id=self.page_id
             )
 
             if not children_response or not children_response.results:
-                return True
+                return None
 
+            # Use PageContentRetriever for sophisticated markdown conversion
+            deleted_content = self._content_retriever._convert_blocks_to_markdown(
+                children_response.results, indent_level=0
+            )
+
+            # Delete blocks
             success = True
             for block in children_response.results:
                 block_success = await self._delete_block_with_children(block)
                 if not block_success:
                     success = False
 
-            return success
-        except Exception as e:
-            self.logger.error("Error clearing page content: %s", str(e))
-            return False
+            if not success:
+                self.logger.warning("Some blocks could not be deleted")
+
+            return deleted_content if deleted_content else None
+
+        except Exception:
+            self.logger.error("Error clearing page content", exc_info=True)
+            return None
 
     async def _delete_block_with_children(self, block: Block) -> bool:
         """Delete a block and all its children recursively."""
@@ -149,3 +191,11 @@ class PageContentWriter(LoggingMixin):
 
         processor = MarkdownWhitespaceProcessor()
         return processor.process_lines(lines)
+
+    def _ensure_table_of_contents_exists_in_registry(self) -> None:
+        """Ensure TableOfContents is registered in the block registry."""
+        self.block_registry.register(TableOfContentsElement)
+
+    def _ensure_divider_exists_in_registry(self) -> None:
+        """Ensure DividerBlock is registered in the block registry."""
+        self.block_registry.register(DividerElement)

notionary/page/reader/handler/__init__.py

@@ -0,0 +1,17 @@
+from .base_block_renderer import BlockHandler
+from .block_rendering_context import BlockRenderingContext
+from .column_list_renderer import ColumnListRenderer
+from .column_renderer import ColumnRenderer
+from .line_renderer import LineRenderer
+from .toggle_renderer import ToggleRenderer
+from .toggleable_heading_renderer import ToggleableHeadingRenderer
+
+__all__ = [
+    "BlockHandler",
+    "BlockRenderingContext",
+    "ColumnListRenderer",
+    "ColumnRenderer",
+    "LineRenderer",
+    "ToggleRenderer",
+    "ToggleableHeadingRenderer",
+]

notionary/page/reader/handler/base_block_renderer.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Optional
+
+from notionary.page.reader.handler.block_rendering_context import BlockRenderingContext
+
+
+class BlockHandler(ABC):
+    """Abstract base class for block handlers."""
+
+    def __init__(self):
+        self._next_handler: Optional[BlockHandler] = None
+
+    def set_next(self, handler: BlockHandler) -> BlockHandler:
+        """Set the next handler in the chain."""
+        self._next_handler = handler
+        return handler
+
+    def handle(self, context: BlockRenderingContext) -> None:
+        """Handle the block or pass to next handler."""
+        if self._can_handle(context):
+            self._process(context)
+        elif self._next_handler:
+            self._next_handler.handle(context)
+
+    @abstractmethod
+    def _can_handle(self, context: BlockRenderingContext) -> bool:
+        """Check if this handler can process the current block."""
+        pass
+
+    @abstractmethod
+    def _process(self, context: BlockRenderingContext) -> None:
+        """Process the block and update context."""
+        pass
+
+    def _indent_text(self, text: str, spaces: int = 4) -> str:
+        """Indent each line of text with specified number of spaces."""
+        if not text:
+            return text
+
+        indent = " " * spaces
+        lines = text.split("\n")
+        return "\n".join(f"{indent}{line}" if line.strip() else line for line in lines)

notionary/page/reader/handler/block_processing_context.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional
+
+from notionary.blocks.models import Block
+from notionary.blocks.registry.block_registry import BlockRegistry
+
+
+@dataclass
+class BlockProcessingContext:
+    """Context for processing blocks during markdown conversion."""
+
+    block: Block
+    indent_level: int
+    block_registry: BlockRegistry
+
+    # Result
+    markdown_result: Optional[str] = None
+    children_result: Optional[str] = None
+    was_processed: bool = False
+
+    def has_children(self) -> bool:
+        """Check if block has children that need processing."""
+        return (
+            self.block.has_children
+            and self.block.children is not None
+            and len(self.block.children) > 0
+        )
+
+    def get_children_blocks(self) -> list[Block]:
+        """Get the children blocks safely."""
+        if self.has_children():
+            return self.block.children
+        return []

notionary/page/reader/handler/block_rendering_context.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable, Optional
+
+from notionary.blocks.models import Block
+from notionary.blocks.registry.block_registry import BlockRegistry
+
+
+@dataclass
+class BlockRenderingContext:
+    """Context for processing blocks during markdown conversion."""
+
+    block: Block
+    indent_level: int
+    block_registry: BlockRegistry
+    convert_children_callback: Optional[Callable[[list[Block], int], str]] = None
+
+    # Result
+    markdown_result: Optional[str] = None
+    children_result: Optional[str] = None
+    was_processed: bool = False
+
+    def has_children(self) -> bool:
+        """Check if block has children that need processing."""
+        return (
+            self.block.has_children
+            and self.block.children is not None
+            and len(self.block.children) > 0
+        )
+
+    def get_children_blocks(self) -> list[Block]:
+        """Get the children blocks safely."""
+        if self.has_children():
+            return self.block.children
+        return []
+
+    def convert_children_to_markdown(self, indent_level: int = 0) -> str:
+        """Convert children blocks to markdown using the callback."""
+        if not self.has_children() or not self.convert_children_callback:
+            return ""
+
+        return self.convert_children_callback(self.get_children_blocks(), indent_level)

notionary/page/reader/handler/column_list_renderer.py

@@ -0,0 +1,51 @@
+from notionary.blocks.column.column_list_element import ColumnListElement
+from notionary.page.reader.handler import BlockHandler, BlockRenderingContext
+
+
+class ColumnListRenderer(BlockHandler):
+    """Handles column list blocks with their column children."""
+
+    def _can_handle(self, context: BlockRenderingContext) -> bool:
+        return ColumnListElement.match_notion(context.block)
+
+    def _process(self, context: BlockRenderingContext) -> None:
+        # Create column list start line
+        column_list_start = "::: columns"
+
+        # Apply indentation if needed
+        if context.indent_level > 0:
+            column_list_start = self._indent_text(
+                column_list_start, spaces=context.indent_level * 4
+            )
+
+        # Process children if they exist
+        children_markdown = ""
+        if context.has_children():
+            # Import here to avoid circular dependency
+            from notionary.page.reader.page_content_retriever import (
+                PageContentRetriever,
+            )
+
+            # Create a temporary retriever to process children
+            retriever = PageContentRetriever(context.block_registry)
+            children_markdown = retriever._convert_blocks_to_markdown(
+                context.get_children_blocks(),
+                indent_level=0,  # No indentation for content inside column lists
+            )
+
+        # Create column list end line
+        column_list_end = ":::"
+        if context.indent_level > 0:
+            column_list_end = self._indent_text(
+                column_list_end, spaces=context.indent_level * 4
+            )
+
+        # Combine column list with children content
+        if children_markdown:
+            context.markdown_result = (
+                f"{column_list_start}\n{children_markdown}\n{column_list_end}"
+            )
+        else:
+            context.markdown_result = f"{column_list_start}\n{column_list_end}"
+
+        context.was_processed = True

notionary/page/reader/handler/column_renderer.py

@@ -0,0 +1,60 @@
+from notionary.blocks.column.column_element import ColumnElement
+from notionary.page.reader.handler import BlockHandler, BlockRenderingContext
+
+
+class ColumnRenderer(BlockHandler):
+    """Handles individual column blocks with their children content."""
+
+    def _can_handle(self, context: BlockRenderingContext) -> bool:
+        return ColumnElement.match_notion(context.block)
+
+    def _process(self, context: BlockRenderingContext) -> None:
+        # Get the column start line with potential width ratio
+        column_start = self._extract_column_start(context.block)
+
+        # Apply indentation if needed
+        if context.indent_level > 0:
+            column_start = self._indent_text(
+                column_start, spaces=context.indent_level * 4
+            )
+
+        # Process children if they exist
+        children_markdown = ""
+        if context.has_children():
+            # Import here to avoid circular dependency
+            from notionary.page.reader.page_content_retriever import (
+                PageContentRetriever,
+            )
+
+            # Create a temporary retriever to process children
+            retriever = PageContentRetriever(context.block_registry)
+            children_markdown = retriever._convert_blocks_to_markdown(
+                context.get_children_blocks(),
+                indent_level=0,  # No indentation for content inside columns
+            )
+
+        # Create column end line
+        column_end = ":::"
+        if context.indent_level > 0:
+            column_end = self._indent_text(column_end, spaces=context.indent_level * 4)
+
+        # Combine column with children content
+        if children_markdown:
+            context.markdown_result = (
+                f"{column_start}\n{children_markdown}\n{column_end}"
+            )
+        else:
+            context.markdown_result = f"{column_start}\n{column_end}"
+
+        context.was_processed = True
+
+    def _extract_column_start(self, block) -> str:
+        """Extract column start line with potential width ratio."""
+        if not block.column:
+            return "::: column"
+
+        width_ratio = block.column.width_ratio
+        if width_ratio:
+            return f"::: column {width_ratio}"
+        else:
+            return "::: column"

notionary/page/reader/handler/line_renderer.py

@@ -0,0 +1,60 @@
+from notionary.page.reader.handler import BlockHandler, BlockRenderingContext
+
+
+class LineRenderer(BlockHandler):
+    """Handles all regular blocks that don't need special parent/children processing."""
+
+    def _can_handle(self, context: BlockRenderingContext) -> bool:
+        # Always can handle - this is the fallback handler
+        return True
+
+    def _process(self, context: BlockRenderingContext) -> None:
+        # Convert the block itself
+        block_markdown = context.block_registry.notion_to_markdown(context.block)
+
+        # If block has no direct markdown, either return empty or process children
+        if not block_markdown:
+            if not context.has_children():
+                context.markdown_result = ""
+                context.was_processed = True
+                return
+
+            # Import here to avoid circular dependency and process children
+            from notionary.page.reader.page_content_retriever import (
+                PageContentRetriever,
+            )
+
+            retriever = PageContentRetriever(context.block_registry)
+            children_markdown = retriever._convert_blocks_to_markdown(
+                context.get_children_blocks(), indent_level=context.indent_level + 1
+            )
+            context.markdown_result = children_markdown
+            context.was_processed = True
+            return
+
+        # Apply indentation if needed
+        if context.indent_level > 0:
+            block_markdown = self._indent_text(
+                block_markdown, spaces=context.indent_level * 4
+            )
+
+        # If there are no children, return the block markdown directly
+        if not context.has_children():
+            context.markdown_result = block_markdown
+            context.was_processed = True
+            return
+
+        # Otherwise process children and combine
+        from notionary.page.reader.page_content_retriever import PageContentRetriever
+
+        retriever = PageContentRetriever(context.block_registry)
+        children_markdown = retriever._convert_blocks_to_markdown(
+            context.get_children_blocks(), indent_level=context.indent_level + 1
+        )
+
+        context.markdown_result = (
+            f"{block_markdown}\n{children_markdown}"
+            if children_markdown
+            else block_markdown
+        )
+        context.was_processed = True

notionary/page/reader/handler/toggle_renderer.py

@@ -0,0 +1,69 @@
+from notionary.blocks.toggle.toggle_element import ToggleElement
+from notionary.page.reader.handler import BlockHandler, BlockRenderingContext
+
+
+class ToggleRenderer(BlockHandler):
+    """Handles toggle blocks with their children content."""
+
+    def _can_handle(self, context: BlockRenderingContext) -> bool:
+        return ToggleElement.match_notion(context.block)
+
+    def _process(self, context: BlockRenderingContext) -> None:
+        # Get the toggle title from the block
+        toggle_title = self._extract_toggle_title(context.block)
+
+        if not toggle_title:
+            return
+
+        # Create toggle start line
+        toggle_start = f"+++ {toggle_title}"
+
+        # Apply indentation if needed
+        if context.indent_level > 0:
+            toggle_start = self._indent_text(
+                toggle_start, spaces=context.indent_level * 4
+            )
+
+        # Process children if they exist
+        children_markdown = ""
+        if context.has_children():
+            # Import here to avoid circular dependency
+            from notionary.page.reader.page_content_retriever import (
+                PageContentRetriever,
+            )
+
+            # Create a temporary retriever to process children
+            retriever = PageContentRetriever(context.block_registry)
+            children_markdown = retriever._convert_blocks_to_markdown(
+                context.get_children_blocks(),
+                indent_level=0,  # No indentation for content inside toggles
+            )
+
+        # Create toggle end line
+        toggle_end = "+++"
+        if context.indent_level > 0:
+            toggle_end = self._indent_text(toggle_end, spaces=context.indent_level * 4)
+
+        # Combine toggle with children content
+        if children_markdown:
+            context.markdown_result = (
+                f"{toggle_start}\n{children_markdown}\n{toggle_end}"
+            )
+        else:
+            context.markdown_result = f"{toggle_start}\n{toggle_end}"
+
+        context.was_processed = True
+
+    def _extract_toggle_title(self, block) -> str:
+        """Extract toggle title from the block."""
+        if not block.toggle or not block.toggle.rich_text:
+            return ""
+
+        title = ""
+        for text_obj in block.toggle.rich_text:
+            if hasattr(text_obj, "plain_text"):
+                title += text_obj.plain_text or ""
+            elif hasattr(text_obj, "text") and hasattr(text_obj.text, "content"):
+                title += text_obj.text.content or ""
+
+        return title.strip()