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

notionary/page/notion_page.py

@@ -5,16 +5,20 @@ import random
 from typing import TYPE_CHECKING, Any, Callable, Optional, Union
 
 from notionary.blocks.client import NotionBlockClient
+from notionary.comments import CommentClient, Comment
 from notionary.blocks.syntax_prompt_builder import SyntaxPromptBuilder
 from notionary.blocks.models import DatabaseParent
 from notionary.blocks.registry.block_registry import BlockRegistry
-from notionary.blocks.registry.block_registry_builder import BlockRegistryBuilder
 from notionary.database.client import NotionDatabaseClient
-from notionary.markdown.markdown_builder import MarkdownBuilder
+from notionary.file_upload.client import NotionFileUploadClient
+from notionary.blocks.markdown.markdown_builder import MarkdownBuilder
+from notionary.schemas import NotionContentSchema
+from notionary.page import page_context
 from notionary.page.client import NotionPageClient
 from notionary.page.models import NotionPageResponse
 from notionary.page.page_content_deleting_service import PageContentDeletingService
 from notionary.page.page_content_writer import PageContentWriter
+from notionary.page.page_context import PageContextProvider, page_context
 from notionary.page.property_formatter import NotionPropertyFormatter
 from notionary.page.reader.page_content_retriever import PageContentRetriever
 from notionary.page.utils import extract_property_value
@@ -24,6 +28,7 @@ from notionary.util.fuzzy import find_best_match
 if TYPE_CHECKING:
     from notionary import NotionDatabase
 
+
 class NotionPage(LoggingMixin):
     """
     Managing content and metadata of a Notion page.
@@ -56,8 +61,9 @@ class NotionPage(LoggingMixin):
 
         self._client = NotionPageClient(token=token)
         self._block_client = NotionBlockClient(token=token)
+        self._comment_client = CommentClient(token=token)
         self._page_data = None
-        
+
         self.block_element_registry = BlockRegistry.create_registry()
 
         self._page_content_writer = PageContentWriter(
@@ -74,6 +80,8 @@ class NotionPage(LoggingMixin):
             block_registry=self.block_element_registry,
         )
 
+        self.page_context_provider = self._setup_page_context_provider()
+
     @classmethod
     async def from_page_id(
         cls, page_id: str, token: Optional[str] = None
@@ -202,17 +210,49 @@ class NotionPage(LoggingMixin):
     def is_in_trash(self) -> bool:
         return self._is_in_trash
 
-    @property
-    def block_registry_builder(self) -> BlockRegistryBuilder:
-        """
-        Returns the block registry builder for this page.
-        """
-        return self.block_element_registry.builder
-
     def get_prompt_information(self) -> str:
         markdown_syntax_builder = SyntaxPromptBuilder()
         return markdown_syntax_builder.build_concise_reference()
 
+    async def get_comments(self) -> list[Comment]:
+        return await self._comment_client.list_all_comments_for_page(
+            page_id=self._page_id
+        )
+
+    async def post_comment(
+        self,
+        content: str,
+        *,
+        discussion_id: Optional[str] = None,
+        rich_text: Optional[list[dict[str, Any]]] = None,
+    ) -> Optional[Comment]:
+        """
+        Post a comment on this page.
+
+        Args:
+            content: The plain text content of the comment
+            discussion_id: Optional discussion ID to reply to an existing discussion
+            rich_text: Optional rich text formatting for the comment content
+
+        Returns:
+            Comment: The created comment object, or None if creation failed
+        """
+        try:
+            # Use the comment client to create the comment
+            comment = await self._comment_client.create_comment(
+                page_id=self._page_id,
+                content=content,
+                discussion_id=discussion_id,
+                rich_text=rich_text,
+            )
+            self.logger.info(f"Successfully posted comment on page '{self._title}'")
+            return comment
+        except Exception as e:
+            self.logger.error(
+                f"Failed to post comment on page '{self._title}': {str(e)}"
+            )
+            return None
+
     async def set_title(self, title: str) -> str:
         """
         Set the title of the page.
@@ -234,43 +274,31 @@ class NotionPage(LoggingMixin):
 
     async def append_markdown(
         self,
-        content: Union[str, Callable[[MarkdownBuilder], MarkdownBuilder]],
-        *,
-        prepend_table_of_contents: bool = False,
-        append_divider: bool = False,
+        content: Union[
+            str, Callable[[MarkdownBuilder], MarkdownBuilder], NotionContentSchema
+        ],
     ) -> bool:
         """
-        Append markdown content to the page.
-
-        Args:
-            content: Either raw markdown text OR a callback function that receives a MarkdownBuilder
-            prepend_table_of_contents: Whether to prepend table of contents
-            append_divider: Whether to append a divider
-
-        Returns:
-            bool: True if successful, False otherwise
+        Append markdown content to the page using text, builder callback, MarkdownDocumentModel, or NotionContentSchema.
         """
-        result = await self._page_content_writer.append_markdown(
-            content=content,
-            append_divider=append_divider,
-            prepend_table_of_contents=prepend_table_of_contents,
-        )
-        return result is not None
+        async with page_context(self.page_context_provider):
+            result = await self._page_content_writer.append_markdown(
+                content=content,
+            )
+            return result is not None
 
     async def replace_content(
         self,
-        content: Union[str, Callable[[MarkdownBuilder], MarkdownBuilder]],
-        *,
-        prepend_table_of_contents: bool = False,
-        append_divider: bool = False,
+        content: Union[
+            str, Callable[[MarkdownBuilder], MarkdownBuilder], NotionContentSchema
+        ],
     ) -> bool:
         """
         Replace the entire page content with new markdown content.
 
         Args:
-            content: Either raw markdown text OR a callback function that receives a MarkdownBuilder
-            prepend_table_of_contents: Whether to prepend table of contents
-            append_divider: Whether to append a divider
+            content: Either raw markdown text, a callback function that receives a MarkdownBuilder,
+                    a MarkdownDocumentModel, or a NotionContentSchema
 
         Returns:
             bool: True if successful, False otherwise
@@ -281,8 +309,6 @@ class NotionPage(LoggingMixin):
 
         result = await self._page_content_writer.append_markdown(
             content=content,
-            prepend_table_of_contents=prepend_table_of_contents,
-            append_divider=append_divider,
         )
         return result is not None
 
@@ -320,27 +346,33 @@ class NotionPage(LoggingMixin):
 
             self.logger.error(f"Error updating page emoji: {str(e)}")
             return None
-        
+
     async def create_child_database(self, title: str) -> NotionDatabase:
         from notionary import NotionDatabase
+
         database_client = NotionDatabaseClient(token=self._client.token)
-        
-        create_database_response =  await database_client.create_database(
+
+        create_database_response = await database_client.create_database(
             title=title,
             parent_page_id=self._page_id,
         )
-        
-        return await NotionDatabase.from_database_id(id=create_database_response.id, token=self._client.token)
-    
+
+        return await NotionDatabase.from_database_id(
+            id=create_database_response.id, token=self._client.token
+        )
+
     async def create_child_page(self, title: str) -> NotionPage:
         from notionary import NotionPage
+
         child_page_response = await self._client.create_page(
             parent_page_id=self._page_id,
             title=title,
         )
-        
-        return await NotionPage.from_page_id(page_id=child_page_response.id, token=self._client.token)
-    
+
+        return await NotionPage.from_page_id(
+            page_id=child_page_response.id, token=self._client.token
+        )
+
     async def set_external_icon(self, url: str) -> Optional[str]:
         """
         Sets the page icon to an external image.
@@ -636,4 +668,11 @@ class NotionPage(LoggingMixin):
         """Extract parent database ID from page response."""
         parent = page_response.parent
         if isinstance(parent, DatabaseParent):
-            return parent.database_id
+            return parent.database_id
+
+    def _setup_page_context_provider(self) -> PageContextProvider:
+        return PageContextProvider(
+            page_id=self._page_id,
+            database_client=NotionDatabaseClient(token=self._client.token),
+            file_upload_client=NotionFileUploadClient(),
+        )

notionary/page/page_content_deleting_service.py

@@ -27,7 +27,7 @@ class PageContentDeletingService(LoggingMixin):
                 return None
 
             # Use PageContentRetriever for sophisticated markdown conversion
-            deleted_content = self._content_retriever._convert_blocks_to_markdown(
+            deleted_content = await self._content_retriever._convert_blocks_to_markdown(
                 children_response.results, indent_level=0
             )
 

notionary/page/page_content_writer.py

@@ -1,10 +1,10 @@
 from typing import Callable, Optional, Union
 
 from notionary.blocks.client import NotionBlockClient
-from notionary.blocks.divider import DividerElement
 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.blocks.markdown.markdown_builder import MarkdownBuilder
+from notionary.schemas.base import NotionContentSchema
+from notionary.page.markdown_whitespace_processor import MarkdownWhitespaceProcessor
 from notionary.page.writer.markdown_to_notion_converter import MarkdownToNotionConverter
 from notionary.util import LoggingMixin
 
@@ -21,36 +21,18 @@ class PageContentWriter(LoggingMixin):
 
     async def append_markdown(
         self,
-        content: Union[str, Callable[[MarkdownBuilder], MarkdownBuilder]],
-        *,
-        append_divider: bool = True,
-        prepend_table_of_contents: bool = False,
+        content: Union[
+            str, Callable[[MarkdownBuilder], MarkdownBuilder], NotionContentSchema
+        ],
     ) -> Optional[str]:
         """
-        Append markdown content to a Notion page using either text or builder callback.
+        Append markdown content to a Notion page using text, builder callback, MarkdownDocumentModel, or NotionContentSchema.
         """
+        markdown = self._extract_markdown_from_param(content)
 
-        if isinstance(content, str):
-            final_markdown = content
-        elif callable(content):
-            builder = MarkdownBuilder()
-            content(builder)
-            final_markdown = builder.build()
-        else:
-            raise ValueError(
-                "content must be either a string or a callable that takes a MarkdownBuilder"
-            )
-
-        # Add optional components
-        if prepend_table_of_contents:
-            self._ensure_table_of_contents_exists_in_registry()
-            final_markdown = "[toc]\n\n" + final_markdown
-
-        if append_divider:
-            self._ensure_divider_exists_in_registry()
-            final_markdown = final_markdown + "\n\n---\n"
-
-        processed_markdown = self._process_markdown_whitespace(final_markdown)
+        processed_markdown = MarkdownWhitespaceProcessor.process_markdown_whitespace(
+            markdown
+        )
 
         try:
             blocks = await self._markdown_to_notion_converter.convert(
@@ -72,106 +54,27 @@ class PageContentWriter(LoggingMixin):
             self.logger.error("Error appending markdown: %s", str(e), exc_info=True)
             return None
 
-    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 ""
-
-        return self._process_whitespace_lines(lines)
-
-    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 = []
-
-        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
-                )
-            )
-
-        return "\n".join(processed_lines)
-
-    def _process_single_line(
+    def _extract_markdown_from_param(
         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
-            )
-        if in_code_block:
-            current_code_block.append(line)
-            return processed_lines, in_code_block, current_code_block
-        else:
-            processed_lines.append(line.lstrip())
-            return processed_lines, in_code_block, current_code_block
+        content: Union[
+            str, Callable[[MarkdownBuilder], MarkdownBuilder], NotionContentSchema
+        ],
+    ) -> str:
+        """
+        Prepare markdown content from string, builder callback, MarkdownDocumentModel, or NotionContentSchema.
+        """
+        if isinstance(content, str):
+            return content
+        elif isinstance(content, NotionContentSchema):
+            # Use new injection-based API
+            builder = MarkdownBuilder()
+            return content.to_notion_content(builder)
 
-    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)
+        elif callable(content):
+            builder = MarkdownBuilder()
+            content(builder)
+            return builder.build()
         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."""
-        self.block_registry.register(TableOfContentsElement)
-
-    def _ensure_divider_exists_in_registry(self) -> None:
-        """Ensure DividerBlock is registered in the block registry."""
-        self.block_registry.register(DividerElement)
+            raise ValueError(
+                "content must be either a string, a NotionContentSchema, a MarkdownDocumentModel, or a callable that takes a MarkdownBuilder"
+            )

notionary/page/page_context.py

@@ -1,4 +1,3 @@
-# notionary/blocks/context/page_context.py
 from __future__ import annotations
 
 from typing import TYPE_CHECKING, Optional
@@ -35,11 +34,6 @@ def get_page_context() -> PageContextProvider:
     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."""
 

notionary/page/reader/handler/column_list_renderer.py

@@ -8,7 +8,7 @@ class ColumnListRenderer(BlockHandler):
     def _can_handle(self, context: BlockRenderingContext) -> bool:
         return ColumnListElement.match_notion(context.block)
 
-    def _process(self, context: BlockRenderingContext) -> None:
+    async def _process(self, context: BlockRenderingContext) -> None:
         # Create column list start line
         column_list_start = "::: columns"
 
@@ -28,7 +28,7 @@ class ColumnListRenderer(BlockHandler):
 
             # Create a temporary retriever to process children
             retriever = PageContentRetriever(context.block_registry)
-            children_markdown = retriever._convert_blocks_to_markdown(
+            children_markdown = await retriever._convert_blocks_to_markdown(
                 context.get_children_blocks(),
                 indent_level=0,  # No indentation for content inside column lists
             )

notionary/page/reader/handler/column_renderer.py

@@ -8,7 +8,7 @@ class ColumnRenderer(BlockHandler):
     def _can_handle(self, context: BlockRenderingContext) -> bool:
         return ColumnElement.match_notion(context.block)
 
-    def _process(self, context: BlockRenderingContext) -> None:
+    async def _process(self, context: BlockRenderingContext) -> None:
         # Get the column start line with potential width ratio
         column_start = self._extract_column_start(context.block)
 
@@ -28,7 +28,7 @@ class ColumnRenderer(BlockHandler):
 
             # Create a temporary retriever to process children
             retriever = PageContentRetriever(context.block_registry)
-            children_markdown = retriever._convert_blocks_to_markdown(
+            children_markdown = await retriever._convert_blocks_to_markdown(
                 context.get_children_blocks(),
                 indent_level=0,  # No indentation for content inside columns
             )

notionary/page/reader/handler/line_renderer.py

@@ -29,7 +29,7 @@ class LineRenderer(BlockHandler):
             )
 
             retriever = PageContentRetriever(context.block_registry)
-            children_markdown = retriever._convert_blocks_to_markdown(
+            children_markdown = await retriever._convert_blocks_to_markdown(
                 context.get_children_blocks(), indent_level=context.indent_level + 1
             )
             context.markdown_result = children_markdown
@@ -52,7 +52,7 @@ class LineRenderer(BlockHandler):
         from notionary.page.reader.page_content_retriever import PageContentRetriever
 
         retriever = PageContentRetriever(context.block_registry)
-        children_markdown = retriever._convert_blocks_to_markdown(
+        children_markdown = await retriever._convert_blocks_to_markdown(
             context.get_children_blocks(), indent_level=context.indent_level + 1
         )
 

notionary/page/reader/handler/toggle_renderer.py

@@ -8,7 +8,7 @@ class ToggleRenderer(BlockHandler):
     def _can_handle(self, context: BlockRenderingContext) -> bool:
         return ToggleElement.match_notion(context.block)
 
-    def _process(self, context: BlockRenderingContext) -> None:
+    async def _process(self, context: BlockRenderingContext) -> None:
         # Get the toggle title from the block
         toggle_title = self._extract_toggle_title(context.block)
 
@@ -34,7 +34,7 @@ class ToggleRenderer(BlockHandler):
 
             # Create a temporary retriever to process children
             retriever = PageContentRetriever(context.block_registry)
-            children_markdown = retriever._convert_blocks_to_markdown(
+            children_markdown = await retriever._convert_blocks_to_markdown(
                 context.get_children_blocks(),
                 indent_level=0,  # No indentation for content inside toggles
             )

notionary/page/reader/handler/toggleable_heading_renderer.py

@@ -11,7 +11,7 @@ class ToggleableHeadingRenderer(BlockHandler):
     def _can_handle(self, context: BlockRenderingContext) -> bool:
         return ToggleableHeadingElement.match_notion(context.block)
 
-    def _process(self, context: BlockRenderingContext) -> None:
+    async def _process(self, context: BlockRenderingContext) -> None:
         # Get the heading level and title
         level, title = self._extract_heading_info(context.block)
 
@@ -38,7 +38,7 @@ class ToggleableHeadingRenderer(BlockHandler):
 
             # Create a temporary retriever to process children
             retriever = PageContentRetriever(context.block_registry)
-            children_markdown = retriever._convert_blocks_to_markdown(
+            children_markdown = await retriever._convert_blocks_to_markdown(
                 context.get_children_blocks(),
                 indent_level=0,  # No indentation for content inside toggleable headings
             )

notionary/page/writer/handler/toggle_handler.py

@@ -15,7 +15,8 @@ class ToggleHandler(LineHandler):
 
     def __init__(self):
         super().__init__()
-        self._start_pattern = re.compile(r"^[+]{3}\s+(.+)$", re.IGNORECASE)
+        # 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:
@@ -43,15 +44,18 @@ class ToggleHandler(LineHandler):
             context.should_continue = True
 
     def _is_toggle_start(self, context: LineProcessingContext) -> bool:
-        """Check if line starts a toggle (+++ Title)."""
+        """Check if line starts a toggle (+++ Title or +++Title)."""
         line = context.line.strip()
 
-        # Must match our pattern
+        # 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 +++)
-        toggleable_heading_pattern = re.compile(r"^[+]{3}#{1,3}\s+.+$", re.IGNORECASE)
+        # 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
 

notionary/page/writer/handler/toggleable_heading_handler.py

@@ -19,8 +19,9 @@ class ToggleableHeadingHandler(LineHandler):
 
     def __init__(self):
         super().__init__()
+        # Updated: Support both "+++# title" and "+++#title"
         self._start_pattern = re.compile(
-            r"^[+]{3}(?P<level>#{1,3})\s+(.+)$", re.IGNORECASE
+            r"^[+]{3}\s*(?P<level>#{1,3})\s*(.+)$", re.IGNORECASE
         )
         # +++
         self._end_pattern = re.compile(r"^[+]{3}\s*$")
@@ -49,7 +50,7 @@ class ToggleableHeadingHandler(LineHandler):
             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")."""
+        """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: