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

notionary/file_upload/notion_file_upload.py

@@ -5,7 +5,7 @@ from io import BytesIO
 from pathlib import Path
 from typing import Optional
 
-from notionary.file_upload.models import FileUploadResponse
+from notionary.file_upload.models import FileUploadResponse, UploadMode
 from notionary.util import LoggingMixin
 
 
@@ -196,7 +196,7 @@ class NotionFileUpload(LoggingMixin):
             filename=filename,
             content_type=content_type,
             content_length=file_size,
-            mode="single_part",
+            mode=UploadMode.SINGLE_PART,
         )
 
         if not file_upload:
@@ -228,7 +228,7 @@ class NotionFileUpload(LoggingMixin):
             filename=filename,
             content_type=content_type,
             content_length=file_size,
-            mode="multi_part",
+            mode=UploadMode.MULTI_PART,
         )
 
         if not file_upload:
@@ -269,7 +269,7 @@ class NotionFileUpload(LoggingMixin):
             filename=filename,
             content_type=content_type,
             content_length=file_size,
-            mode="single_part",
+            mode=UploadMode.SINGLE_PART,
         )
 
         if not file_upload:
@@ -299,7 +299,7 @@ class NotionFileUpload(LoggingMixin):
             filename=filename,
             content_type=content_type,
             content_length=file_size,
-            mode="multi_part",
+            mode=UploadMode.MULTI_PART,
         )
 
         if not file_upload:

notionary/page/markdown_whitespace_processor.py

@@ -0,0 +1,129 @@
+"""
+Markdown whitespace processing utilities.
+
+Handles normalization of markdown text while preserving code blocks and their indentation.
+"""
+
+from typing import Tuple
+
+
+class MarkdownWhitespaceProcessor:
+    """
+    Processes markdown text to normalize whitespace while preserving code block formatting.
+
+    This processor handles:
+    - Removing leading whitespace from regular lines
+    - Preserving code block structure and indentation
+    - Normalizing code block markers
+    """
+
+    @staticmethod
+    def process_markdown_whitespace(markdown_text: str) -> str:
+        """Process markdown text to normalize whitespace while preserving code blocks."""
+        lines = markdown_text.split("\n")
+        if not lines:
+            return ""
+
+        return MarkdownWhitespaceProcessor._process_whitespace_lines(lines)
+
+    @staticmethod
+    def _process_whitespace_lines(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 = (
+                MarkdownWhitespaceProcessor._process_single_line(
+                    line, processed_lines, in_code_block, current_code_block
+                )
+            )
+
+        return "\n".join(processed_lines)
+
+    @staticmethod
+    def _process_single_line(
+        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 MarkdownWhitespaceProcessor._is_code_block_marker(line):
+            return MarkdownWhitespaceProcessor._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
+
+    @staticmethod
+    def _handle_code_block_marker(
+        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 MarkdownWhitespaceProcessor._start_code_block(line, processed_lines)
+        else:
+            return MarkdownWhitespaceProcessor._end_code_block(
+                processed_lines, current_code_block
+            )
+
+    @staticmethod
+    def _start_code_block(
+        line: str, processed_lines: list[str]
+    ) -> Tuple[list[str], bool, list[str]]:
+        """Start a new code block."""
+        processed_lines.append(
+            MarkdownWhitespaceProcessor._normalize_code_block_start(line)
+        )
+        return processed_lines, True, []
+
+    @staticmethod
+    def _end_code_block(
+        processed_lines: list[str], current_code_block: list[str]
+    ) -> Tuple[list[str], bool, list[str]]:
+        """End the current code block."""
+        processed_lines.extend(
+            MarkdownWhitespaceProcessor._normalize_code_block_content(
+                current_code_block
+            )
+        )
+        processed_lines.append("```")
+        return processed_lines, False, []
+
+    @staticmethod
+    def _is_code_block_marker(line: str) -> bool:
+        """Check if line is a code block marker."""
+        return line.lstrip().startswith("```")
+
+    @staticmethod
+    def _normalize_code_block_start(line: str) -> str:
+        """Normalize code block opening marker."""
+        language = line.lstrip().replace("```", "", 1).strip()
+        return "```" + language
+
+    @staticmethod
+    def _normalize_code_block_content(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]

notionary/page/notion_page.py

@@ -9,13 +9,16 @@ 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
@@ -77,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
@@ -205,20 +210,15 @@ 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)
-    
+        return await self._comment_client.list_all_comments_for_page(
+            page_id=self._page_id
+        )
+
     async def post_comment(
         self,
         content: str,
@@ -248,7 +248,9 @@ class NotionPage(LoggingMixin):
             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)}")
+            self.logger.error(
+                f"Failed to post comment on page '{self._title}': {str(e)}"
+            )
             return None
 
     async def set_title(self, title: str) -> str:
@@ -272,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
@@ -319,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
 
@@ -681,3 +669,10 @@ class NotionPage(LoggingMixin):
         parent = page_response.parent
         if isinstance(parent, DatabaseParent):
             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

@@ -34,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: