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

notionary/page/writer/handler/toggleable_heading_handler.py

@@ -0,0 +1,173 @@
+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__()
+        self._start_pattern = re.compile(
+            r"^[+]{3}(?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")."""
+        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

@@ -0,0 +1,95 @@
+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.markdown_to_notion_formatting_post_processor import (
+    MarkdownToNotionFormattingPostProcessor,
+)
+from notionary.page.writer.notion_text_length_processor import (
+    NotionTextLengthProcessor,
+)
+
+
+class MarkdownToNotionConverter:
+    """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._formatting_post_processor = MarkdownToNotionFormattingPostProcessor()
+        self._text_length_post_processor = NotionTextLengthProcessor()
+
+        self._setup_handler_chain()
+
+    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()
+
+        # register more specific elements first
+        code_handler.set_next(equation_handler).set_next(table_handler).set_next(
+            column_list_handler
+        ).set_next(column_handler).set_next(toggleable_heading_handler).set_next(
+            toggle_handler
+        ).set_next(
+            regular_handler
+        )
+
+        self._handler_chain = code_handler
+
+    async def convert(self, markdown_text: str) -> list[BlockCreateRequest]:
+        if not markdown_text.strip():
+            return []
+
+        all_blocks = await self.process_lines(markdown_text)
+
+        # Apply formatting post-processing (empty paragraphs)
+        all_blocks = self._formatting_post_processor.process(all_blocks)
+
+        # 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

notionary/page/writer/markdown_to_notion_converter_context.py

@@ -0,0 +1,30 @@
+# 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/markdown_to_notion_formatting_post_processor.py

@@ -0,0 +1,73 @@
+"""
+Post-processor for handling block formatting in Markdown to Notion conversion.
+
+Handles block formatting tasks like adding empty paragraphs before media blocks
+and other formatting-related post-processing.
+"""
+
+from typing import cast
+
+from notionary.blocks.models import BlockCreateRequest
+from notionary.blocks.types import BlockType
+from notionary.blocks.paragraph.paragraph_models import (
+    CreateParagraphBlock,
+    ParagraphBlock,
+)
+
+
+class MarkdownToNotionFormattingPostProcessor:
+    """Handles block formatting post-processing for Notion blocks."""
+
+    BLOCKS_NEEDING_EMPTY_PARAGRAPH: set[BlockType] = {
+        BlockType.DIVIDER,
+        BlockType.FILE,
+        BlockType.IMAGE,
+        BlockType.PDF,
+        BlockType.VIDEO,
+    }
+
+    def process(self, blocks: list[BlockCreateRequest]) -> list[BlockCreateRequest]:
+        """Process blocks with all formatting steps."""
+        if not blocks:
+            return blocks
+
+        return self._add_empty_paragraphs_for_media_blocks(blocks)
+
+    def _add_empty_paragraphs_for_media_blocks(
+        self, blocks: list[BlockCreateRequest]
+    ) -> list[BlockCreateRequest]:
+        """Add empty paragraphs before configured block types."""
+        if not blocks:
+            return blocks
+
+        result: list[BlockCreateRequest] = []
+
+        for i, block in enumerate(blocks):
+            block_type = block.type
+
+            if (
+                block_type in self.BLOCKS_NEEDING_EMPTY_PARAGRAPH
+                and i > 0
+                and not self._is_empty_paragraph(result[-1] if result else None)
+            ):
+
+                # Create empty paragraph block inline
+                empty_paragraph = CreateParagraphBlock(
+                    paragraph=ParagraphBlock(rich_text=[])
+                )
+                result.append(empty_paragraph)
+
+            result.append(block)
+
+        return result
+
+    def _is_empty_paragraph(self, block: BlockCreateRequest | None) -> bool:
+        if not block or block.type != BlockType.PARAGRAPH:
+            return False
+        if not isinstance(block, CreateParagraphBlock):
+            return False
+
+        para_block = cast(CreateParagraphBlock, block)
+        paragraph: ParagraphBlock | None = para_block.paragraph
+        if not paragraph:
+            return False

notionary/page/writer/notion_text_length_processor.py

@@ -0,0 +1,150 @@
+"""
+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/telemetry/__init__.py

@@ -2,10 +2,10 @@ from .service import ProductTelemetry
 from .views import (
     BaseTelemetryEvent,
     DatabaseFactoryUsedEvent,
-    QueryOperationEvent,
-    NotionMarkdownSyntaxPromptEvent,
     MarkdownToNotionConversionEvent,
+    NotionMarkdownSyntaxPromptEvent,
     NotionToMarkdownConversionEvent,
+    QueryOperationEvent,
 )
 
 __all__ = [

notionary/telemetry/service.py

@@ -1,12 +1,12 @@
 import os
 import uuid
 from pathlib import Path
-from typing import Dict, Any, Optional
-from posthog import Posthog
+
 from dotenv import load_dotenv
+from posthog import Posthog
 
 from notionary.telemetry.views import BaseTelemetryEvent
-from notionary.util import SingletonMetaClass, LoggingMixin
+from notionary.util import LoggingMixin, SingletonMetaClass
 
 load_dotenv()
 

notionary/user/__init__.py

@@ -1,7 +1,7 @@
-from .notion_user import NotionUser
-from .notion_user_manager import NotionUserManager
 from .client import NotionUserClient
 from .notion_bot_user import NotionBotUser
+from .notion_user import NotionUser
+from .notion_user_manager import NotionUserManager
 
 __all__ = [
     "NotionUser",

notionary/user/base_notion_user.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
+
 from abc import ABC
 from typing import Optional
-from notionary.user.client import NotionUserClient
 
+from notionary.user.client import NotionUserClient
 from notionary.util import LoggingMixin
 
 

notionary/user/client.py

@@ -1,14 +1,13 @@
-from typing import Optional, List
+from typing import List, Optional
+
 from notionary.base_notion_client import BaseNotionClient
 from notionary.user.models import (
     NotionBotUserResponse,
     NotionUserResponse,
     NotionUsersListResponse,
 )
-from notionary.util import singleton
 
 
-@singleton
 class NotionUserClient(BaseNotionClient):
     """
     Client for Notion user-specific operations.

notionary/user/models.py

@@ -1,5 +1,6 @@
 from dataclasses import dataclass
 from typing import Literal, Optional
+
 from pydantic import BaseModel
 
 

notionary/user/notion_bot_user.py

@@ -1,11 +1,10 @@
 from __future__ import annotations
-from typing import Optional, List
+
+from typing import List, Optional
+
 from notionary.user.base_notion_user import BaseNotionUser
 from notionary.user.client import NotionUserClient
-from notionary.user.models import (
-    NotionBotUserResponse,
-    WorkspaceLimits,
-)
+from notionary.user.models import NotionBotUserResponse, WorkspaceLimits
 from notionary.util import factory_only
 from notionary.util.fuzzy import find_best_match
 

notionary/user/notion_user.py

@@ -1,11 +1,10 @@
 from __future__ import annotations
 
-from typing import Optional, List
+from typing import List, Optional
+
 from notionary.user.base_notion_user import BaseNotionUser
 from notionary.user.client import NotionUserClient
-from notionary.user.models import (
-    NotionUserResponse,
-)
+from notionary.user.models import NotionUserResponse
 from notionary.util import factory_only
 from notionary.util.fuzzy import find_best_matches