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

notionary/page/reader/handler/line_renderer.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from typing import Optional
+
+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
+
+    async def _process(self, context: BlockRenderingContext) -> None:
+        # Convert the block itself using direct element iteration
+        block_markdown = await self._convert_block_to_markdown(context)
+
+        # 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
+
+    async def _convert_block_to_markdown(
+        self, context: BlockRenderingContext
+    ) -> Optional[str]:
+        """Convert a Notion block to markdown using registered elements."""
+        for element in context.block_registry.get_elements():
+            if element.match_notion(context.block):
+                return await element.notion_to_markdown(context.block)
+        return None

notionary/page/reader/handler/numbered_list_renderer.py

@@ -0,0 +1,85 @@
+from notionary.blocks.models import Block, BlockType
+from notionary.blocks.registry.block_registry import BlockRegistry
+from notionary.page.reader.handler.base_block_renderer import BlockHandler
+from notionary.page.reader.handler.block_rendering_context import BlockRenderingContext
+
+
+class NumberedListRenderer(BlockHandler):
+    """Handles numbered list items with sequential numbering."""
+
+    def _can_handle(self, context: BlockRenderingContext) -> bool:
+        """Check if this is a numbered list item."""
+        return (
+            context.block.type == BlockType.NUMBERED_LIST_ITEM
+            and context.block.numbered_list_item is not None
+        )
+
+    async def _process(self, context: BlockRenderingContext) -> None:
+        """Process numbered list item with sequential numbering."""
+        if context.all_blocks is None or context.current_block_index is None:
+            await self._process_single_item(context, 1)
+            return
+
+        items, blocks_to_skip = self._collect_numbered_list_items(context)
+
+        markdown_parts = []
+        for i, item_context in enumerate(items, 1):
+            item_markdown = await self._process_single_item(item_context, i)
+            if item_markdown:
+                markdown_parts.append(item_markdown)
+
+        # Set result and mark how many blocks to skip
+        if markdown_parts:
+            context.markdown_result = "\n".join(markdown_parts)
+            context.was_processed = True
+            context.blocks_consumed = blocks_to_skip
+
+    def _collect_numbered_list_items(
+        self, context: BlockRenderingContext
+    ) -> tuple[list[BlockRenderingContext], int]:
+        """Collect all consecutive numbered list items starting from current position."""
+        items = []
+        current_index = context.current_block_index
+        all_blocks = context.all_blocks
+
+        # Start with current block
+        items.append(context)
+        blocks_processed = 1
+
+        # Look ahead for more numbered list items
+        for i in range(current_index + 1, len(all_blocks)):
+            block = all_blocks[i]
+
+            # Check if it's a numbered list item
+            if (
+                block.type == BlockType.NUMBERED_LIST_ITEM
+                and block.numbered_list_item is not None
+            ):
+
+                # Create context for this item
+                item_context = BlockRenderingContext(
+                    block=block,
+                    indent_level=context.indent_level,
+                    block_registry=context.block_registry,
+                    convert_children_callback=context.convert_children_callback,
+                )
+                items.append(item_context)
+                blocks_processed += 1
+            else:
+                # Not a numbered list item - stop collecting
+                break
+
+        return items, blocks_processed
+
+    async def _process_single_item(
+        self, context: BlockRenderingContext, number: int
+    ) -> str:
+        """Process a single numbered list item with the given number."""
+        from notionary.blocks.rich_text.text_inline_formatter import TextInlineFormatter
+
+        rich_text = context.block.numbered_list_item.rich_text
+        content = await TextInlineFormatter.extract_text_with_formatting(rich_text)
+
+        # Apply indentation
+        indent = "  " * context.indent_level
+        return f"{indent}{number}. {content}"

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()

notionary/page/reader/handler/toggleable_heading_renderer.py

@@ -0,0 +1,89 @@
+from notionary.blocks.toggleable_heading.toggleable_heading_element import (
+    ToggleableHeadingElement,
+)
+from notionary.blocks.types import BlockType
+from notionary.page.reader.handler import BlockHandler, BlockRenderingContext
+
+
+class ToggleableHeadingRenderer(BlockHandler):
+    """Handles toggleable heading blocks with their children content."""
+
+    def _can_handle(self, context: BlockRenderingContext) -> bool:
+        return ToggleableHeadingElement.match_notion(context.block)
+
+    def _process(self, context: BlockRenderingContext) -> None:
+        # Get the heading level and title
+        level, title = self._extract_heading_info(context.block)
+
+        if not title or level == 0:
+            return
+
+        # Create toggleable heading start line
+        prefix = "+++" + ("#" * level)
+        heading_start = f"{prefix} {title}"
+
+        # Apply indentation if needed
+        if context.indent_level > 0:
+            heading_start = self._indent_text(
+                heading_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 toggleable headings
+            )
+
+        # Create toggleable heading end line
+        heading_end = "+++"
+        if context.indent_level > 0:
+            heading_end = self._indent_text(
+                heading_end, spaces=context.indent_level * 4
+            )
+
+        # Combine heading with children content
+        if children_markdown:
+            context.markdown_result = (
+                f"{heading_start}\n{children_markdown}\n{heading_end}"
+            )
+        else:
+            context.markdown_result = f"{heading_start}\n{heading_end}"
+
+        context.was_processed = True
+
+    def _extract_heading_info(self, block) -> tuple[int, str]:
+        """Extract heading level and title from the block."""
+        # Determine heading level from block type
+        if block.type == BlockType.HEADING_1:
+            level = 1
+            heading_content = block.heading_1
+        elif block.type == BlockType.HEADING_2:
+            level = 2
+            heading_content = block.heading_2
+        elif block.type == BlockType.HEADING_3:
+            level = 3
+            heading_content = block.heading_3
+        else:
+            return 0, ""
+
+        if not heading_content or not heading_content.rich_text:
+            return level, ""
+
+        # Extract title from rich_text
+        title = ""
+        for text_obj in heading_content.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 level, title.strip()

notionary/page/reader/page_content_retriever.py

@@ -0,0 +1,81 @@
+from notionary.blocks.models import Block
+from notionary.blocks.registry.block_registry import BlockRegistry
+from notionary.page.reader.handler import (
+    BlockRenderingContext,
+    ColumnListRenderer,
+    ColumnRenderer,
+    LineRenderer,
+    NumberedListRenderer,
+    ToggleableHeadingRenderer,
+    ToggleRenderer,
+)
+from notionary.util import LoggingMixin
+
+
+class PageContentRetriever(LoggingMixin):
+    """Retrieves Notion page content and converts it to Markdown using chain of responsibility."""
+
+    def __init__(
+        self,
+        block_registry: BlockRegistry,
+    ):
+        self._block_registry = block_registry
+
+        self._setup_handler_chain()
+
+    async def convert_to_markdown(self, blocks: list[Block]) -> str:
+        """
+        Retrieve page content and convert it to Markdown.
+        Uses the chain of responsibility pattern for scalable block processing.
+        """
+        return await self._convert_blocks_to_markdown(blocks, indent_level=0)
+
+    def _setup_handler_chain(self) -> None:
+        """Setup the chain of handlers in priority order."""
+        toggle_handler = ToggleRenderer()
+        toggleable_heading_handler = ToggleableHeadingRenderer()
+        column_list_handler = ColumnListRenderer()
+        column_handler = ColumnRenderer()
+        numbered_list_handler = NumberedListRenderer()
+        regular_handler = LineRenderer()
+
+        # Chain handlers - most specific first
+        toggle_handler.set_next(toggleable_heading_handler).set_next(
+            column_list_handler
+        ).set_next(column_handler).set_next(numbered_list_handler).set_next(
+            regular_handler
+        )
+
+        self._handler_chain = toggle_handler
+
+    async def _convert_blocks_to_markdown(
+        self, blocks: list[Block], indent_level: int = 0
+    ) -> str:
+        """Convert blocks to Markdown using the handler chain."""
+        if not blocks:
+            return ""
+
+        markdown_parts = []
+        i = 0
+
+        while i < len(blocks):
+            block = blocks[i]
+            context = BlockRenderingContext(
+                block=block,
+                indent_level=indent_level,
+                block_registry=self._block_registry,
+                all_blocks=blocks,
+                current_block_index=i,
+                convert_children_callback=self._convert_blocks_to_markdown,
+            )
+
+            await self._handler_chain.handle(context)
+
+            if context.was_processed and context.markdown_result:
+                markdown_parts.append(context.markdown_result)
+
+            # Skip additional blocks if they were consumed by batch processing
+            i += max(1, context.blocks_consumed)
+
+        separator = "\n\n" if indent_level == 0 else "\n"
+        return separator.join(markdown_parts)

notionary/page/search_filter_builder.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
-from typing import Any, Dict, Optional, Literal
+
 from dataclasses import dataclass
+from typing import Any, Dict, Literal, Optional
 
 
 @dataclass

notionary/page/writer/handler/__init__.py

@@ -0,0 +1,24 @@
+from .code_handler import CodeHandler
+from .column_handler import ColumnHandler
+from .column_list_handler import ColumnListHandler
+from .equation_handler import EquationHandler
+from .line_handler import LineHandler
+from .line_processing_context import LineProcessingContext, ParentBlockContext
+from .regular_line_handler import RegularLineHandler
+from .table_handler import TableHandler
+from .toggle_handler import ToggleHandler
+from .toggleable_heading_handler import ToggleableHeadingHandler
+
+__all__ = [
+    "LineProcessingContext",
+    "ParentBlockContext",
+    "LineHandler",
+    "ColumnListHandler",
+    "ColumnHandler",
+    "ToggleableHeadingHandler",
+    "ToggleHandler",
+    "TableHandler",
+    "RegularLineHandler",
+    "CodeHandler",
+    "EquationHandler",
+]

notionary/page/writer/handler/code_handler.py

@@ -0,0 +1,72 @@
+import re
+
+from notionary.blocks.code.code_element import CodeElement
+from notionary.page.writer.handler.line_handler import (
+    LineHandler,
+    LineProcessingContext,
+)
+
+
+class CodeHandler(LineHandler):
+    """Handles code block specific logic with batching.
+
+    Markdown syntax:
+    ```language "optional caption"
+    code lines...
+    ```
+    """
+
+    def __init__(self):
+        super().__init__()
+        self._code_start_pattern = re.compile(r"^```(\w*)\s*(?:\"([^\"]*)\")?\s*$")
+        self._code_end_pattern = re.compile(r"^```\s*$")
+
+    def _can_handle(self, context: LineProcessingContext) -> bool:
+        if self._is_inside_parent_context(context):
+            return False
+        return self._is_code_start(context)
+
+    async def _process(self, context: LineProcessingContext) -> None:
+        if self._is_code_start(context):
+            await self._process_complete_code_block(context)
+            self._mark_processed(context)
+
+    def _is_code_start(self, context: LineProcessingContext) -> bool:
+        """Check if this line starts a code block."""
+        return self._code_start_pattern.match(context.line.strip()) is not None
+
+    def _is_inside_parent_context(self, context: LineProcessingContext) -> bool:
+        """Check if we're currently inside any parent context (toggle, heading, etc.)."""
+        return len(context.parent_stack) > 0
+
+    async def _process_complete_code_block(
+        self, context: LineProcessingContext
+    ) -> None:
+        """Process the entire code block in one go using CodeElement."""
+        code_lines, lines_to_consume = self._collect_code_lines(context)
+
+        block = CodeElement.create_from_markdown_block(
+            opening_line=context.line, code_lines=code_lines
+        )
+
+        if block:
+            context.lines_consumed = lines_to_consume
+            context.result_blocks.append(block)
+
+    def _collect_code_lines(
+        self, context: LineProcessingContext
+    ) -> tuple[list[str], int]:
+        """Collect lines until closing fence and return (lines, count_to_consume)."""
+        lines = []
+        for idx, ln in enumerate(context.get_remaining_lines()):
+            if self._code_end_pattern.match(ln.strip()):
+                return lines, idx + 1
+            lines.append(ln)
+        # No closing fence: consume all remaining
+        rem = context.get_remaining_lines()
+        return rem, len(rem)
+
+    def _mark_processed(self, context: LineProcessingContext) -> None:
+        """Mark context as processed and continue."""
+        context.was_processed = True
+        context.should_continue = True

notionary/page/writer/handler/column_handler.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+import re
+
+from notionary.blocks.column.column_element import ColumnElement
+from notionary.page.writer.handler.line_handler import (
+    LineHandler,
+    LineProcessingContext,
+)
+from notionary.page.writer.handler.line_processing_context import ParentBlockContext
+
+
+class ColumnHandler(LineHandler):
+    """Handles single column elements - both start and end.
+    Syntax:
+    ::: column      # Start individual column (can have optional parameters)
+    Content here
+    :::             # End column
+    """
+
+    def __init__(self):
+        super().__init__()
+        self._start_pattern = re.compile(r"^:::\s*column(\s+.*?)?\s*$", re.IGNORECASE)
+        self._end_pattern = re.compile(r"^:::\s*$")
+
+    def _can_handle(self, context: LineProcessingContext) -> bool:
+        return self._is_column_start(context) or self._is_column_end(context)
+
+    async def _process(self, context: LineProcessingContext) -> None:
+        if self._is_column_start(context):
+            await self._start_column(context)
+            self._mark_processed(context)
+            return
+
+        if self._is_column_end(context):
+            await self._finalize_column(context)
+            self._mark_processed(context)
+
+    def _is_column_start(self, context: LineProcessingContext) -> bool:
+        """Check if line starts a column (::: column)."""
+        return self._start_pattern.match(context.line.strip()) is not None
+
+    def _is_column_end(self, context: LineProcessingContext) -> bool:
+        """Check if we need to end a single column (:::)."""
+        if not self._end_pattern.match(context.line.strip()):
+            return False
+
+        if not context.parent_stack:
+            return False
+
+        # Check if top of stack is a Column (not ColumnList)
+        current_parent = context.parent_stack[-1]
+        return issubclass(current_parent.element_type, ColumnElement)
+
+    async def _start_column(self, context: LineProcessingContext) -> None:
+        """Start a new column."""
+        # Create Column block directly - much more efficient!
+        column_element = ColumnElement()
+        result = await column_element.markdown_to_notion(context.line)
+        if not result:
+            return
+
+        block = result
+
+        # Push to parent stack
+        parent_context = ParentBlockContext(
+            block=block,
+            element_type=ColumnElement,
+            child_lines=[],
+        )
+        context.parent_stack.append(parent_context)
+
+    async def _finalize_column(self, context: LineProcessingContext) -> None:
+        """Finalize a single column and add it to the column list or result."""
+        column_context = context.parent_stack.pop()
+        await self._assign_column_children_if_any(column_context, context)
+
+        if context.parent_stack:
+            parent = context.parent_stack[-1]
+            from notionary.blocks.column.column_list_element import ColumnListElement
+
+            if issubclass(parent.element_type, ColumnListElement):
+                # Add to parent using the new system
+                parent.add_child_block(column_context.block)
+                return
+
+        # Fallback: no parent or parent is not ColumnList
+        context.result_blocks.append(column_context.block)
+
+    async def _assign_column_children_if_any(
+        self, column_context: ParentBlockContext, context: LineProcessingContext
+    ) -> None:
+        """Collect and assign any children blocks inside this column."""
+        all_children = []
+
+        # Process text lines
+        if column_context.child_lines:
+            children_text = "\n".join(column_context.child_lines)
+            text_blocks = await self._convert_children_text(
+                children_text, context.block_registry
+            )
+            all_children.extend(text_blocks)
+
+        # Add direct child blocks (like processed toggles)
+        if column_context.child_blocks:
+            all_children.extend(column_context.child_blocks)
+
+        column_context.block.column.children = all_children
+
+    def _try_add_to_parent_column_list(
+        self, column_context: ParentBlockContext, context: LineProcessingContext
+    ) -> bool:
+        """If the previous stack element is a ColumnList, append column and return True."""
+        if not context.parent_stack:
+            return False
+
+        parent = context.parent_stack[-1]
+        from notionary.blocks.column.column_list_element import ColumnListElement
+
+        if not issubclass(parent.element_type, ColumnListElement):
+            return False
+
+        parent.block.column_list.children.append(column_context.block)
+        return True
+
+    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,
+        )
+
+        if not text.strip():
+            return []
+
+        child_converter = MarkdownToNotionConverter(block_registry)
+        return await child_converter.process_lines(text)
+
+    def _mark_processed(self, context: LineProcessingContext) -> None:
+        """Mark context as processed and signal to continue."""
+        context.was_processed = True
+        context.should_continue = True