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

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,69 @@
+from notionary.blocks.models import Block
+from notionary.blocks.registry.block_registry import BlockRegistry
+from notionary.page.reader.handler import (
+    BlockRenderingContext,
+    ColumnListRenderer,
+    ColumnRenderer,
+    LineRenderer,
+    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 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()
+        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(regular_handler)
+
+        self._handler_chain = toggle_handler
+
+    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 = []
+
+        for block in blocks:
+            context = BlockRenderingContext(
+                block=block,
+                indent_level=indent_level,
+                block_registry=self._block_registry,
+            )
+
+            self._handler_chain.handle(context)
+
+            if context.was_processed and context.markdown_result:
+                markdown_parts.append(context.markdown_result)
+
+        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,22 @@
+from .code_handler import CodeHandler
+from .column_handler import ColumnHandler
+from .column_list_handler import ColumnListHandler
+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",
+]

notionary/page/writer/handler/code_handler.py

@@ -0,0 +1,100 @@
+import re
+
+from notionary.blocks.code.code_element import CodeElement
+from notionary.blocks.rich_text.rich_text_models import RichTextObject
+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)
+
+    def _process(self, context: LineProcessingContext) -> None:
+        if self._is_code_start(context):
+            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
+
+    def _process_complete_code_block(self, context: LineProcessingContext) -> None:
+        """Process the entire code block in one go."""
+        # Extract language and caption from opening fence
+        language, caption = self._extract_fence_info(context.line)
+
+        # Create base code block
+        result = CodeElement.markdown_to_notion(f"```{language}")
+        if not result:
+            return
+
+        block = result[0] if isinstance(result, list) else result
+
+        code_lines, lines_to_consume = self._collect_code_lines(context)
+
+        self._set_block_content(block, code_lines)
+
+        self._set_block_caption(block, caption)
+
+        context.lines_consumed = lines_to_consume
+        context.result_blocks.append(block)
+
+    def _extract_fence_info(self, line: str) -> tuple[str, str]:
+        """Extract the language and optional caption from a code fence."""
+        match = self._code_start_pattern.match(line.strip())
+        lang = match.group(1) if match and match.group(1) else ""
+        cap = match.group(2) if match and match.group(2) else ""
+        return lang, cap
+
+    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
+
+    def _set_block_content(self, block, code_lines: list[str]) -> None:
+        """Set the code rich_text content on the block."""
+        if not code_lines:
+            return
+        content = "\n".join(code_lines)
+        block.code.rich_text = [RichTextObject.for_code_block(content)]
+
+    def _set_block_caption(self, block, caption: str) -> None:
+        """Append caption to the code block if provided."""
+        if not caption:
+            return
+        block.code.caption.append(RichTextObject.for_code_block(caption))

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)
+
+    def _process(self, context: LineProcessingContext) -> None:
+        if self._is_column_start(context):
+            self._start_column(context)
+            self._mark_processed(context)
+            return
+
+        if self._is_column_end(context):
+            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)
+
+    def _start_column(self, context: LineProcessingContext) -> None:
+        """Start a new column."""
+        # Create Column block directly - much more efficient!
+        column_element = ColumnElement()
+        result = column_element.markdown_to_notion(context.line)
+        if not result:
+            return
+
+        block = result if not isinstance(result, list) else result[0]
+
+        # Push to parent stack
+        parent_context = ParentBlockContext(
+            block=block,
+            element_type=ColumnElement,
+            child_lines=[],
+        )
+        context.parent_stack.append(parent_context)
+
+    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()
+        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)
+
+    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 = 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
+
+    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 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

notionary/page/writer/handler/column_list_handler.py

@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+import re
+
+from notionary.blocks.column.column_list_element import ColumnListElement
+from notionary.page.writer.handler.line_handler import (
+    LineHandler,
+    LineProcessingContext,
+)
+
+from notionary.page.writer.handler.line_processing_context import ParentBlockContext
+
+class ColumnListHandler(LineHandler):
+    """Handles column list elements - both start and end.
+    Syntax:
+    ::: columns     # Start column list
+    ::: column      # Individual column
+    Content here
+    :::             # End column
+    ::: column      # Another column
+    More content
+    :::             # End column
+    :::             # End column list
+    """
+
+    def __init__(self):
+        super().__init__()
+        self._start_pattern = re.compile(r"^:::\s*columns?\s*$", re.IGNORECASE)
+        self._end_pattern = re.compile(r"^:::\s*$")
+
+    def _can_handle(self, context: LineProcessingContext) -> bool:
+        return self._is_column_list_start(context) or self._is_column_list_end(context)
+
+    def _process(self, context: LineProcessingContext) -> None:
+        if self._is_column_list_start(context):
+            self._start_column_list(context)
+            context.was_processed = True
+            context.should_continue = True
+            return
+
+        if self._is_column_list_end(context):
+            self._finalize_column_list(context)
+            context.was_processed = True
+            context.should_continue = True
+
+    def _is_column_list_start(self, context: LineProcessingContext) -> bool:
+        """Check if line starts a column list (::: columns)."""
+        return self._start_pattern.match(context.line.strip()) is not None
+
+    def _is_column_list_end(self, context: LineProcessingContext) -> bool:
+        """Check if we need to end a column list (:::)."""
+        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 ColumnList
+        current_parent = context.parent_stack[-1]
+        return issubclass(current_parent.element_type, ColumnListElement)
+
+    def _start_column_list(self, context: LineProcessingContext) -> None:
+        """Start a new column list."""
+        # Create ColumnList block using the element from registry
+        column_list_element = None
+        for element in context.block_registry.get_elements():
+            if issubclass(element, ColumnListElement):
+                column_list_element = element
+                break
+
+        if not column_list_element:
+            return
+
+        # Create the block
+        result = column_list_element.markdown_to_notion(context.line)
+        if not result:
+            return
+
+        block = result if not isinstance(result, list) else result[0]
+
+        # Push to parent stack
+        parent_context = ParentBlockContext(
+            block=block,
+            element_type=column_list_element,
+            child_lines=[],
+        )
+        context.parent_stack.append(parent_context)
+
+    def _finalize_column_list(self, context: LineProcessingContext) -> None:
+        """Finalize a column list and add it to result_blocks."""
+        column_list_context = context.parent_stack.pop()
+        self._assign_column_list_children_if_any(column_list_context, context)
+
+        # Check if we have a parent context to add this column_list to
+        if context.parent_stack:
+            # Add this column_list as a child block to the parent (like Toggle)
+            parent_context = context.parent_stack[-1]
+            parent_context.add_child_block(column_list_context.block)
+
+        else:
+            # No parent, add to top level
+            context.result_blocks.append(column_list_context.block)
+
+    def _assign_column_list_children_if_any(
+        self, column_list_context: ParentBlockContext, context: LineProcessingContext
+    ) -> None:
+        """Collect and assign any column children blocks inside this column list."""
+        all_children = []
+
+        # Process text lines
+        if column_list_context.child_lines:
+            children_text = "\n".join(column_list_context.child_lines)
+            children_blocks = self._convert_children_text(
+                children_text, context.block_registry
+            )
+            all_children.extend(children_blocks)
+
+        if column_list_context.child_blocks:
+            all_children.extend(column_list_context.child_blocks)
+
+        # Filter only column blocks
+        column_children = [
+            block
+            for block in all_children
+            if hasattr(block, "column") and getattr(block, "type", None) == "column"
+        ]
+        column_list_context.block.column_list.children = column_children
+
+    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 child_converter._process_lines(text)

notionary/page/writer/handler/line_handler.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Optional
+
+from notionary.page.writer.handler.line_processing_context import LineProcessingContext
+
+
+class LineHandler(ABC):
+    """Abstract base class for line handlers."""
+
+    def __init__(self):
+        self._next_handler: Optional[LineHandler] = None
+
+    def set_next(self, handler: LineHandler) -> LineHandler:
+        """Set the next handler in the chain."""
+        self._next_handler = handler
+        return handler
+
+    def handle(self, context: LineProcessingContext) -> None:
+        """Handle the line 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: LineProcessingContext) -> bool:
+        """Check if this handler can process the current line."""
+        pass
+
+    @abstractmethod
+    def _process(self, context: LineProcessingContext) -> None:
+        """Process the line and update context."""
+        pass

notionary/page/writer/handler/line_processing_context.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Optional
+
+from notionary.blocks.base_block_element import BaseBlockElement
+from notionary.blocks.models import BlockCreateRequest
+from notionary.blocks.registry.block_registry import BlockRegistry
+
+
+@dataclass
+class ParentBlockContext:
+    """Context for a block that expects children."""
+
+    block: BlockCreateRequest
+    element_type: BaseBlockElement
+    child_lines: list[str]
+    child_blocks: list[BlockCreateRequest] = field(default_factory=list)
+
+    def add_child_line(self, content: str):
+        """Adds a child line."""
+        self.child_lines.append(content)
+
+    def add_child_block(self, block: BlockCreateRequest):
+        """Adds a processed child block."""
+        self.child_blocks.append(block)
+
+    def has_children(self) -> bool:
+        """Checks if children have been collected."""
+        return len(self.child_lines) > 0 or len(self.child_blocks) > 0
+
+
+@dataclass
+class LineProcessingContext:
+    """Context that gets passed through the handler chain."""
+
+    line: str
+    result_blocks: list[BlockCreateRequest]
+    parent_stack: list[ParentBlockContext]
+    block_registry: BlockRegistry
+
+    all_lines: Optional[list[str]] = None
+    current_line_index: Optional[int] = None
+    lines_consumed: int = 0
+
+    # Result indicators
+    was_processed: bool = False
+    should_continue: bool = False
+
+    def get_remaining_lines(self) -> list[str]:
+        """Get all remaining lines from current position."""
+        if self.all_lines is None or self.current_line_index is None:
+            return []
+        return self.all_lines[self.current_line_index + 1 :]