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

notionary/page/page_content_writer.py

@@ -2,12 +2,9 @@ from typing import Callable, Optional, Union
 
 from notionary.blocks.client import NotionBlockClient
 from notionary.blocks.divider import DividerElement
-from notionary.blocks.models import Block
 from notionary.blocks.registry.block_registry import BlockRegistry
 from notionary.blocks.table_of_contents import TableOfContentsElement
 from notionary.markdown.markdown_builder import MarkdownBuilder
-from notionary.page.markdown_whitespace_processor import MarkdownWhitespaceProcessor
-from notionary.page.reader.page_content_retriever import PageContentRetriever
 from notionary.page.writer.markdown_to_notion_converter import MarkdownToNotionConverter
 from notionary.util import LoggingMixin
 
@@ -22,8 +19,6 @@ class PageContentWriter(LoggingMixin):
             block_registry=block_registry
         )
 
-        self._content_retriever = PageContentRetriever(block_registry=block_registry)
-
     async def append_markdown(
         self,
         content: Union[str, Callable[[MarkdownBuilder], MarkdownBuilder]],
@@ -33,14 +28,6 @@ class PageContentWriter(LoggingMixin):
     ) -> Optional[str]:
         """
         Append markdown content to a Notion page using either text or builder callback.
-
-        Args:
-            content: Either raw markdown text OR a callback function that receives a MarkdownBuilder
-            append_divider: Whether to append a divider
-            prepend_table_of_contents: Whether to prepend table of contents
-
-        Returns:
-            str: The processed markdown content that was appended (None if failed)
         """
 
         if isinstance(content, str):
@@ -66,7 +53,9 @@ class PageContentWriter(LoggingMixin):
         processed_markdown = self._process_markdown_whitespace(final_markdown)
 
         try:
-            blocks = self._markdown_to_notion_converter.convert(processed_markdown)
+            blocks = await self._markdown_to_notion_converter.convert(
+                processed_markdown
+            )
 
             result = await self._block_client.append_block_children(
                 block_id=self.page_id, children=blocks
@@ -83,114 +72,101 @@ class PageContentWriter(LoggingMixin):
             self.logger.error("Error appending markdown: %s", str(e), exc_info=True)
             return None
 
-    async def clear_page_content(self) -> Optional[str]:
-        """Clear all content of the page and return deleted content as markdown."""
-        try:
-            children_response = await self._block_client.get_block_children(
-                block_id=self.page_id
-            )
-
-            if not children_response or not children_response.results:
-                return None
-
-            # Use PageContentRetriever for sophisticated markdown conversion
-            deleted_content = self._content_retriever._convert_blocks_to_markdown(
-                children_response.results, indent_level=0
-            )
-
-            # Delete blocks
-            success = True
-            for block in children_response.results:
-                block_success = await self._delete_block_with_children(block)
-                if not block_success:
-                    success = False
-
-            if not success:
-                self.logger.warning("Some blocks could not be deleted")
-
-            return deleted_content if deleted_content else None
-
-        except Exception:
-            self.logger.error("Error clearing page content", exc_info=True)
-            return None
-
-    async def _delete_block_with_children(self, block: Block) -> bool:
-        """Delete a block and all its children recursively."""
-        if not block.id:
-            self.logger.error("Block has no valid ID")
-            return False
-
-        self.logger.debug("Deleting block: %s (type: %s)", block.id, block.type)
-
-        try:
-            if block.has_children and not await self._delete_block_children(block):
-                return False
-
-            return await self._delete_single_block(block)
-
-        except Exception as e:
-            self.logger.error("Failed to delete block %s: %s", block.id, str(e))
-            return False
-
-    async def _delete_block_children(self, block: Block) -> bool:
-        """Delete all children of a block."""
-        self.logger.debug("Block %s has children, deleting children first", block.id)
+    def _process_markdown_whitespace(self, markdown_text: str) -> str:
+        """Process markdown text to normalize whitespace while preserving code blocks."""
+        lines = markdown_text.split("\n")
+        if not lines:
+            return ""
 
-        try:
-            children_blocks = await self._block_client.get_all_block_children(block.id)
+        return self._process_whitespace_lines(lines)
 
-            if not children_blocks:
-                self.logger.debug("No children found for block: %s", block.id)
-                return True
+    def _process_whitespace_lines(self, lines: list[str]) -> str:
+        """Process all lines and return the processed markdown."""
+        processed_lines = []
+        in_code_block = False
+        current_code_block = []
 
-            self.logger.debug(
-                "Found %d children to delete for block: %s",
-                len(children_blocks),
-                block.id,
+        for line in lines:
+            processed_lines, in_code_block, current_code_block = (
+                self._process_single_line(
+                    line, processed_lines, in_code_block, current_code_block
+                )
             )
 
-            # Delete all children recursively
-            for child_block in children_blocks:
-                if not await self._delete_block_with_children(child_block):
-                    self.logger.error(
-                        "Failed to delete child block: %s", child_block.id
-                    )
-                    return False
-
-            self.logger.debug(
-                "Successfully deleted all children of block: %s", block.id
-            )
-            return True
+        return "\n".join(processed_lines)
 
-        except Exception as e:
-            self.logger.error(
-                "Failed to delete children of block %s: %s", block.id, str(e)
+    def _process_single_line(
+        self,
+        line: str,
+        processed_lines: list[str],
+        in_code_block: bool,
+        current_code_block: list[str],
+    ) -> tuple[list[str], bool, list[str]]:
+        """Process a single line and return updated state."""
+        if self._is_code_block_marker(line):
+            return self._handle_code_block_marker(
+                line, processed_lines, in_code_block, current_code_block
             )
-            return False
-
-    async def _delete_single_block(self, block: Block) -> bool:
-        """Delete a single block."""
-        deleted_block: Optional[Block] = await self._block_client.delete_block(block.id)
-
-        if deleted_block is None:
-            self.logger.error("Failed to delete block: %s", block.id)
-            return False
-
-        if deleted_block.archived or deleted_block.in_trash:
-            self.logger.debug("Successfully deleted/archived block: %s", block.id)
-            return True
+        if in_code_block:
+            current_code_block.append(line)
+            return processed_lines, in_code_block, current_code_block
         else:
-            self.logger.warning("Block %s was not properly archived/deleted", block.id)
-            return False
+            processed_lines.append(line.lstrip())
+            return processed_lines, in_code_block, current_code_block
 
-    def _process_markdown_whitespace(self, markdown_text: str) -> str:
-        """Process markdown text to normalize whitespace while preserving code blocks."""
-        lines = markdown_text.split("\n")
-        if not lines:
-            return ""
-
-        processor = MarkdownWhitespaceProcessor()
-        return processor.process_lines(lines)
+    def _handle_code_block_marker(
+        self,
+        line: str,
+        processed_lines: list[str],
+        in_code_block: bool,
+        current_code_block: list[str],
+    ) -> tuple[list[str], bool, list[str]]:
+        """Handle code block start/end markers."""
+        if not in_code_block:
+            return self._start_code_block(line, processed_lines)
+        else:
+            return self._end_code_block(processed_lines, current_code_block)
+
+    def _start_code_block(
+        self, line: str, processed_lines: list[str]
+    ) -> tuple[list[str], bool, list[str]]:
+        """Start a new code block."""
+        processed_lines.append(self._normalize_code_block_start(line))
+        return processed_lines, True, []
+
+    def _end_code_block(
+        self, processed_lines: list[str], current_code_block: list[str]
+    ) -> tuple[list[str], bool, list[str]]:
+        """End the current code block."""
+        processed_lines.extend(self._normalize_code_block_content(current_code_block))
+        processed_lines.append("```")
+        return processed_lines, False, []
+
+    def _is_code_block_marker(self, line: str) -> bool:
+        """Check if line is a code block marker."""
+        return line.lstrip().startswith("```")
+
+    def _normalize_code_block_start(self, line: str) -> str:
+        """Normalize code block opening marker."""
+        language = line.lstrip().replace("```", "", 1).strip()
+        return "```" + language
+
+    def _normalize_code_block_content(self, code_lines: list[str]) -> list[str]:
+        """Normalize code block indentation."""
+        if not code_lines:
+            return []
+
+        # Find minimum indentation from non-empty lines
+        non_empty_lines = [line for line in code_lines if line.strip()]
+        if not non_empty_lines:
+            return [""] * len(code_lines)
+
+        min_indent = min(len(line) - len(line.lstrip()) for line in non_empty_lines)
+        if min_indent == 0:
+            return code_lines
+
+        # Remove common indentation
+        return ["" if not line.strip() else line[min_indent:] for line in code_lines]
 
     def _ensure_table_of_contents_exists_in_registry(self) -> None:
         """Ensure TableOfContents is registered in the block registry."""

notionary/page/page_context.py

@@ -0,0 +1,65 @@
+# notionary/blocks/context/page_context.py
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Optional
+from dataclasses import dataclass
+from contextvars import ContextVar
+
+if TYPE_CHECKING:
+    from notionary.database.client import NotionDatabaseClient
+    from notionary.file_upload import NotionFileUploadClient
+
+
+@dataclass(frozen=True)
+class PageContextProvider:
+    """Context object that provides dependencies for block conversion operations."""
+
+    page_id: str
+    database_client: NotionDatabaseClient
+    file_upload_client: NotionFileUploadClient
+
+
+# Context variable
+_page_context: ContextVar[Optional[PageContextProvider]] = ContextVar(
+    "page_context", default=None
+)
+
+
+def get_page_context() -> PageContextProvider:
+    """Get current page context or raise if not available."""
+    context = _page_context.get()
+    if context is None:
+        raise RuntimeError(
+            "No page context available. Use 'async with page_context(...)'"
+        )
+    return context
+
+
+def get_page_context_optional() -> Optional[PageContextProvider]:
+    """Get current page context or None if not available."""
+    return _page_context.get()
+
+
+class page_context:
+    """Async-only context manager for page operations."""
+
+    def __init__(self, provider: PageContextProvider):
+        self.provider = provider
+        self._token = None
+
+    def _set_context(self) -> PageContextProvider:
+        """Helper to set context and return provider."""
+        self._token = _page_context.set(self.provider)
+        return self.provider
+
+    def _reset_context(self) -> None:
+        """Helper to reset context."""
+        if self._token is not None:
+            _page_context.reset(self._token)
+
+    async def __aenter__(self) -> PageContextProvider:
+        return self._set_context()
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        self._reset_context()
+        return False

notionary/page/reader/handler/__init__.py

@@ -3,6 +3,7 @@ from .block_rendering_context import BlockRenderingContext
 from .column_list_renderer import ColumnListRenderer
 from .column_renderer import ColumnRenderer
 from .line_renderer import LineRenderer
+from .numbered_list_renderer import NumberedListRenderer
 from .toggle_renderer import ToggleRenderer
 from .toggleable_heading_renderer import ToggleableHeadingRenderer
 
@@ -12,6 +13,7 @@ __all__ = [
     "ColumnListRenderer",
     "ColumnRenderer",
     "LineRenderer",
+    "NumberedListRenderer",
     "ToggleRenderer",
     "ToggleableHeadingRenderer",
 ]

notionary/page/reader/handler/base_block_renderer.py

@@ -17,12 +17,12 @@ class BlockHandler(ABC):
         self._next_handler = handler
         return handler
 
-    def handle(self, context: BlockRenderingContext) -> None:
+    async def handle(self, context: BlockRenderingContext) -> None:
         """Handle the block or pass to next handler."""
         if self._can_handle(context):
-            self._process(context)
+            await self._process(context)
         elif self._next_handler:
-            self._next_handler.handle(context)
+            await self._next_handler.handle(context)
 
     @abstractmethod
     def _can_handle(self, context: BlockRenderingContext) -> bool:
@@ -30,7 +30,7 @@ class BlockHandler(ABC):
         pass
 
     @abstractmethod
-    def _process(self, context: BlockRenderingContext) -> None:
+    async def _process(self, context: BlockRenderingContext) -> None:
         """Process the block and update context."""
         pass
 

notionary/page/reader/handler/block_rendering_context.py

@@ -16,6 +16,11 @@ class BlockRenderingContext:
     block_registry: BlockRegistry
     convert_children_callback: Optional[Callable[[list[Block], int], str]] = None
 
+    # For batch processing
+    all_blocks: Optional[list[Block]] = None
+    current_block_index: Optional[int] = None
+    blocks_consumed: int = 0
+
     # Result
     markdown_result: Optional[str] = None
     children_result: Optional[str] = None

notionary/page/reader/handler/line_renderer.py

@@ -1,3 +1,7 @@
+from __future__ import annotations
+
+from typing import Optional
+
 from notionary.page.reader.handler import BlockHandler, BlockRenderingContext
 
 
@@ -8,9 +12,9 @@ class LineRenderer(BlockHandler):
         # Always can handle - this is the fallback handler
         return True
 
-    def _process(self, context: BlockRenderingContext) -> None:
-        # Convert the block itself
-        block_markdown = context.block_registry.notion_to_markdown(context.block)
+    async def _process(self, context: BlockRenderingContext) -> None:
+        # Convert the block itself using direct element iteration
+        block_markdown = await self._convert_block_to_markdown(context)
 
         # If block has no direct markdown, either return empty or process children
         if not block_markdown:
@@ -58,3 +62,12 @@ class LineRenderer(BlockHandler):
             else block_markdown
         )
         context.was_processed = True
+
+    async def _convert_block_to_markdown(
+        self, context: BlockRenderingContext
+    ) -> Optional[str]:
+        """Convert a Notion block to markdown using registered elements."""
+        for element in context.block_registry.get_elements():
+            if element.match_notion(context.block):
+                return await element.notion_to_markdown(context.block)
+        return None

notionary/page/reader/handler/numbered_list_renderer.py

@@ -0,0 +1,85 @@
+from notionary.blocks.models import Block, BlockType
+from notionary.blocks.registry.block_registry import BlockRegistry
+from notionary.page.reader.handler.base_block_renderer import BlockHandler
+from notionary.page.reader.handler.block_rendering_context import BlockRenderingContext
+
+
+class NumberedListRenderer(BlockHandler):
+    """Handles numbered list items with sequential numbering."""
+
+    def _can_handle(self, context: BlockRenderingContext) -> bool:
+        """Check if this is a numbered list item."""
+        return (
+            context.block.type == BlockType.NUMBERED_LIST_ITEM
+            and context.block.numbered_list_item is not None
+        )
+
+    async def _process(self, context: BlockRenderingContext) -> None:
+        """Process numbered list item with sequential numbering."""
+        if context.all_blocks is None or context.current_block_index is None:
+            await self._process_single_item(context, 1)
+            return
+
+        items, blocks_to_skip = self._collect_numbered_list_items(context)
+
+        markdown_parts = []
+        for i, item_context in enumerate(items, 1):
+            item_markdown = await self._process_single_item(item_context, i)
+            if item_markdown:
+                markdown_parts.append(item_markdown)
+
+        # Set result and mark how many blocks to skip
+        if markdown_parts:
+            context.markdown_result = "\n".join(markdown_parts)
+            context.was_processed = True
+            context.blocks_consumed = blocks_to_skip
+
+    def _collect_numbered_list_items(
+        self, context: BlockRenderingContext
+    ) -> tuple[list[BlockRenderingContext], int]:
+        """Collect all consecutive numbered list items starting from current position."""
+        items = []
+        current_index = context.current_block_index
+        all_blocks = context.all_blocks
+
+        # Start with current block
+        items.append(context)
+        blocks_processed = 1
+
+        # Look ahead for more numbered list items
+        for i in range(current_index + 1, len(all_blocks)):
+            block = all_blocks[i]
+
+            # Check if it's a numbered list item
+            if (
+                block.type == BlockType.NUMBERED_LIST_ITEM
+                and block.numbered_list_item is not None
+            ):
+
+                # Create context for this item
+                item_context = BlockRenderingContext(
+                    block=block,
+                    indent_level=context.indent_level,
+                    block_registry=context.block_registry,
+                    convert_children_callback=context.convert_children_callback,
+                )
+                items.append(item_context)
+                blocks_processed += 1
+            else:
+                # Not a numbered list item - stop collecting
+                break
+
+        return items, blocks_processed
+
+    async def _process_single_item(
+        self, context: BlockRenderingContext, number: int
+    ) -> str:
+        """Process a single numbered list item with the given number."""
+        from notionary.blocks.rich_text.text_inline_formatter import TextInlineFormatter
+
+        rich_text = context.block.numbered_list_item.rich_text
+        content = await TextInlineFormatter.extract_text_with_formatting(rich_text)
+
+        # Apply indentation
+        indent = "  " * context.indent_level
+        return f"{indent}{number}. {content}"

notionary/page/reader/page_content_retriever.py

@@ -5,6 +5,7 @@ from notionary.page.reader.handler import (
     ColumnListRenderer,
     ColumnRenderer,
     LineRenderer,
+    NumberedListRenderer,
     ToggleableHeadingRenderer,
     ToggleRenderer,
 )
@@ -27,7 +28,7 @@ class PageContentRetriever(LoggingMixin):
         Retrieve page content and convert it to Markdown.
         Uses the chain of responsibility pattern for scalable block processing.
         """
-        return self._convert_blocks_to_markdown(blocks, indent_level=0)
+        return await self._convert_blocks_to_markdown(blocks, indent_level=0)
 
     def _setup_handler_chain(self) -> None:
         """Setup the chain of handlers in priority order."""
@@ -35,16 +36,19 @@ class PageContentRetriever(LoggingMixin):
         toggleable_heading_handler = ToggleableHeadingRenderer()
         column_list_handler = ColumnListRenderer()
         column_handler = ColumnRenderer()
+        numbered_list_handler = NumberedListRenderer()
         regular_handler = LineRenderer()
 
         # Chain handlers - most specific first
         toggle_handler.set_next(toggleable_heading_handler).set_next(
             column_list_handler
-        ).set_next(column_handler).set_next(regular_handler)
+        ).set_next(column_handler).set_next(numbered_list_handler).set_next(
+            regular_handler
+        )
 
         self._handler_chain = toggle_handler
 
-    def _convert_blocks_to_markdown(
+    async def _convert_blocks_to_markdown(
         self, blocks: list[Block], indent_level: int = 0
     ) -> str:
         """Convert blocks to Markdown using the handler chain."""
@@ -52,18 +56,26 @@ class PageContentRetriever(LoggingMixin):
             return ""
 
         markdown_parts = []
+        i = 0
 
-        for block in blocks:
+        while i < len(blocks):
+            block = blocks[i]
             context = BlockRenderingContext(
                 block=block,
                 indent_level=indent_level,
                 block_registry=self._block_registry,
+                all_blocks=blocks,
+                current_block_index=i,
+                convert_children_callback=self._convert_blocks_to_markdown,
             )
 
-            self._handler_chain.handle(context)
+            await self._handler_chain.handle(context)
 
             if context.was_processed and context.markdown_result:
                 markdown_parts.append(context.markdown_result)
 
+            # Skip additional blocks if they were consumed by batch processing
+            i += max(1, context.blocks_consumed)
+
         separator = "\n\n" if indent_level == 0 else "\n"
         return separator.join(markdown_parts)

notionary/page/writer/handler/__init__.py

@@ -1,6 +1,7 @@
 from .code_handler import CodeHandler
 from .column_handler import ColumnHandler
 from .column_list_handler import ColumnListHandler
+from .equation_handler import EquationHandler
 from .line_handler import LineHandler
 from .line_processing_context import LineProcessingContext, ParentBlockContext
 from .regular_line_handler import RegularLineHandler
@@ -19,4 +20,5 @@ __all__ = [
     "TableHandler",
     "RegularLineHandler",
     "CodeHandler",
+    "EquationHandler",
 ]

notionary/page/writer/handler/code_handler.py

@@ -1,7 +1,6 @@
 import re
 
 from notionary.blocks.code.code_element import CodeElement
-from notionary.blocks.rich_text.rich_text_models import RichTextObject
 from notionary.page.writer.handler.line_handler import (
     LineHandler,
     LineProcessingContext,
@@ -27,9 +26,9 @@ class CodeHandler(LineHandler):
             return False
         return self._is_code_start(context)
 
-    def _process(self, context: LineProcessingContext) -> None:
+    async def _process(self, context: LineProcessingContext) -> None:
         if self._is_code_start(context):
-            self._process_complete_code_block(context)
+            await self._process_complete_code_block(context)
             self._mark_processed(context)
 
     def _is_code_start(self, context: LineProcessingContext) -> bool:
@@ -40,33 +39,19 @@ class CodeHandler(LineHandler):
         """Check if we're currently inside any parent context (toggle, heading, etc.)."""
         return len(context.parent_stack) > 0
 
-    def _process_complete_code_block(self, context: LineProcessingContext) -> None:
-        """Process the entire code block in one go."""
-        # Extract language and caption from opening fence
-        language, caption = self._extract_fence_info(context.line)
-
-        # Create base code block
-        result = CodeElement.markdown_to_notion(f"```{language}")
-        if not result:
-            return
-
-        block = result[0] if isinstance(result, list) else result
-
+    async def _process_complete_code_block(
+        self, context: LineProcessingContext
+    ) -> None:
+        """Process the entire code block in one go using CodeElement."""
         code_lines, lines_to_consume = self._collect_code_lines(context)
 
-        self._set_block_content(block, code_lines)
+        block = CodeElement.create_from_markdown_block(
+            opening_line=context.line, code_lines=code_lines
+        )
 
-        self._set_block_caption(block, caption)
-
-        context.lines_consumed = lines_to_consume
-        context.result_blocks.append(block)
-
-    def _extract_fence_info(self, line: str) -> tuple[str, str]:
-        """Extract the language and optional caption from a code fence."""
-        match = self._code_start_pattern.match(line.strip())
-        lang = match.group(1) if match and match.group(1) else ""
-        cap = match.group(2) if match and match.group(2) else ""
-        return lang, cap
+        if block:
+            context.lines_consumed = lines_to_consume
+            context.result_blocks.append(block)
 
     def _collect_code_lines(
         self, context: LineProcessingContext
@@ -85,16 +70,3 @@ class CodeHandler(LineHandler):
         """Mark context as processed and continue."""
         context.was_processed = True
         context.should_continue = True
-
-    def _set_block_content(self, block, code_lines: list[str]) -> None:
-        """Set the code rich_text content on the block."""
-        if not code_lines:
-            return
-        content = "\n".join(code_lines)
-        block.code.rich_text = [RichTextObject.for_code_block(content)]
-
-    def _set_block_caption(self, block, caption: str) -> None:
-        """Append caption to the code block if provided."""
-        if not caption:
-            return
-        block.code.caption.append(RichTextObject.for_code_block(caption))