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

notionary/page/writer/handler/table_handler.py

@@ -1,9 +1,6 @@
 import re
 
-from notionary.blocks.rich_text.rich_text_models import RichTextObject
-from notionary.blocks.rich_text.text_inline_formatter import TextInlineFormatter
 from notionary.blocks.table.table_element import TableElement
-from notionary.blocks.table.table_models import CreateTableRowBlock, TableRowBlock
 from notionary.page.writer.handler import LineHandler, LineProcessingContext
 
 
@@ -20,11 +17,11 @@ class TableHandler(LineHandler):
             return False
         return self._is_table_start(context)
 
-    def _process(self, context: LineProcessingContext) -> None:
+    async def _process(self, context: LineProcessingContext) -> None:
         if not self._is_table_start(context):
             return
 
-        self._process_complete_table(context)
+        await self._process_complete_table(context)
         context.was_processed = True
         context.should_continue = True
 
@@ -36,16 +33,8 @@ class TableHandler(LineHandler):
         """Check if this line starts a table."""
         return self._table_row_pattern.match(context.line.strip()) is not None
 
-    def _process_complete_table(self, context: LineProcessingContext) -> None:
-        """Process the entire table in one go."""
-        # Create table element
-        table_element = TableElement()
-        result = table_element.markdown_to_notion(context.line)
-        if not result:
-            return
-
-        block = result if not isinstance(result, list) else result[0]
-
+    async def _process_complete_table(self, context: LineProcessingContext) -> None:
+        """Process the entire table in one go using TableElement."""
         # Collect all table lines (including the current one)
         table_lines = [context.line]
         remaining_lines = context.get_remaining_lines()
@@ -68,63 +57,10 @@ class TableHandler(LineHandler):
                 lines_to_consume = i
                 break
         else:
-            # Consumed all remaining lines
             lines_to_consume = len(remaining_lines)
 
-        # Process the table content
-        table_rows, separator_found = self._process_table_lines(table_lines)
-
-        table = block.table
-        table.children = table_rows
-        table.has_column_header = bool(separator_found)
-
-        # Tell the main loop to skip the consumed lines
-        context.lines_consumed = lines_to_consume
-        context.result_blocks.append(block)
-
-    def _process_table_lines(
-        self, table_lines: list[str]
-    ) -> tuple[list[CreateTableRowBlock], bool]:
-        """Process all table lines and return rows and separator status."""
-        table_rows = []
-        separator_found = False
-
-        for line in table_lines:
-            line = line.strip()
-            if not line:
-                continue
-
-            if self._is_separator_line(line):
-                separator_found = True
-                continue
-
-            if self._table_row_pattern.match(line):
-                table_row = self._create_table_row_from_line(line)
-                table_rows.append(table_row)
-
-        return table_rows, separator_found
-
-    def _is_separator_line(self, line: str) -> bool:
-        return self._separator_pattern.match(line) is not None
-
-    def _create_table_row_from_line(self, line: str) -> CreateTableRowBlock:
-        cells = self._parse_table_row(line)
-        rich_text_cells = [self._convert_cell_to_rich_text(cell) for cell in cells]
-        table_row = TableRowBlock(cells=rich_text_cells)
-        return CreateTableRowBlock(table_row=table_row)
-
-    def _convert_cell_to_rich_text(self, cell: str) -> list[RichTextObject]:
-        rich_text = TextInlineFormatter.parse_inline_formatting(cell)
-        if not rich_text:
-            rich_text = [RichTextObject.from_plain_text(cell)]
-        return rich_text
-
-    def _parse_table_row(self, row_text: str) -> list[str]:
-        row_content = row_text.strip()
-
-        if row_content.startswith("|"):
-            row_content = row_content[1:]
-        if row_content.endswith("|"):
-            row_content = row_content[:-1]
+        block = await TableElement.create_from_markdown_table(table_lines)
 
-        return [cell.strip() for cell in row_content.split("|")]
+        if block:
+            context.lines_consumed = lines_to_consume
+            context.result_blocks.append(block)

notionary/page/writer/handler/toggle_handler.py

@@ -25,15 +25,15 @@ class ToggleHandler(LineHandler):
             or self._is_toggle_content(context)
         )
 
-    def _process(self, context: LineProcessingContext) -> None:
+    async def _process(self, context: LineProcessingContext) -> None:
         # Explicit, readable branches (small duplication is acceptable)
         if self._is_toggle_start(context):
-            self._start_toggle(context)
+            await self._start_toggle(context)
             context.was_processed = True
             context.should_continue = True
 
         if self._is_toggle_end(context):
-            self._finalize_toggle(context)
+            await self._finalize_toggle(context)
             context.was_processed = True
             context.should_continue = True
 
@@ -69,16 +69,16 @@ class ToggleHandler(LineHandler):
         current_parent = context.parent_stack[-1]
         return issubclass(current_parent.element_type, ToggleElement)
 
-    def _start_toggle(self, context: LineProcessingContext) -> None:
+    async def _start_toggle(self, context: LineProcessingContext) -> None:
         """Start a new toggle block."""
         toggle_element = ToggleElement()
 
         # Create the block
-        result = toggle_element.markdown_to_notion(context.line)
+        result = await toggle_element.markdown_to_notion(context.line)
         if not result:
             return
 
-        block = result if not isinstance(result, list) else result[0]
+        block = result
 
         # Push to parent stack
         parent_context = ParentBlockContext(
@@ -88,12 +88,12 @@ class ToggleHandler(LineHandler):
         )
         context.parent_stack.append(parent_context)
 
-    def _finalize_toggle(self, context: LineProcessingContext) -> None:
+    async def _finalize_toggle(self, context: LineProcessingContext) -> None:
         """Finalize a toggle block and add it to result_blocks."""
         toggle_context = context.parent_stack.pop()
 
         if toggle_context.has_children():
-            all_children = self._get_all_children(
+            all_children = await self._get_all_children(
                 toggle_context, context.block_registry
             )
             toggle_context.block.toggle.children = all_children
@@ -124,7 +124,7 @@ class ToggleHandler(LineHandler):
         """Add content to the current toggle context."""
         context.parent_stack[-1].add_child_line(context.line)
 
-    def _convert_children_text(self, text: str, block_registry) -> list:
+    async def _convert_children_text(self, text: str, block_registry) -> list:
         """Convert children text to blocks."""
         from notionary.page.writer.markdown_to_notion_converter import (
             MarkdownToNotionConverter,
@@ -134,16 +134,18 @@ class ToggleHandler(LineHandler):
             return []
 
         child_converter = MarkdownToNotionConverter(block_registry)
-        return child_converter._process_lines(text)
+        return await child_converter.process_lines(text)
 
-    def _get_all_children(self, parent_context, block_registry) -> list:
+    async def _get_all_children(self, parent_context, block_registry) -> list:
         """Helper method to combine text-based and direct block children."""
         children_blocks = []
 
         # Process text lines
         if parent_context.child_lines:
             children_text = "\n".join(parent_context.child_lines)
-            text_blocks = self._convert_children_text(children_text, block_registry)
+            text_blocks = await self._convert_children_text(
+                children_text, block_registry
+            )
             children_blocks.extend(text_blocks)
 
         # Add direct blocks (like processed columns)

notionary/page/writer/handler/toggleable_heading_handler.py

@@ -32,21 +32,21 @@ class ToggleableHeadingHandler(LineHandler):
             or self._is_toggleable_heading_content(context)
         )
 
-    def _process(self, context: LineProcessingContext) -> None:
+    async def _process(self, context: LineProcessingContext) -> None:
         """Process toggleable heading start, end, or content with unified handling."""
 
-        def _handle(action):
-            action(context)
+        async def _handle(action):
+            await action(context)
             context.was_processed = True
             context.should_continue = True
             return True
 
         if self._is_toggleable_heading_start(context):
-            return _handle(self._start_toggleable_heading)
+            return await _handle(self._start_toggleable_heading)
         if self._is_toggleable_heading_end(context):
-            return _handle(self._finalize_toggleable_heading)
+            return await _handle(self._finalize_toggleable_heading)
         if self._is_toggleable_heading_content(context):
-            return _handle(self._add_toggleable_heading_content)
+            return await _handle(self._add_toggleable_heading_content)
 
     def _is_toggleable_heading_start(self, context: LineProcessingContext) -> bool:
         """Check if line starts a toggleable heading (+++# "Title")."""
@@ -64,16 +64,16 @@ class ToggleableHeadingHandler(LineHandler):
         current_parent = context.parent_stack[-1]
         return issubclass(current_parent.element_type, ToggleableHeadingElement)
 
-    def _start_toggleable_heading(self, context: LineProcessingContext) -> None:
+    async def _start_toggleable_heading(self, context: LineProcessingContext) -> None:
         """Start a new toggleable heading block."""
         toggleable_heading_element = ToggleableHeadingElement()
 
         # Create the block
-        result = toggleable_heading_element.markdown_to_notion(context.line)
+        result = await toggleable_heading_element.markdown_to_notion(context.line)
         if not result:
             return
 
-        block = result if not isinstance(result, list) else result[0]
+        block = result
 
         # Push to parent stack
         parent_context = ParentBlockContext(
@@ -96,16 +96,20 @@ class ToggleableHeadingHandler(LineHandler):
         line = context.line.strip()
         return not (self._start_pattern.match(line) or self._end_pattern.match(line))
 
-    def _add_toggleable_heading_content(self, context: LineProcessingContext) -> None:
+    async def _add_toggleable_heading_content(
+        self, context: LineProcessingContext
+    ) -> None:
         """Add content to the current toggleable heading context."""
         context.parent_stack[-1].add_child_line(context.line)
 
-    def _finalize_toggleable_heading(self, context: LineProcessingContext) -> None:
+    async def _finalize_toggleable_heading(
+        self, context: LineProcessingContext
+    ) -> None:
         """Finalize a toggleable heading block and add it to result_blocks."""
         heading_context = context.parent_stack.pop()
 
         if heading_context.has_children():
-            all_children = self._get_all_children(
+            all_children = await self._get_all_children(
                 heading_context, context.block_registry
             )
             self._assign_heading_children(heading_context.block, all_children)
@@ -123,7 +127,7 @@ class ToggleableHeadingHandler(LineHandler):
             # No parent, add to top level
             context.result_blocks.append(heading_context.block)
 
-    def _get_all_children(
+    async def _get_all_children(
         self, parent_context: ParentBlockContext, block_registry
     ) -> list:
         """Helper method to combine text-based and direct block children."""
@@ -132,7 +136,9 @@ class ToggleableHeadingHandler(LineHandler):
         # Process text lines
         if parent_context.child_lines:
             children_text = "\n".join(parent_context.child_lines)
-            text_blocks = self._convert_children_text(children_text, block_registry)
+            text_blocks = await self._convert_children_text(
+                children_text, block_registry
+            )
             children_blocks.extend(text_blocks)
 
         # Add direct blocks
@@ -154,7 +160,7 @@ class ToggleableHeadingHandler(LineHandler):
         elif block_type == BlockType.HEADING_3:
             parent_block.heading_3.children = children
 
-    def _convert_children_text(self, text: str, block_registry) -> list:
+    async def _convert_children_text(self, text: str, block_registry) -> list:
         """Convert children text to blocks."""
         from notionary.page.writer.markdown_to_notion_converter import (
             MarkdownToNotionConverter,
@@ -164,4 +170,4 @@ class ToggleableHeadingHandler(LineHandler):
             return []
 
         child_converter = MarkdownToNotionConverter(block_registry)
-        return child_converter._process_lines(text)
+        return await child_converter.process_lines(text)

notionary/page/writer/markdown_to_notion_converter.py

@@ -1,10 +1,10 @@
 from notionary.blocks.models import BlockCreateRequest
 from notionary.blocks.registry.block_registry import BlockRegistry
-from notionary.page.notion_text_length_utils import fix_blocks_content_length
 from notionary.page.writer.handler import (
     CodeHandler,
     ColumnHandler,
     ColumnListHandler,
+    EquationHandler,
     LineProcessingContext,
     ParentBlockContext,
     RegularLineHandler,
@@ -12,6 +12,12 @@ from notionary.page.writer.handler import (
     ToggleableHeadingHandler,
     ToggleHandler,
 )
+from notionary.page.writer.markdown_to_notion_formatting_post_processor import (
+    MarkdownToNotionFormattingPostProcessor,
+)
+from notionary.page.writer.notion_text_length_processor import (
+    NotionTextLengthProcessor,
+)
 
 
 class MarkdownToNotionConverter:
@@ -19,10 +25,14 @@ class MarkdownToNotionConverter:
 
     def __init__(self, block_registry: BlockRegistry) -> None:
         self._block_registry = block_registry
+        self._formatting_post_processor = MarkdownToNotionFormattingPostProcessor()
+        self._text_length_post_processor = NotionTextLengthProcessor()
+
         self._setup_handler_chain()
 
     def _setup_handler_chain(self) -> None:
         code_handler = CodeHandler()
+        equation_handler = EquationHandler()
         table_handler = TableHandler()
         column_list_handler = ColumnListHandler()
         column_handler = ColumnHandler()
@@ -31,22 +41,31 @@ class MarkdownToNotionConverter:
         regular_handler = RegularLineHandler()
 
         # register more specific elements first
-        code_handler.set_next(table_handler).set_next(column_list_handler).set_next(
-            column_handler
-        ).set_next(toggleable_heading_handler).set_next(toggle_handler).set_next(
+        code_handler.set_next(equation_handler).set_next(table_handler).set_next(
+            column_list_handler
+        ).set_next(column_handler).set_next(toggleable_heading_handler).set_next(
+            toggle_handler
+        ).set_next(
             regular_handler
         )
 
         self._handler_chain = code_handler
 
-    def convert(self, markdown_text: str) -> list[BlockCreateRequest]:
+    async def convert(self, markdown_text: str) -> list[BlockCreateRequest]:
         if not markdown_text.strip():
             return []
 
-        all_blocks = self._process_lines(markdown_text)
-        return fix_blocks_content_length(all_blocks)
+        all_blocks = await self.process_lines(markdown_text)
+
+        # Apply formatting post-processing (empty paragraphs)
+        all_blocks = self._formatting_post_processor.process(all_blocks)
+
+        # Apply text length post-processing (truncation)
+        all_blocks = self._text_length_post_processor.process(all_blocks)
+
+        return all_blocks
 
-    def _process_lines(self, text: str) -> list[BlockCreateRequest]:
+    async def process_lines(self, text: str) -> list[BlockCreateRequest]:
         lines = text.split("\n")
         result_blocks: list[BlockCreateRequest] = []
         parent_stack: list[ParentBlockContext] = []
@@ -65,7 +84,7 @@ class MarkdownToNotionConverter:
                 lines_consumed=0,
             )
 
-            self._handler_chain.handle(context)
+            await self._handler_chain.handle(context)
 
             # Skip consumed lines
             i += 1 + context.lines_consumed

notionary/page/writer/markdown_to_notion_converter_context.py

@@ -0,0 +1,30 @@
+# notionary/blocks/context/conversion_context.py
+from __future__ import annotations
+
+from typing import Optional, TYPE_CHECKING
+from dataclasses import dataclass
+
+if TYPE_CHECKING:
+    from notionary.database.client import NotionDatabaseClient
+
+
+@dataclass
+class ConverterContext:
+    """
+    Context object that provides dependencies for block conversion operations.
+    """
+
+    page_id: Optional[str] = None
+    database_client: Optional["NotionDatabaseClient"] = None
+
+    def require_database_client(self) -> NotionDatabaseClient:
+        """Get database client or raise if not available."""
+        if self.database_client is None:
+            raise ValueError("Database client required but not provided in context")
+        return self.database_client
+
+    def require_page_id(self) -> str:
+        """Get parent page ID or raise if not available."""
+        if self.page_id is None:
+            raise ValueError("Parent page ID required but not provided in context")
+        return self.page_id

notionary/page/writer/markdown_to_notion_formatting_post_processor.py

@@ -0,0 +1,73 @@
+"""
+Post-processor for handling block formatting in Markdown to Notion conversion.
+
+Handles block formatting tasks like adding empty paragraphs before media blocks
+and other formatting-related post-processing.
+"""
+
+from typing import cast
+
+from notionary.blocks.models import BlockCreateRequest
+from notionary.blocks.types import BlockType
+from notionary.blocks.paragraph.paragraph_models import (
+    CreateParagraphBlock,
+    ParagraphBlock,
+)
+
+
+class MarkdownToNotionFormattingPostProcessor:
+    """Handles block formatting post-processing for Notion blocks."""
+
+    BLOCKS_NEEDING_EMPTY_PARAGRAPH: set[BlockType] = {
+        BlockType.DIVIDER,
+        BlockType.FILE,
+        BlockType.IMAGE,
+        BlockType.PDF,
+        BlockType.VIDEO,
+    }
+
+    def process(self, blocks: list[BlockCreateRequest]) -> list[BlockCreateRequest]:
+        """Process blocks with all formatting steps."""
+        if not blocks:
+            return blocks
+
+        return self._add_empty_paragraphs_for_media_blocks(blocks)
+
+    def _add_empty_paragraphs_for_media_blocks(
+        self, blocks: list[BlockCreateRequest]
+    ) -> list[BlockCreateRequest]:
+        """Add empty paragraphs before configured block types."""
+        if not blocks:
+            return blocks
+
+        result: list[BlockCreateRequest] = []
+
+        for i, block in enumerate(blocks):
+            block_type = block.type
+
+            if (
+                block_type in self.BLOCKS_NEEDING_EMPTY_PARAGRAPH
+                and i > 0
+                and not self._is_empty_paragraph(result[-1] if result else None)
+            ):
+
+                # Create empty paragraph block inline
+                empty_paragraph = CreateParagraphBlock(
+                    paragraph=ParagraphBlock(rich_text=[])
+                )
+                result.append(empty_paragraph)
+
+            result.append(block)
+
+        return result
+
+    def _is_empty_paragraph(self, block: BlockCreateRequest | None) -> bool:
+        if not block or block.type != BlockType.PARAGRAPH:
+            return False
+        if not isinstance(block, CreateParagraphBlock):
+            return False
+
+        para_block = cast(CreateParagraphBlock, block)
+        paragraph: ParagraphBlock | None = para_block.paragraph
+        if not paragraph:
+            return False

notionary/page/writer/notion_text_length_processor.py

@@ -0,0 +1,150 @@
+"""
+Post-processor for handling Notion API text length limitations.
+
+Handles text length validation and truncation for blocks that exceed
+Notion's rich_text character limit of 2000 characters per element.
+"""
+
+from typing import TypeGuard, Union
+
+from notionary.blocks.models import BlockCreateRequest
+from notionary.blocks.rich_text.rich_text_models import RichTextObject
+from notionary.blocks.types import HasRichText, HasChildren
+from notionary.util import LoggingMixin
+
+
+class NotionTextLengthProcessor(LoggingMixin):
+    """
+    Processes Notion blocks to ensure text content doesn't exceed API limits.
+
+    The Notion API has a limit of 2000 characters per rich_text element.
+    This processor truncates content that exceeds the specified limit.
+    """
+
+    DEFAULT_MAX_LENGTH = 1900  # Leave some buffer under the 2000 limit
+
+    def __init__(self, max_text_length: int = DEFAULT_MAX_LENGTH) -> None:
+        """
+        Initialize the processor.
+
+        Args:
+            max_text_length: Maximum allowed text length (default: 1900)
+        """
+        if max_text_length <= 0:
+            raise ValueError("max_text_length must be positive")
+        if max_text_length > 2000:
+            self.logger.warning(
+                "max_text_length (%d) exceeds Notion's limit of 2000 characters",
+                max_text_length,
+            )
+
+        self.max_text_length = max_text_length
+
+    def process(self, blocks: list[BlockCreateRequest]) -> list[BlockCreateRequest]:
+        """
+        Process blocks to fix text length limits.
+        """
+        if not blocks:
+            return blocks
+
+        flattened_blocks = self._flatten_block_list(blocks)
+        return [self._process_single_block(block) for block in flattened_blocks]
+
+    def _process_single_block(self, block: BlockCreateRequest) -> BlockCreateRequest:
+        """
+        Process a single block to fix text length issues.
+        """
+        block_copy = block.model_copy(deep=True)
+
+        block_content = self._extract_block_content(block_copy)
+
+        if block_content is not None:
+            self._fix_content_text_lengths(block_content)
+
+        return block_copy
+
+    def _extract_block_content(self, block: BlockCreateRequest) -> object | None:
+        """
+        Extract the content object from a block using type-safe attribute access.
+        """
+        # Get the block's content using the block type as attribute name
+        # We assume block.type always exists as per the BlockCreateRequest structure
+        content = getattr(block, block.type, None)
+
+        # Verify it's a valid content object (has rich_text or children)
+        if content and (
+            self._is_rich_text_container(content)
+            or self._is_children_container(content)
+        ):
+            return content
+
+        return None
+
+    def _fix_content_text_lengths(self, content: object) -> None:
+        """
+        Fix text lengths in a content object and its children recursively.
+        """
+        # Process rich_text if present
+        if self._is_rich_text_container(content):
+            self._truncate_rich_text_content(content.rich_text)
+
+        # Process children recursively if present
+        if self._is_children_container(content):
+            for child in content.children:
+                child_content = self._extract_block_content(child)
+                if child_content:
+                    self._fix_content_text_lengths(child_content)
+
+    def _truncate_rich_text_content(self, rich_text_list: list[RichTextObject]) -> None:
+        """
+        Truncate text content in rich text objects that exceed the limit.
+        """
+        for rich_text_obj in rich_text_list:
+            if not self._is_text_rich_text_object(rich_text_obj):
+                continue
+
+            content = rich_text_obj.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,
+                )
+                # Truncate the content
+                rich_text_obj.text.content = content[: self.max_text_length]
+
+    def _flatten_block_list(
+        self, blocks: list[Union[BlockCreateRequest, list]]
+    ) -> list[BlockCreateRequest]:
+        """
+        Flatten a potentially nested list of blocks.
+        """
+        flattened: list[BlockCreateRequest] = []
+
+        for item in blocks:
+            if isinstance(item, list):
+                # Recursively flatten nested lists
+                flattened.extend(self._flatten_block_list(item))
+            else:
+                # Add individual block
+                flattened.append(item)
+
+        return flattened
+
+    def _is_rich_text_container(self, obj: object) -> TypeGuard[HasRichText]:
+        """Type guard to check if an object has rich_text attribute."""
+        return hasattr(obj, "rich_text") and isinstance(getattr(obj, "rich_text"), list)
+
+    def _is_children_container(self, obj: object) -> TypeGuard[HasChildren]:
+        """Type guard to check if an object has children attribute."""
+        return hasattr(obj, "children") and isinstance(getattr(obj, "children"), list)
+
+    def _is_text_rich_text_object(
+        self, rich_text_obj: RichTextObject
+    ) -> TypeGuard[RichTextObject]:
+        """Type guard to check if a RichTextObject is of type 'text' with content."""
+        return (
+            rich_text_obj.type == "text"
+            and rich_text_obj.text is not None
+            and rich_text_obj.text.content is not None
+        )

notionary/shared/__init__.py

@@ -0,0 +1,5 @@
+from .name_to_id_resolver import NameIdResolver
+
+__all__ = [
+    "NameIdResolver"
+]