notionary 0.2.27__py3-none-any.whl → 0.2.28__py3-none-any.whl

notionary/page/writer/handler/column_handler.py

@@ -1,141 +0,0 @@
-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

notionary/page/writer/handler/column_list_handler.py

@@ -1,139 +0,0 @@
-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

@@ -1,74 +0,0 @@
-import re
-
-from notionary.blocks.equation.equation_element import EquationElement
-from notionary.page.writer.handler.line_handler import (
-    LineHandler,
-    LineProcessingContext,
-)
-
-
-class EquationHandler(LineHandler):
-    r"""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

@@ -1,35 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,86 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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)