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

notionary/page/writer/handler/toggle_handler.py

@@ -1,159 +0,0 @@
-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__()
-        # Updated: Support both "+++title" and "+++ title"
-        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 or +++Title)."""
-        line = context.line.strip()
-
-        # Must match our pattern (now allows optional space)
-        if not self._start_pattern.match(line):
-            return False
-
-        # But NOT match toggleable heading pattern (has # after +++)
-        # Updated: Support both "+++#title" and "+++ # title"
-        toggleable_heading_pattern = re.compile(
-            r"^[+]{3}\s*#{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

notionary/page/writer/handler/toggleable_heading_handler.py

@@ -1,174 +0,0 @@
-from __future__ import annotations
-
-import re
-
-from notionary.blocks.models import BlockCreateRequest
-from notionary.blocks.toggleable_heading.toggleable_heading_element import (
-    ToggleableHeadingElement,
-)
-from notionary.blocks.types import BlockType
-from notionary.page.writer.handler import (
-    LineHandler,
-    LineProcessingContext,
-    ParentBlockContext,
-)
-
-
-class ToggleableHeadingHandler(LineHandler):
-    """Handles toggleable heading blocks with +++# syntax."""
-
-    def __init__(self):
-        super().__init__()
-        # Updated: Support both "+++# title" and "+++#title"
-        self._start_pattern = re.compile(
-            r"^[+]{3}\s*(?P<level>#{1,3})\s*(.+)$", re.IGNORECASE
-        )
-        # +++
-        self._end_pattern = re.compile(r"^[+]{3}\s*$")
-
-    def _can_handle(self, context: LineProcessingContext) -> bool:
-        return (
-            self._is_toggleable_heading_start(context)
-            or self._is_toggleable_heading_end(context)
-            or self._is_toggleable_heading_content(context)
-        )
-
-    async def _process(self, context: LineProcessingContext) -> None:
-        """Process toggleable heading start, end, or content with unified handling."""
-
-        async def _handle(action):
-            await action(context)
-            context.was_processed = True
-            context.should_continue = True
-            return True
-
-        if self._is_toggleable_heading_start(context):
-            return await _handle(self._start_toggleable_heading)
-        if self._is_toggleable_heading_end(context):
-            return await _handle(self._finalize_toggleable_heading)
-        if self._is_toggleable_heading_content(context):
-            return await _handle(self._add_toggleable_heading_content)
-
-    def _is_toggleable_heading_start(self, context: LineProcessingContext) -> bool:
-        """Check if line starts a toggleable heading (+++# "Title" or +++#"Title")."""
-        return self._start_pattern.match(context.line.strip()) is not None
-
-    def _is_toggleable_heading_end(self, context: LineProcessingContext) -> bool:
-        """Check if we need to end a toggleable heading (+++)."""
-        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 ToggleableHeading
-        current_parent = context.parent_stack[-1]
-        return issubclass(current_parent.element_type, ToggleableHeadingElement)
-
-    async def _start_toggleable_heading(self, context: LineProcessingContext) -> None:
-        """Start a new toggleable heading block."""
-        toggleable_heading_element = ToggleableHeadingElement()
-
-        # Create the block
-        result = await toggleable_heading_element.markdown_to_notion(context.line)
-        if not result:
-            return
-
-        block = result
-
-        # Push to parent stack
-        parent_context = ParentBlockContext(
-            block=block,
-            element_type=ToggleableHeadingElement,
-            child_lines=[],
-        )
-        context.parent_stack.append(parent_context)
-
-    def _is_toggleable_heading_content(self, context: LineProcessingContext) -> bool:
-        """Check if we're inside a toggleable heading 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, ToggleableHeadingElement):
-            return False
-
-        # Handle all content inside toggleable heading (not start/end patterns)
-        line = context.line.strip()
-        return not (self._start_pattern.match(line) or self._end_pattern.match(line))
-
-    async def _add_toggleable_heading_content(
-        self, context: LineProcessingContext
-    ) -> None:
-        """Add content to the current toggleable heading context."""
-        context.parent_stack[-1].add_child_line(context.line)
-
-    async def _finalize_toggleable_heading(
-        self, context: LineProcessingContext
-    ) -> None:
-        """Finalize a toggleable heading block and add it to result_blocks."""
-        heading_context = context.parent_stack.pop()
-
-        if heading_context.has_children():
-            all_children = await self._get_all_children(
-                heading_context, context.block_registry
-            )
-            self._assign_heading_children(heading_context.block, all_children)
-
-        # Check if we have a parent context to add this heading to
-        if context.parent_stack:
-            # Add this heading as a child block to the parent
-            parent_context = context.parent_stack[-1]
-            if hasattr(parent_context, "add_child_block"):
-                parent_context.add_child_block(heading_context.block)
-            else:
-                # Fallback: add to result_blocks for backward compatibility
-                context.result_blocks.append(heading_context.block)
-        else:
-            # No parent, add to top level
-            context.result_blocks.append(heading_context.block)
-
-    async def _get_all_children(
-        self, parent_context: ParentBlockContext, 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
-        if hasattr(parent_context, "child_blocks") and parent_context.child_blocks:
-            children_blocks.extend(parent_context.child_blocks)
-
-        return children_blocks
-
-    def _assign_heading_children(
-        self, parent_block: BlockCreateRequest, children: list[BlockCreateRequest]
-    ) -> None:
-        """Assign children to toggleable heading blocks."""
-        block_type = parent_block.type
-
-        if block_type == BlockType.HEADING_1:
-            parent_block.heading_1.children = children
-        elif block_type == BlockType.HEADING_2:
-            parent_block.heading_2.children = children
-        elif block_type == BlockType.HEADING_3:
-            parent_block.heading_3.children = 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/markdown_to_notion_converter.py

@@ -1,139 +0,0 @@
-from notionary.blocks.models import BlockCreateRequest
-from notionary.blocks.registry.block_registry import BlockRegistry
-from notionary.page.writer.handler import (
-    CodeHandler,
-    ColumnHandler,
-    ColumnListHandler,
-    EquationHandler,
-    LineProcessingContext,
-    ParentBlockContext,
-    RegularLineHandler,
-    TableHandler,
-    ToggleableHeadingHandler,
-    ToggleHandler,
-)
-from notionary.page.writer.notion_text_length_processor import (
-    NotionTextLengthProcessor,
-)
-from notionary.util.logging_mixin import LoggingMixin
-
-
-class HandlerOrderValidationError(RuntimeError):
-    """Raised when handler chain order is incorrect."""
-
-    pass
-
-
-class MarkdownToNotionConverter(LoggingMixin):
-    """Converts Markdown text to Notion API block format with unified stack-based processing."""
-
-    def __init__(self, block_registry: BlockRegistry) -> None:
-        self._block_registry = block_registry
-        self._text_length_post_processor = NotionTextLengthProcessor()
-        self._setup_handler_chain()
-
-    async def convert(self, markdown_text: str) -> list[BlockCreateRequest]:
-        if not markdown_text.strip():
-            return []
-
-        all_blocks = await self.process_lines(markdown_text)
-
-        # Apply text length post-processing (truncation)
-        all_blocks = self._text_length_post_processor.process(all_blocks)
-
-        return all_blocks
-
-    async def process_lines(self, text: str) -> list[BlockCreateRequest]:
-        lines = text.split("\n")
-        result_blocks: list[BlockCreateRequest] = []
-        parent_stack: list[ParentBlockContext] = []
-
-        i = 0
-        while i < len(lines):
-            line = lines[i]
-
-            context = LineProcessingContext(
-                line=line,
-                result_blocks=result_blocks,
-                parent_stack=parent_stack,
-                block_registry=self._block_registry,
-                all_lines=lines,
-                current_line_index=i,
-                lines_consumed=0,
-            )
-
-            await self._handler_chain.handle(context)
-
-            # Skip consumed lines
-            i += 1 + context.lines_consumed
-
-            if context.should_continue:
-                continue
-
-        return result_blocks
-
-    def _setup_handler_chain(self) -> None:
-        code_handler = CodeHandler()
-        equation_handler = EquationHandler()
-        table_handler = TableHandler()
-        column_list_handler = ColumnListHandler()
-        column_handler = ColumnHandler()
-        toggle_handler = ToggleHandler()
-        toggleable_heading_handler = ToggleableHeadingHandler()
-        regular_handler = RegularLineHandler()
-
-        # Create handler chain
-        code_handler.set_next(equation_handler).set_next(table_handler).set_next(
-            column_handler
-        ).set_next(column_list_handler).set_next(toggleable_heading_handler).set_next(
-            toggle_handler
-        ).set_next(
-            regular_handler
-        )
-
-        self._handler_chain = code_handler
-
-        # Validate critical order - only log/error if something is wrong
-        self._validate_handler_order(
-            [
-                code_handler,
-                equation_handler,
-                table_handler,
-                column_handler,
-                column_list_handler,
-                toggleable_heading_handler,
-                toggle_handler,
-                regular_handler,
-            ]
-        )
-
-    def _validate_handler_order(self, handlers) -> None:
-        """Validate critical handler positioning rules - only warns/errors when needed."""
-        handler_classes = [handler.__class__ for handler in handlers]
-
-        # Critical: ColumnHandler MUST come before ColumnListHandler
-        try:
-            column_handler_pos = handler_classes.index(ColumnHandler)
-            column_list_handler_pos = handler_classes.index(ColumnListHandler)
-
-            if column_handler_pos >= column_list_handler_pos:
-                error_msg = (
-                    f"CRITICAL: ColumnHandler must come BEFORE ColumnListHandler. "
-                    f"Current order: ColumnHandler at {column_handler_pos}, ColumnListHandler at {column_list_handler_pos}. "
-                    f"Fix: Move ColumnHandler before ColumnListHandler in _setup_handler_chain()"
-                )
-                self.logger.error(error_msg)
-                raise HandlerOrderValidationError(error_msg)
-
-        except ValueError as e:
-            error_msg = f"Missing required handlers in chain: {e}"
-            self.logger.error(error_msg)
-            raise HandlerOrderValidationError(error_msg)
-
-        # Critical: RegularLineHandler should be last (fallback)
-        if handler_classes[-1] != RegularLineHandler:
-            error_msg = (
-                f"WARNING: RegularLineHandler should be last handler (fallback), "
-                f"but {handler_classes[-1].__name__} is at the end"
-            )
-            self.logger.warning(error_msg)

notionary/page/writer/markdown_to_notion_converter_context.py

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

notionary/page/writer/notion_text_length_processor.py

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

notionary/schemas/__init__.py

@@ -1,3 +0,0 @@
-from .base import NotionContentSchema
-
-__all__ = ["NotionContentSchema"]