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

notionary/page/writer/handler/regular_line_handler.py

@@ -0,0 +1,92 @@
+from notionary.blocks.column.column_element import ColumnElement
+from notionary.blocks.column.column_list_element import ColumnListElement
+from notionary.blocks.models import BlockCreateRequest, BlockCreateResult
+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()
+
+    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 = self._process_single_line_content(context)
+        if not block_created:
+            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)
+
+    def _process_single_line_content(self, context: LineProcessingContext) -> bool:
+        """Process a regular line for simple elements (lists, etc.)."""
+        for element in context.block_registry.get_elements():
+            # Skip all 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
+
+            specialized_elements = (
+                ColumnListElement,
+                ColumnElement,
+                ToggleElement,
+                ToggleableHeadingElement,
+                TableElement,
+                CodeElement,
+                ParagraphElement,  # Skip paragraph to ensure equations are processed first
+            )
+
+            if issubclass(element, specialized_elements):
+                continue
+
+            result = element.markdown_to_notion(context.line)
+            if not result:
+                continue
+
+            blocks = self._normalize_to_list(result)
+            for block in blocks:
+                context.result_blocks.append(block)
+
+            return True
+
+        return False
+
+    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 = paragraph_element.markdown_to_notion(context.line)
+
+        if result:
+            blocks = self._normalize_to_list(result)
+            for block in blocks:
+                context.result_blocks.append(block)
+
+    @staticmethod
+    def _normalize_to_list(result: BlockCreateResult) -> list[BlockCreateRequest]:
+        """Normalize the result to a list."""
+        if result is None:
+            return []
+        return result if isinstance(result, list) else [result]

notionary/page/writer/handler/table_handler.py

@@ -0,0 +1,130 @@
+import re
+
+from notionary.blocks.rich_text.rich_text_models import RichTextObject
+from notionary.blocks.rich_text.text_inline_formatter import TextInlineFormatter
+from notionary.blocks.table.table_element import TableElement
+from notionary.blocks.table.table_models import CreateTableRowBlock, TableRowBlock
+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)
+
+    def _process(self, context: LineProcessingContext) -> None:
+        if not self._is_table_start(context):
+            return
+
+        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
+
+    def _process_complete_table(self, context: LineProcessingContext) -> None:
+        """Process the entire table in one go."""
+        # Create table element
+        table_element = TableElement()
+        result = table_element.markdown_to_notion(context.line)
+        if not result:
+            return
+
+        block = result if not isinstance(result, list) else result[0]
+
+        # 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:
+            # Consumed all remaining lines
+            lines_to_consume = len(remaining_lines)
+
+        # Process the table content
+        table_rows, separator_found = self._process_table_lines(table_lines)
+
+        table = block.table
+        table.children = table_rows
+        table.has_column_header = bool(separator_found)
+
+        # Tell the main loop to skip the consumed lines
+        context.lines_consumed = lines_to_consume
+        context.result_blocks.append(block)
+
+    def _process_table_lines(
+        self, table_lines: list[str]
+    ) -> tuple[list[CreateTableRowBlock], bool]:
+        """Process all table lines and return rows and separator status."""
+        table_rows = []
+        separator_found = False
+
+        for line in table_lines:
+            line = line.strip()
+            if not line:
+                continue
+
+            if self._is_separator_line(line):
+                separator_found = True
+                continue
+
+            if self._table_row_pattern.match(line):
+                table_row = self._create_table_row_from_line(line)
+                table_rows.append(table_row)
+
+        return table_rows, separator_found
+
+    def _is_separator_line(self, line: str) -> bool:
+        return self._separator_pattern.match(line) is not None
+
+    def _create_table_row_from_line(self, line: str) -> CreateTableRowBlock:
+        cells = self._parse_table_row(line)
+        rich_text_cells = [self._convert_cell_to_rich_text(cell) for cell in cells]
+        table_row = TableRowBlock(cells=rich_text_cells)
+        return CreateTableRowBlock(table_row=table_row)
+
+    def _convert_cell_to_rich_text(self, cell: str) -> list[RichTextObject]:
+        rich_text = TextInlineFormatter.parse_inline_formatting(cell)
+        if not rich_text:
+            rich_text = [RichTextObject.from_plain_text(cell)]
+        return rich_text
+
+    def _parse_table_row(self, row_text: str) -> list[str]:
+        row_content = row_text.strip()
+
+        if row_content.startswith("|"):
+            row_content = row_content[1:]
+        if row_content.endswith("|"):
+            row_content = row_content[:-1]
+
+        return [cell.strip() for cell in row_content.split("|")]

notionary/page/writer/handler/toggle_handler.py

@@ -0,0 +1,153 @@
+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)
+        )
+
+    def _process(self, context: LineProcessingContext) -> None:
+        # Explicit, readable branches (small duplication is acceptable)
+        if self._is_toggle_start(context):
+            self._start_toggle(context)
+            context.was_processed = True
+            context.should_continue = True
+
+        if self._is_toggle_end(context):
+            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)
+
+    def _start_toggle(self, context: LineProcessingContext) -> None:
+        """Start a new toggle block."""
+        toggle_element = ToggleElement()
+
+        # Create the block
+        result = toggle_element.markdown_to_notion(context.line)
+        if not result:
+            return
+
+        block = result if not isinstance(result, list) else result[0]
+
+        # Push to parent stack
+        parent_context = ParentBlockContext(
+            block=block,
+            element_type=ToggleElement,
+            child_lines=[],
+        )
+        context.parent_stack.append(parent_context)
+
+    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 = 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)
+
+    def _convert_children_text(self, text: str, block_registry) -> list:
+        """Convert children text to blocks."""
+        from notionary.page.writer.markdown_to_notion_converter import (
+            MarkdownToNotionConverter,
+        )
+
+        if not text.strip():
+            return []
+
+        child_converter = MarkdownToNotionConverter(block_registry)
+        return child_converter._process_lines(text)
+
+    def _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 = 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

@@ -0,0 +1,167 @@
+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)
+        )
+
+    def _process(self, context: LineProcessingContext) -> None:
+        """Process toggleable heading start, end, or content with unified handling."""
+
+        def _handle(action):
+            action(context)
+            context.was_processed = True
+            context.should_continue = True
+            return True
+
+        if self._is_toggleable_heading_start(context):
+            return _handle(self._start_toggleable_heading)
+        if self._is_toggleable_heading_end(context):
+            return _handle(self._finalize_toggleable_heading)
+        if self._is_toggleable_heading_content(context):
+            return _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)
+
+    def _start_toggleable_heading(self, context: LineProcessingContext) -> None:
+        """Start a new toggleable heading block."""
+        toggleable_heading_element = ToggleableHeadingElement()
+
+        # Create the block
+        result = toggleable_heading_element.markdown_to_notion(context.line)
+        if not result:
+            return
+
+        block = result if not isinstance(result, list) else result[0]
+
+        # Push to parent stack
+        parent_context = ParentBlockContext(
+            block=block,
+            element_type=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))
+
+    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)
+
+    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 = 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)
+
+    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 = 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
+
+    def _convert_children_text(self, text: str, block_registry) -> list:
+        """Convert children text to blocks."""
+        from notionary.page.writer.markdown_to_notion_converter import (
+            MarkdownToNotionConverter,
+        )
+
+        if not text.strip():
+            return []
+
+        child_converter = MarkdownToNotionConverter(block_registry)
+        return child_converter._process_lines(text)

notionary/page/writer/markdown_to_notion_converter.py

@@ -0,0 +1,76 @@
+from notionary.blocks.models import BlockCreateRequest
+from notionary.blocks.registry.block_registry import BlockRegistry
+from notionary.page.notion_text_length_utils import fix_blocks_content_length
+from notionary.page.writer.handler import (
+    CodeHandler,
+    ColumnHandler,
+    ColumnListHandler,
+    LineProcessingContext,
+    ParentBlockContext,
+    RegularLineHandler,
+    TableHandler,
+    ToggleableHeadingHandler,
+    ToggleHandler,
+)
+
+
+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._setup_handler_chain()
+
+    def _setup_handler_chain(self) -> None:
+        code_handler = CodeHandler()
+        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(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
+
+    def convert(self, markdown_text: str) -> list[BlockCreateRequest]:
+        if not markdown_text.strip():
+            return []
+
+        all_blocks = self._process_lines(markdown_text)
+        return fix_blocks_content_length(all_blocks)
+
+    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,
+            )
+
+            self._handler_chain.handle(context)
+
+            # Skip consumed lines
+            i += 1 + context.lines_consumed
+
+            if context.should_continue:
+                continue
+
+        return result_blocks

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,13 @@
 import os
 import uuid
 from pathlib import Path
-from typing import Dict, Any, Optional
-from posthog import Posthog
+from typing import Any, Dict, Optional
+
 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.