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

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)
+
+    async def _process(self, context: LineProcessingContext) -> None:
+        if self._is_column_list_start(context):
+            await self._start_column_list(context)
+            context.was_processed = True
+            context.should_continue = True
+            return
+
+        if self._is_column_list_end(context):
+            await 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)
+
+    async 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 = await column_list_element.markdown_to_notion(context.line)
+        if not result:
+            return
+
+        block = result
+
+        # Push to parent stack
+        parent_context = ParentBlockContext(
+            block=block,
+            element_type=column_list_element,
+            child_lines=[],
+        )
+        context.parent_stack.append(parent_context)
+
+    async 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()
+        await 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)
+
+    async 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 = await 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
+
+    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)

notionary/page/writer/handler/equation_handler.py

@@ -0,0 +1,74 @@
+import re
+
+from notionary.blocks.equation.equation_element import EquationElement
+from notionary.page.writer.handler.line_handler import (
+    LineHandler,
+    LineProcessingContext,
+)
+
+
+class EquationHandler(LineHandler):
+    """Handles equation block specific logic with batching.
+
+    Markdown syntax:
+    $$
+    \sum_{i=1}^n i = \frac{n(n+1)}{2} \\
+    \sum_{i=1}^n i^2 = \frac{n(n+1)(2n+1)}{6} \\
+    \sum_{i=1}^n i^3 = \left(\frac{n(n+1)}{2}\right)^2
+    $$
+    """
+
+    def __init__(self):
+        super().__init__()
+        self._equation_start_pattern = re.compile(r"^\$\$\s*$")
+        self._equation_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_equation_start(context)
+
+    async def _process(self, context: LineProcessingContext) -> None:
+        if self._is_equation_start(context):
+            await self._process_complete_equation_block(context)
+            self._mark_processed(context)
+
+    def _is_equation_start(self, context: LineProcessingContext) -> bool:
+        """Check if this line starts an equation block."""
+        return self._equation_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_equation_block(
+        self, context: LineProcessingContext
+    ) -> None:
+        """Process the entire equation block in one go using EquationElement."""
+        equation_lines, lines_to_consume = self._collect_equation_lines(context)
+
+        block = EquationElement.create_from_markdown_block(
+            opening_line=context.line, equation_lines=equation_lines
+        )
+
+        if block:
+            context.lines_consumed = lines_to_consume
+            context.result_blocks.append(block)
+
+    def _collect_equation_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._equation_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/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
+
+    async def handle(self, context: LineProcessingContext) -> None:
+        """Handle the line or pass to next handler."""
+        if self._can_handle(context):
+            await self._process(context)
+        elif self._next_handler:
+            await self._next_handler.handle(context)
+
+    @abstractmethod
+    def _can_handle(self, context: LineProcessingContext) -> bool:
+        """Check if this handler can process the current line."""
+        pass
+
+    @abstractmethod
+    async 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 :]

notionary/page/writer/handler/regular_line_handler.py

@@ -0,0 +1,86 @@
+from notionary.blocks.column.column_element import ColumnElement
+from notionary.blocks.column.column_list_element import ColumnListElement
+from notionary.page.writer.handler import LineHandler, LineProcessingContext
+
+
+class RegularLineHandler(LineHandler):
+    """Handles regular lines - respects parent contexts like columns."""
+
+    def _can_handle(self, context: LineProcessingContext) -> bool:
+        return context.line.strip()
+
+    async def _process(self, context: LineProcessingContext) -> None:
+        if self._is_in_column_context(context):
+            self._add_to_column_context(context)
+            context.was_processed = True
+            context.should_continue = True
+            return
+
+        block_created = await self._process_single_line_content(context)
+        if not block_created:
+            await self._process_as_paragraph(context)
+
+        context.was_processed = True
+
+    def _is_in_column_context(self, context: LineProcessingContext) -> bool:
+        """Check if we're inside a Column/ColumnList context."""
+        if not context.parent_stack:
+            return False
+
+        current_parent = context.parent_stack[-1]
+        return issubclass(
+            current_parent.element_type, (ColumnListElement, ColumnElement)
+        )
+
+    def _add_to_column_context(self, context: LineProcessingContext) -> None:
+        """Add line as child to the current Column context."""
+        context.parent_stack[-1].add_child_line(context.line)
+
+    async def _process_single_line_content(
+        self, context: LineProcessingContext
+    ) -> bool:
+        """Process a regular line for simple elements (lists, etc.)."""
+        specialized_elements = self._get_specialized_elements()
+
+        for element in context.block_registry.get_elements():
+
+            if issubclass(element, specialized_elements):
+                continue
+
+            result = await element.markdown_to_notion(context.line)
+            if not result:
+                continue
+
+            context.result_blocks.append(result)
+
+            return True
+
+        return False
+
+    async def _process_as_paragraph(self, context: LineProcessingContext) -> None:
+        """Process a line as a paragraph."""
+        from notionary.blocks.paragraph.paragraph_element import ParagraphElement
+
+        paragraph_element = ParagraphElement()
+        result = await paragraph_element.markdown_to_notion(context.line)
+
+        if result:
+            context.result_blocks.append(result)
+
+    def _get_specialized_elements(self):
+        """Get tuple of elements that have specialized handlers."""
+        from notionary.blocks.code import CodeElement
+        from notionary.blocks.paragraph import ParagraphElement
+        from notionary.blocks.table import TableElement
+        from notionary.blocks.toggle import ToggleElement
+        from notionary.blocks.toggleable_heading import ToggleableHeadingElement
+
+        return (
+            ColumnListElement,
+            ColumnElement,
+            ToggleElement,
+            ToggleableHeadingElement,
+            TableElement,
+            CodeElement,
+            ParagraphElement,
+        )

notionary/page/writer/handler/table_handler.py

@@ -0,0 +1,66 @@
+import re
+
+from notionary.blocks.table.table_element import TableElement
+from notionary.page.writer.handler import LineHandler, LineProcessingContext
+
+
+class TableHandler(LineHandler):
+    """Handles table specific logic with batching."""
+
+    def __init__(self):
+        super().__init__()
+        self._table_row_pattern = re.compile(r"^\s*\|(.+)\|\s*$")
+        self._separator_pattern = re.compile(r"^\s*\|([\s\-:|]+)\|\s*$")
+
+    def _can_handle(self, context: LineProcessingContext) -> bool:
+        if self._is_inside_parent_context(context):
+            return False
+        return self._is_table_start(context)
+
+    async def _process(self, context: LineProcessingContext) -> None:
+        if not self._is_table_start(context):
+            return
+
+        await self._process_complete_table(context)
+        context.was_processed = True
+        context.should_continue = True
+
+    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 _is_table_start(self, context: LineProcessingContext) -> bool:
+        """Check if this line starts a table."""
+        return self._table_row_pattern.match(context.line.strip()) is not None
+
+    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()
+        lines_to_consume = 0
+
+        # Find all consecutive table rows
+        for i, line in enumerate(remaining_lines):
+            line_stripped = line.strip()
+            if not line_stripped:
+                # Empty line - continue to allow for spacing in tables
+                table_lines.append(line)
+                continue
+
+            if self._table_row_pattern.match(
+                line_stripped
+            ) or self._separator_pattern.match(line_stripped):
+                table_lines.append(line)
+            else:
+                # Not a table line - stop here
+                lines_to_consume = i
+                break
+        else:
+            lines_to_consume = len(remaining_lines)
+
+        block = await TableElement.create_from_markdown_table(table_lines)
+
+        if block:
+            context.lines_consumed = lines_to_consume
+            context.result_blocks.append(block)

notionary/page/writer/handler/toggle_handler.py

@@ -0,0 +1,155 @@
+from __future__ import annotations
+
+import re
+
+from notionary.blocks.toggle.toggle_element import ToggleElement
+from notionary.page.writer.handler import (
+    LineHandler,
+    LineProcessingContext,
+    ParentBlockContext,
+)
+
+
+class ToggleHandler(LineHandler):
+    """Handles regular toggle blocks with ultra-simplified +++ syntax."""
+
+    def __init__(self):
+        super().__init__()
+        self._start_pattern = re.compile(r"^[+]{3}\s+(.+)$", re.IGNORECASE)
+        self._end_pattern = re.compile(r"^[+]{3}\s*$")
+
+    def _can_handle(self, context: LineProcessingContext) -> bool:
+        return (
+            self._is_toggle_start(context)
+            or self._is_toggle_end(context)
+            or self._is_toggle_content(context)
+        )
+
+    async def _process(self, context: LineProcessingContext) -> None:
+        # Explicit, readable branches (small duplication is acceptable)
+        if self._is_toggle_start(context):
+            await self._start_toggle(context)
+            context.was_processed = True
+            context.should_continue = True
+
+        if self._is_toggle_end(context):
+            await self._finalize_toggle(context)
+            context.was_processed = True
+            context.should_continue = True
+
+        if self._is_toggle_content(context):
+            self._add_toggle_content(context)
+            context.was_processed = True
+            context.should_continue = True
+
+    def _is_toggle_start(self, context: LineProcessingContext) -> bool:
+        """Check if line starts a toggle (+++ Title)."""
+        line = context.line.strip()
+
+        # Must match our pattern
+        if not self._start_pattern.match(line):
+            return False
+
+        # But NOT match toggleable heading pattern (has # after +++)
+        toggleable_heading_pattern = re.compile(r"^[+]{3}#{1,3}\s+.+$", re.IGNORECASE)
+        if toggleable_heading_pattern.match(line):
+            return False
+
+        return True
+
+    def _is_toggle_end(self, context: LineProcessingContext) -> bool:
+        """Check if we need to end a toggle (+++)."""
+        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 Toggle
+        current_parent = context.parent_stack[-1]
+        return issubclass(current_parent.element_type, ToggleElement)
+
+    async def _start_toggle(self, context: LineProcessingContext) -> None:
+        """Start a new toggle block."""
+        toggle_element = ToggleElement()
+
+        # Create the block
+        result = await toggle_element.markdown_to_notion(context.line)
+        if not result:
+            return
+
+        block = result
+
+        # Push to parent stack
+        parent_context = ParentBlockContext(
+            block=block,
+            element_type=ToggleElement,
+            child_lines=[],
+        )
+        context.parent_stack.append(parent_context)
+
+    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 = await self._get_all_children(
+                toggle_context, context.block_registry
+            )
+            toggle_context.block.toggle.children = all_children
+
+        # Check if we have a parent context to add this toggle to
+        if context.parent_stack:
+            # Add this toggle as a child block to the parent
+            parent_context = context.parent_stack[-1]
+            parent_context.add_child_block(toggle_context.block)
+        else:
+            # No parent, add to top level
+            context.result_blocks.append(toggle_context.block)
+
+    def _is_toggle_content(self, context: LineProcessingContext) -> bool:
+        """Check if we're inside a toggle context and should handle content."""
+        if not context.parent_stack:
+            return False
+
+        current_parent = context.parent_stack[-1]
+        if not issubclass(current_parent.element_type, ToggleElement):
+            return False
+
+        # Handle all content inside toggle (not start/end patterns)
+        line = context.line.strip()
+        return not (self._start_pattern.match(line) or self._end_pattern.match(line))
+
+    def _add_toggle_content(self, context: LineProcessingContext) -> None:
+        """Add content to the current toggle context."""
+        context.parent_stack[-1].add_child_line(context.line)
+
+    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)
+
+    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 = await self._convert_children_text(
+                children_text, block_registry
+            )
+            children_blocks.extend(text_blocks)
+
+        # Add direct blocks (like processed columns)
+        if hasattr(parent_context, "child_blocks") and parent_context.child_blocks:
+            children_blocks.extend(parent_context.child_blocks)
+
+        return children_blocks