notionary 0.2.7__py3-none-any.whl → 0.2.8__py3-none-any.whl

notionary/elements/column_element.py

@@ -1,113 +1,322 @@
 import re
-from typing import Dict, Any, Optional, List, Tuple
+from typing import Dict, Any, Optional, List, Tuple, Callable
+
 from notionary.elements.notion_block_element import NotionBlockElement
-from notionary.prompting.element_prompt_content import (
-    ElementPromptBuilder,
-    ElementPromptContent,
-)
+from notionary.prompting.element_prompt_content import ElementPromptContent
 
 
-# Fix Column Element
-class ColumnsElement(NotionBlockElement):
+class ColumnElement(NotionBlockElement):
     """
-    Handles conversion between Markdown column syntax and Notion column_list blocks.
+    Handles conversion between custom Markdown column syntax and Notion column blocks.
+
+    Markdown column syntax:
+    ::: columns
+    ::: column
+    Content for first column
+    :::
+    ::: column
+    Content for second column
+    :::
+    :::
 
-    Note: Due to Notion's column structure, this element requires special handling.
-    It returns a column_list block with placeholder content, as the actual columns
-    must be added as children after the column_list is created.
+    This creates a column layout in Notion with the specified content in each column.
     """
 
-    PATTERN = re.compile(
-        r"^::: columns\n((?:::: column\n(?:.*?\n)*?:::\n?)+):::\s*$",
-        re.MULTILINE | re.DOTALL,
-    )
+    COLUMNS_START = re.compile(r"^:::\s*columns\s*$")
+    COLUMN_START = re.compile(r"^:::\s*column\s*$")
+    BLOCK_END = re.compile(r"^:::\s*$")
 
-    COLUMN_PATTERN = re.compile(r"::: column\n(.*?):::", re.DOTALL)
+    _converter_callback = None
 
     @classmethod
-    def match_markdown(cls, text: str) -> bool:
-        """Check if text contains a columns block."""
-        return bool(cls.PATTERN.search(text))
+    def set_converter_callback(
+        cls, callback: Callable[[str], List[Dict[str, Any]]]
+    ) -> None:
+        """
+        Setze die Callback-Funktion, die zum Konvertieren von Markdown zu Notion-Blöcken verwendet wird.
 
-    @classmethod
-    def match_notion(cls, block: Dict[str, Any]) -> bool:
-        """Check if block is a Notion column_list block."""
-        return block.get("type") == "column_list"
+        Args:
+            callback: Funktion, die Markdown-Text annimmt und eine Liste von Notion-Blöcken zurückgibt
+        """
+        cls._converter_callback = callback
 
-    @classmethod
-    def markdown_to_notion(cls, text: str) -> Optional[Dict[str, Any]]:
-        """Convert markdown columns to Notion column_list block."""
-        match = cls.PATTERN.search(text)
-        if not match:
-            return None
+    @staticmethod
+    def match_markdown(text: str) -> bool:
+        """Check if text starts a columns block."""
+        return bool(ColumnElement.COLUMNS_START.match(text.strip()))
 
-        columns_content = match.group(1)
-        column_matches = cls.COLUMN_PATTERN.findall(columns_content)
+    @staticmethod
+    def match_notion(block: Dict[str, Any]) -> bool:
+        """Check if block is a Notion column_list."""
+        return block.get("type") == "column_list"
+
+    @staticmethod
+    def markdown_to_notion(text: str) -> Optional[Dict[str, Any]]:
+        """
+        Convert markdown column syntax to Notion column blocks.
 
-        if not column_matches:
+        Note: This only processes the first line (columns start).
+        The full column content needs to be processed separately.
+        """
+        if not ColumnElement.COLUMNS_START.match(text.strip()):
             return None
 
-        return {"type": "column_list", "column_list": {}}
+        # Create an empty column_list block
+        # Child columns will be added by the column processor
+        return {"type": "column_list", "column_list": {"children": []}}
 
-    @classmethod
-    def notion_to_markdown(cls, block: Dict[str, Any]) -> Optional[str]:
-        """Convert Notion column_list block to markdown columns."""
+    @staticmethod
+    def notion_to_markdown(block: Dict[str, Any]) -> Optional[str]:
+        """Convert Notion column_list block to markdown column syntax."""
         if block.get("type") != "column_list":
             return None
 
-        # In a real implementation, you'd need to fetch the child column blocks
-        # This is a placeholder showing the expected output format
-        markdown = "::: columns\n"
+        column_children = block.get("column_list", {}).get("children", [])
+
+        # Start the columns block
+        result = ["::: columns"]
+
+        # Process each column
+        for column_block in column_children:
+            if column_block.get("type") == "column":
+                result.append("::: column")
+
+            for _ in column_block.get("column", {}).get("children", []):
+                result.append("  [Column content]")  # Placeholder
+
+                result.append(":::")
 
-        # Placeholder for column content extraction
-        # In reality, you'd iterate through the child blocks
-        markdown += "::: column\nColumn content here\n:::\n"
+        # End the columns block
+        result.append(":::")
 
-        markdown += ":::"
-        return markdown
+        return "\n".join(result)
+
+    @staticmethod
+    def is_multiline() -> bool:
+        """Column blocks span multiple lines."""
+        return True
 
     @classmethod
-    def find_matches(cls, text: str) -> List[Tuple[int, int, Dict[str, Any]]]:
+    def find_matches(
+        cls, text: str, converter_callback: Optional[Callable] = None
+    ) -> List[Tuple[int, int, Dict[str, Any]]]:
         """
-        Find all column block matches in the text and return their positions.
+        Find all column block matches in the text and return their positions and blocks.
 
         Args:
-            text: The text to search in
+            text: The input markdown text
+            converter_callback: Optional callback to convert nested content
 
         Returns:
-            List of tuples with (start_pos, end_pos, block_data)
+            List of tuples (start_pos, end_pos, block)
         """
+        # Wenn ein Callback übergeben wurde, nutze diesen, sonst die gespeicherte Referenz
+        converter = converter_callback or cls._converter_callback
+        if not converter:
+            raise ValueError(
+                "No converter callback provided for ColumnElement. Call set_converter_callback first or provide converter_callback parameter."
+            )
+
         matches = []
-        for match in cls.PATTERN.finditer(text):
-            block_data = cls.markdown_to_notion(match.group(0))
-            if block_data:
-                matches.append((match.start(), match.end(), block_data))
+        lines = text.split("\n")
+        i = 0
+
+        while i < len(lines):
+            # Skip non-column lines
+            if not ColumnElement.COLUMNS_START.match(lines[i].strip()):
+                i += 1
+                continue
+
+            # Process a column block and add to matches
+            column_block_info = cls._process_column_block(
+                lines=lines, start_index=i, converter_callback=converter
+            )
+            matches.append(column_block_info)
+
+            # Skip to the end of the processed column block
+            i = column_block_info[3]  # i is returned as the 4th element in the tuple
+
+        return [(start, end, block) for start, end, block, _ in matches]
+
+    @classmethod
+    def _process_column_block(
+        cls, lines: List[str], start_index: int, converter_callback: Callable
+    ) -> Tuple[int, int, Dict[str, Any], int]:
+        """
+        Process a complete column block structure from the given starting line.
+
+        Args:
+            lines: All lines of the text
+            start_index: Index of the column block start line
+            converter_callback: Callback function to convert markdown to notion blocks
+
+        Returns:
+            Tuple of (start_pos, end_pos, block, next_line_index)
+        """
+        columns_start = start_index
+        columns_block = cls.markdown_to_notion(lines[start_index].strip())
+        columns_children = []
+
+        next_index = cls._collect_columns(
+            lines, start_index + 1, columns_children, converter_callback
+        )
+
+        # Add columns to the main block
+        if columns_children:
+            columns_block["column_list"]["children"] = columns_children
+
+        # Calculate positions
+        start_pos = sum(len(lines[j]) + 1 for j in range(columns_start))
+        end_pos = sum(len(lines[j]) + 1 for j in range(next_index))
+
+        return (start_pos, end_pos, columns_block, next_index)
+
+    @classmethod
+    def _collect_columns(
+        cls,
+        lines: List[str],
+        start_index: int,
+        columns_children: List[Dict[str, Any]],
+        converter_callback: Callable,
+    ) -> int:
+        """
+        Collect all columns within a column block structure.
+
+        Args:
+            lines: All lines of the text
+            start_index: Index to start collecting from
+            columns_children: List to append collected columns to
+            converter_callback: Callback function to convert column content
+
+        Returns:
+            Next line index after all columns have been processed
+        """
+        i = start_index
+        in_column = False
+        column_content = []
+
+        while i < len(lines):
+            current_line = lines[i].strip()
+
+            if cls.COLUMNS_START.match(current_line):
+                break
+
+            if cls.COLUMN_START.match(current_line):
+                cls._finalize_column(
+                    column_content, columns_children, in_column, converter_callback
+                )
+                column_content = []
+                in_column = True
+                i += 1
+                continue
+
+            if cls.BLOCK_END.match(current_line) and in_column:
+                cls._finalize_column(
+                    column_content, columns_children, in_column, converter_callback
+                )
+                column_content = []
+                in_column = False
+                i += 1
+                continue
+
+            if cls.BLOCK_END.match(current_line) and not in_column:
+                i += 1
+                break
+
+            if in_column:
+                column_content.append(lines[i])
+
+            i += 1
+
+        cls._finalize_column(
+            column_content, columns_children, in_column, converter_callback
+        )
+
+        return i
+
+    @staticmethod
+    def _finalize_column(
+        column_content: List[str],
+        columns_children: List[Dict[str, Any]],
+        in_column: bool,
+        converter_callback: Callable,
+    ) -> None:
+        """
+        Finalize a column by processing its content and adding it to the columns_children list.
+
+        Args:
+            column_content: Content lines of the column
+            columns_children: List to append the column block to
+            in_column: Whether we're currently in a column (if False, does nothing)
+            converter_callback: Callback function to convert column content
+        """
+        if not (in_column and column_content):
+            return
+        
+        processed_content = ColumnElement._preprocess_column_content(column_content)
+
+        column_blocks = converter_callback("\n".join(processed_content))
 
-        return matches
+        # Create column block
+        column_block = {"type": "column", "column": {"children": column_blocks}}
+        columns_children.append(column_block)
 
     @classmethod
     def is_multiline(cls) -> bool:
+        """Column blocks span multiple lines."""
         return True
+    
+    @staticmethod
+    def _preprocess_column_content(lines: List[str]) -> List[str]:
+        """
+        Preprocess column content to handle special cases like first headings.
+        
+        This removes any spacer markers that might have been added before the first
+        heading in a column, as each column should have its own heading context.
+        
+        Args:
+            lines: The lines of content for the column
+            
+        Returns:
+            Processed lines ready for conversion
+        """
+        from notionary.page.markdown_to_notion_converter import MarkdownToNotionConverter
+
+        processed_lines = []
+        found_first_heading = False
+        spacer_marker = MarkdownToNotionConverter.SPACER_MARKER
+        
+        i = 0
+        while i < len(lines):
+            line = lines[i]
+            
+            # Check if this is a heading line
+            if re.match(r"^(#{1,6})\s+(.+)$", line.strip()):
+                # If it's the first heading, look ahead to check for spacer
+                if not found_first_heading and i > 0 and processed_lines and processed_lines[-1] == spacer_marker:
+                    # Remove spacer before first heading in column
+                    processed_lines.pop()
+                
+                found_first_heading = True
+            
+            processed_lines.append(line)
+            i += 1
+        
+        return processed_lines
 
     @classmethod
     def get_llm_prompt_content(cls) -> ElementPromptContent:
         """
-        Returns structured LLM prompt metadata for the columns element.
+        Returns structured LLM prompt metadata for the column layout element.
         """
-        return (
-            ElementPromptBuilder()
-            .with_description(
-                "Create multi-column layouts using Pandoc-style fenced divs. Perfect for side-by-side comparisons, "
-                "parallel content, or creating newsletter-style layouts. Each column can contain any markdown content "
-                "including headers, lists, images, and even nested blocks."
-            )
-            .with_usage_guidelines(
-                "Use columns when you need to present information side-by-side for comparison, create visual balance "
-                "in your layout, or organize related content in parallel. Great for pros/cons lists, before/after "
-                "comparisons, or displaying multiple related items. Keep column content balanced in length for best "
-                "visual results."
-            )
-            .with_syntax(
+        return {
+            "description": "Creates a multi-column layout that displays content side by side.",
+            "when_to_use": (
+                "Use columns sparingly, only for direct comparisons or when parallel presentation significantly improves readability. "
+                "Best for pros/cons lists, feature comparisons, or pairing images with descriptions. "
+                "Avoid overusing as it can complicate document structure."
+            ),
+            "syntax": (
                 "::: columns\n"
                 "::: column\n"
                 "Content for first column\n"
@@ -116,89 +325,29 @@ class ColumnsElement(NotionBlockElement):
                 "Content for second column\n"
                 ":::\n"
                 ":::"
-            )
-            .with_examples(
-                [
-                    # Simple two-column example
-                    "::: columns\n"
-                    "::: column\n"
-                    "### Pros\n"
-                    "- Fast performance\n"
-                    "- Easy to use\n"
-                    "- Great documentation\n"
-                    ":::\n"
-                    "::: column\n"
-                    "### Cons\n"
-                    "- Limited customization\n"
-                    "- Requires subscription\n"
-                    "- No offline mode\n"
-                    ":::\n"
-                    ":::",
-                    # Three-column example
-                    "::: columns\n"
-                    "::: column\n"
-                    "**Python**\n"
-                    "```python\n"
-                    "print('Hello')\n"
-                    "```\n"
-                    ":::\n"
-                    "::: column\n"
-                    "**JavaScript**\n"
-                    "```javascript\n"
-                    "console.log('Hello');\n"
-                    "```\n"
-                    ":::\n"
-                    "::: column\n"
-                    "**Ruby**\n"
-                    "```ruby\n"
-                    "puts 'Hello'\n"
-                    "```\n"
-                    ":::\n"
-                    ":::",
-                    # Mixed content example
-                    "::: columns\n"
-                    "::: column\n"
-                    "![Image](url)\n"
-                    "Product photo\n"
-                    ":::\n"
-                    "::: column\n"
-                    "## Product Details\n"
-                    "- Price: $99\n"
-                    "- Weight: 2kg\n"
-                    "- Color: Blue\n"
-                    "\n"
-                    "[Order Now](link)\n"
-                    ":::\n"
-                    ":::",
-                ]
-            )
-            .with_avoidance_guidelines(
-                "Avoid nesting column blocks within column blocks - this creates confusing layouts. "
-                "Don't use columns for content that should be read sequentially. Keep the number of columns "
-                "reasonable (2-4 max) for readability. Ensure each ::: marker is on its own line with proper "
-                "nesting. Don't mix column syntax with regular markdown formatting on the same line."
-            )
-            .build()
-        )
-
-    @classmethod
-    def get_column_content(cls, text: str) -> List[str]:
-        """
-        Extract the content of individual columns from the markdown.
-        This is a helper method that can be used by the implementation
-        to process column content separately.
-
-        Args:
-            text: The complete columns markdown block
-
-        Returns:
-            List of column content strings
-        """
-        match = cls.PATTERN.search(text)
-        if not match:
-            return []
-
-        columns_content = match.group(1)
-        return [
-            content.strip() for content in cls.COLUMN_PATTERN.findall(columns_content)
-        ]
+            ),
+            "examples": [
+                "::: columns\n"
+                "::: column\n"
+                "## Features\n"
+                "- Fast response time\n"
+                "- Intuitive interface\n"
+                "- Regular updates\n"
+                ":::\n"
+                "::: column\n"
+                "## Benefits\n"
+                "- Increased productivity\n"
+                "- Better collaboration\n"
+                "- Simplified workflows\n"
+                ":::\n"
+                ":::",
+                "::: columns\n"
+                "::: column\n"
+                "![Image placeholder](/api/placeholder/400/320)\n"
+                ":::\n"
+                "::: column\n"
+                "This text appears next to the image, creating a media-with-caption style layout that's perfect for documentation or articles.\n"
+                ":::\n"
+                ":::",
+            ],
+        }

notionary/elements/divider_element.py

@@ -64,4 +64,4 @@ class DividerElement(NotionBlockElement):
                 ["## Section 1\nContent\n\n---\n\n## Section 2\nMore content"]
             )
             .build()
-        )
+        )

notionary/elements/heading_element.py

@@ -85,7 +85,10 @@ class HeadingElement(NotionBlockElement):
             .with_usage_guidelines(
                 "Use to group content into sections and define a visual hierarchy."
             )
+            .with_avoidance_guidelines(
+                "Only H1-H3 syntax is supported. H4 and deeper heading levels are not available."
+            )
             .with_syntax("## Your Heading Text")
             .with_standard_markdown()
             .build()
-        )
+        )

notionary/elements/registry/block_registry.py

@@ -126,7 +126,7 @@ class BlockRegistry:
 
         formatter_names = [e.__name__ for e in element_classes]
         if "TextInlineFormatter" not in formatter_names:
-            element_classes = element_classes +  [TextInlineFormatter]
+            element_classes = element_classes + [TextInlineFormatter]
 
         return MarkdownSyntaxPromptGenerator.generate_system_prompt(element_classes)
 

notionary/elements/registry/block_registry_builder.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 from typing import List, Type
 from collections import OrderedDict
 
+from notionary.elements.column_element import ColumnElement
 from notionary.elements.notion_block_element import NotionBlockElement
 
 from notionary.elements.audio_element import AudioElement
@@ -27,7 +28,6 @@ from notionary.elements.toggleable_heading_element import ToggleableHeadingEleme
 from notionary.elements.video_element import VideoElement
 from notionary.elements.toggle_element import ToggleElement
 from notionary.elements.bookmark_element import BookmarkElement
-from notionary.elements.column_element import ColumnsElement
 
 
 class BlockRegistryBuilder:
@@ -64,6 +64,7 @@ class BlockRegistryBuilder:
             .with_videos()
             .with_embeds()
             .with_audio()
+            .with_columns()
             .with_mention()
             .with_paragraphs()
             .with_toggleable_heading_element()
@@ -267,7 +268,7 @@ class BlockRegistryBuilder:
         """
         Add support for column elements.
         """
-        return self.add_element(ColumnsElement)
+        return self.add_element(ColumnElement)
 
     def build(self) -> BlockRegistry:
         """

notionary/page/content/page_content_writer.py

@@ -1,5 +1,4 @@
 from typing import Any, Dict
-from textwrap import dedent
 
 from notionary.elements.divider_element import DividerElement
 from notionary.elements.registry.block_registry import BlockRegistry
@@ -39,16 +38,6 @@ class PageContentWriter(LoggingMixin):
         """
         Append markdown text to a Notion page, automatically handling content length limits.
         """
-        # Check for leading whitespace in the first three lines and log a warning if found
-        first_three_lines = markdown_text.split('\n')[:3]
-        if any(line.startswith(' ') or line.startswith('\t') for line in first_three_lines):
-            self.logger.warning(
-                "Leading whitespace detected in input markdown. Consider using textwrap.dedent or similar logic: "
-                "this code is indented the wrong way, which could lead to formatting issues."
-            )
-        
-        markdown_text = "\n".join(line.lstrip() for line in markdown_text.split("\n"))
-
         if append_divider and not self.block_registry.contains(DividerElement):
             self.logger.warning(
                 "DividerElement not registered. Appending divider skipped."
@@ -57,7 +46,9 @@ class PageContentWriter(LoggingMixin):
 
         # Append divider in markdown format as it will be converted to a Notion divider block
         if append_divider:
-            markdown_text = markdown_text + "\n\n---\n\n"
+            markdown_text = markdown_text + "\n---"
+
+        markdown_text = self._process_markdown_whitespace(markdown_text)
 
         try:
             blocks = self._markdown_to_notion_converter.convert(markdown_text)
@@ -111,3 +102,102 @@ class PageContentWriter(LoggingMixin):
         except Exception as e:
             self.logger.error("Failed to delete block: %s", str(e))
             return False
+
+    def _process_markdown_whitespace(self, markdown_text: str) -> str:
+        """
+        Process markdown text to preserve code structure while removing unnecessary indentation.
+        Strips all leading whitespace from regular lines, but preserves relative indentation
+        within code blocks.
+
+        Args:
+            markdown_text: Original markdown text with potential leading whitespace
+
+        Returns:
+            Processed markdown text with corrected whitespace
+        """
+        lines = markdown_text.split("\n")
+        if not lines:
+            return ""
+
+        processed_lines = []
+        in_code_block = False
+        current_code_block = []
+
+        for line in lines:
+            # Handle code block markers
+            if self._is_code_block_marker(line):
+                if not in_code_block:
+                    # Starting a new code block
+                    in_code_block = True
+                    processed_lines.append(self._process_code_block_start(line))
+                    current_code_block = []
+                    continue
+
+                # Ending a code block
+                processed_lines.extend(
+                    self._process_code_block_content(current_code_block)
+                )
+                processed_lines.append("```")
+                in_code_block = False
+                continue
+
+            # Handle code block content
+            if in_code_block:
+                current_code_block.append(line)
+                continue
+
+            # Handle regular text
+            processed_lines.append(line.lstrip())
+
+        # Handle unclosed code block
+        if in_code_block and current_code_block:
+            processed_lines.extend(self._process_code_block_content(current_code_block))
+            processed_lines.append("```")
+
+        return "\n".join(processed_lines)
+
+    def _is_code_block_marker(self, line: str) -> bool:
+        """Check if a line is a code block marker."""
+        return line.lstrip().startswith("```")
+
+    def _process_code_block_start(self, line: str) -> str:
+        """Extract and normalize the code block opening marker."""
+        language = line.lstrip().replace("```", "", 1).strip()
+        return "```" + language
+
+    def _process_code_block_content(self, code_lines: list) -> list:
+        """
+        Normalize code block indentation by removing the minimum common indentation.
+
+        Args:
+            code_lines: List of code block content lines
+
+        Returns:
+            List of processed code lines with normalized indentation
+        """
+        if not code_lines:
+            return []
+
+        # Find non-empty lines to determine minimum indentation
+        non_empty_code_lines = [line for line in code_lines if line.strip()]
+        if not non_empty_code_lines:
+            return [""] * len(code_lines)  # All empty lines stay empty
+
+        # Calculate minimum indentation
+        min_indent = min(
+            len(line) - len(line.lstrip()) for line in non_empty_code_lines
+        )
+        if min_indent == 0:
+            return code_lines  # No common indentation to remove
+
+        # Process each line
+        processed_code_lines = []
+        for line in code_lines:
+            if not line.strip():
+                processed_code_lines.append("")  # Keep empty lines empty
+                continue
+
+            # Remove exactly the minimum indentation
+            processed_code_lines.append(line[min_indent:])
+
+        return processed_code_lines

notionary/page/markdown_to_notion_converter.py

@@ -1,6 +1,7 @@
 from typing import Dict, Any, List, Optional, Tuple
 import re
 
+from notionary.elements.column_element import ColumnElement
 from notionary.elements.registry.block_registry import BlockRegistry
 from notionary.elements.registry.block_registry_builder import (
     BlockRegistryBuilder,
@@ -22,6 +23,9 @@ class MarkdownToNotionConverter:
             block_registry or BlockRegistryBuilder().create_full_registry()
         )
 
+        if self._block_registry.contains(ColumnElement):
+            ColumnElement.set_converter_callback(self.convert)
+
     def convert(self, markdown_text: str) -> List[Dict[str, Any]]:
         """Convert markdown text to Notion API block format."""
         if not markdown_text:
@@ -29,6 +33,7 @@ class MarkdownToNotionConverter:
 
         # Preprocess markdown to add spacers before headings and dividers
         processed_markdown = self._add_spacers_before_elements(markdown_text)
+        print("Processed Markdown:", processed_markdown)
 
         # Collect all blocks with their positions in the text
         all_blocks_with_positions = self._collect_all_blocks_with_positions(
@@ -45,37 +50,133 @@ class MarkdownToNotionConverter:
         return self._process_block_spacing(blocks)
 
     def _add_spacers_before_elements(self, markdown_text: str) -> str:
-        """Add spacer markers before every heading (except the first one) and before every divider."""
-        lines = markdown_text.split('\n')
+        """Add spacer markers before every heading (except the first one) and before every divider,
+        but ignore content inside code blocks and consecutive headings."""
+        lines = markdown_text.split("\n")
         processed_lines = []
         found_first_heading = False
-        
+        in_code_block = False
+        last_line_was_spacer = False
+        last_non_empty_was_heading = False
+
         i = 0
         while i < len(lines):
             line = lines[i]
-            
-            # Check if line is a heading
-            if re.match(self.HEADING_PATTERN, line):
-                if found_first_heading:
-                    # Only add a single spacer line before headings (no extra line breaks)
-                    processed_lines.append(self.SPACER_MARKER)
-                else:
-                    found_first_heading = True
-                
+
+            # Check for code block boundaries and handle accordingly
+            if self._is_code_block_marker(line):
+                in_code_block = not in_code_block
+                processed_lines.append(line)
+                if line.strip():  # If not empty
+                    last_non_empty_was_heading = False
+                last_line_was_spacer = False
+                i += 1
+                continue
+
+            # Skip processing markdown inside code blocks
+            if in_code_block:
                 processed_lines.append(line)
-            
-            # Check if line is a divider
-            elif re.match(self.DIVIDER_PATTERN, line):
+                if line.strip():  # If not empty
+                    last_non_empty_was_heading = False
+                last_line_was_spacer = False
+                i += 1
+                continue
+
+            # Process line with context about consecutive headings
+            result = self._process_line_for_spacers(
+                line,
+                processed_lines,
+                found_first_heading,
+                last_line_was_spacer,
+                last_non_empty_was_heading,
+            )
+
+            last_line_was_spacer = result["added_spacer"]
+
+            # Update tracking of consecutive headings and first heading
+            if line.strip():  # Not empty line
+                is_heading = re.match(self.HEADING_PATTERN, line) is not None
+                if is_heading:
+                    if not found_first_heading:
+                        found_first_heading = True
+                    last_non_empty_was_heading = True
+                elif line.strip() != self.SPACER_MARKER:  # Not a spacer or heading
+                    last_non_empty_was_heading = False
+
+            i += 1
+
+        return "\n".join(processed_lines)
+
+    def _is_code_block_marker(self, line: str) -> bool:
+        """Check if a line is a code block marker (start or end)."""
+        return line.strip().startswith("```")
+
+    def _process_line_for_spacers(
+        self,
+        line: str,
+        processed_lines: List[str],
+        found_first_heading: bool,
+        last_line_was_spacer: bool,
+        last_non_empty_was_heading: bool,
+    ) -> Dict[str, bool]:
+        """
+        Process a single line to add spacers before headings and dividers if needed.
+
+        Args:
+            line: The line to process
+            processed_lines: List of already processed lines to append to
+            found_first_heading: Whether the first heading has been found
+            last_line_was_spacer: Whether the last added line was a spacer
+            last_non_empty_was_heading: Whether the last non-empty line was a heading
+
+        Returns:
+            Dictionary with processing results
+        """
+        added_spacer = False
+        line_stripped = line.strip()
+        is_empty = not line_stripped
+
+        # Skip empty lines
+        if is_empty:
+            processed_lines.append(line)
+            return {"added_spacer": False}
+
+        # Check if line is a heading
+        if re.match(self.HEADING_PATTERN, line):
+            if (
+                found_first_heading
+                and not last_line_was_spacer
+                and not last_non_empty_was_heading
+            ):
+                # Add spacer only if:
+                # 1. Not the first heading
+                # 2. Last non-empty line was not a heading
+                # 3. Last line was not already a spacer
+                processed_lines.append(self.SPACER_MARKER)
+                added_spacer = True
+
+            processed_lines.append(line)
+
+        # Check if line is a divider
+        elif re.match(self.DIVIDER_PATTERN, line):
+            if not last_line_was_spacer:
                 # Only add a single spacer line before dividers (no extra line breaks)
                 processed_lines.append(self.SPACER_MARKER)
+                added_spacer = True
+
+            processed_lines.append(line)
+
+        # Check if this line itself is a spacer
+        elif line_stripped == self.SPACER_MARKER:
+            # Never add consecutive spacers
+            if not last_line_was_spacer:
                 processed_lines.append(line)
-            
-            else:
-                processed_lines.append(line)
-            
-            i += 1
-        
-        return '\n'.join(processed_lines)
+                added_spacer = True
+
+        else:
+            processed_lines.append(line)
+
+        return {"added_spacer": added_spacer}
 
     def _collect_all_blocks_with_positions(
         self, markdown_text: str
@@ -464,4 +565,4 @@ class MarkdownToNotionConverter:
             return False
 
         rich_text = block.get("paragraph", {}).get("rich_text", [])
-        return not rich_text or len(rich_text) == 0
+        return not rich_text or len(rich_text) == 0

notionary/prompting/markdown_syntax_prompt_generator.py

@@ -11,8 +11,7 @@ class MarkdownSyntaxPromptGenerator:
     and formats them optimally for LLMs.
     """
 
-    SYSTEM_PROMPT_TEMPLATE = (
-    """
+    SYSTEM_PROMPT_TEMPLATE = """
     You create content for Notion pages using Markdown syntax with special Notion extensions.
 
     # Understanding Notion Blocks
@@ -56,7 +55,6 @@ class MarkdownSyntaxPromptGenerator:
    - Format as: ## 🚀 Heading Text (with space after emoji)
    - Only omit emojis if the user explicitly instructs you not to use them
     """
-    )
 
     @staticmethod
     def generate_element_doc(element_class: Type[NotionBlockElement]) -> str:
@@ -114,4 +112,4 @@ class MarkdownSyntaxPromptGenerator:
         Generates a complete system prompt for LLMs.
         """
         element_docs = cls.generate_element_docs(element_classes)
-        return cls.SYSTEM_PROMPT_TEMPLATE.format(element_docs=element_docs)
+        return cls.SYSTEM_PROMPT_TEMPLATE.format(element_docs=element_docs)

{notionary-0.2.7.dist-info → notionary-0.2.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: notionary
-Version: 0.2.7
+Version: 0.2.8
 Summary: A toolkit to convert between Markdown and Notion blocks
 Home-page: https://github.com/mathisarends/notionary
 Author: Mathis Arends
@@ -153,6 +153,31 @@ Notionary extends standard Markdown with special syntax to support Notion-specif
 | 3. Add content with replace_content() or append_markdown()
 ```
 
+### Multi-Column Layout
+
+```markdown
+::: columns
+::: column
+
+## Left Column
+
+- Item 1
+- Item 2
+- Item 3
+  :::
+  ::: column
+
+## Right Column
+
+This text appears in the second column. Multi-column layouts are perfect for:
+
+- Comparing features
+- Creating side-by-side content
+- Improving readability of wide content
+  :::
+  :::
+```
+
 ### Code Blocks
 
 ```python
@@ -196,6 +221,7 @@ custom_registry = (
     .with_headings()
     .with_callouts()
     .with_toggles()
+    .with_columns()  # Include multi-column support
     .with_code()
     .with_todos()
     .with_paragraphs()
@@ -205,7 +231,7 @@ custom_registry = (
 # Apply this registry to a page
 page = NotionPage.from_url("https://www.notion.so/your-page-url")
 page.block_registry = custom_registry
-ark
+
 # Replace content using only supported elements
 await page.replace_content("# Custom heading with selected elements only")
 ```

{notionary-0.2.7.dist-info → notionary-0.2.8.dist-info}/RECORD

@@ -9,10 +9,10 @@ notionary/elements/bookmark_element.py,sha256=msCtZvuPkIj1kiShNwE8i1GDYwamFb5mwR
 notionary/elements/bulleted_list_element.py,sha256=obsb3JqUNET3uS5OZM3yzDqxSzJzUuEob-Fzx0UIg9Y,2664
 notionary/elements/callout_element.py,sha256=ZsRvRtVy9kxdTwgrB5JGjZ4qcCiwcC0WimWJ_cW0aLY,4492
 notionary/elements/code_block_element.py,sha256=YHOiV2eQIe7gbsOnrsQnztomTZ-eP3HRHsonzrj3Tt8,7529
-notionary/elements/column_element.py,sha256=lMVRKXndOuN6lsBMlkgZ-11uuoEFLtUFedwrPAswL1E,7555
-notionary/elements/divider_element.py,sha256=Kt2oJJQD3zKyWSQ3JOG0nUgYqJRodMO4UVy7EXixxes,2330
+notionary/elements/column_element.py,sha256=pUgu0e2vptvti2Mms_jcivSX0VmeBY9B1asCrVnXrxc,12476
+notionary/elements/divider_element.py,sha256=h6lzk4HITuBwHzxQU967QCWL4F8j2GfEOloWnZ8xs8E,2332
 notionary/elements/embed_element.py,sha256=Zcc18Kl8SGoG98P2aYE0TkBviRvSz-sYOdjMEs-tvgk,4579
-notionary/elements/heading_element.py,sha256=kqgjyfaawEODir2tzDyf7-7wm38DbqoZnsH5k94GsA0,3013
+notionary/elements/heading_element.py,sha256=4X8LLhUb2oyfErQ5p-r0bq3wSR6TGSTSQjoVAhVnTO4,3166
 notionary/elements/image_element.py,sha256=cwdovaWK8e4uZJU97l_fJ2etAxAgM2rG2EE34t4eag8,4758
 notionary/elements/mention_element.py,sha256=L4t6eAY3RcbOqIiwVT_CAqwatDtP4tBs9FaqRhaCbpQ,8227
 notionary/elements/notion_block_element.py,sha256=BVrZH09vyojuacs3KGReVx3W0Ee6di_5o9E8N5sex28,1258
@@ -25,20 +25,20 @@ notionary/elements/todo_element.py,sha256=ND3oOzSnd0l1AUGTcG2NiHW50ZbI4-atjtNorL
 notionary/elements/toggle_element.py,sha256=h9vYkkAIUHzn-0mu31qC6UPdlk_0EFIsU5A4T_A2ZI8,11082
 notionary/elements/toggleable_heading_element.py,sha256=XdaPsd8anufwAACL8J-Egd_RcqPqZ1gFlzeol1GOyyc,9960
 notionary/elements/video_element.py,sha256=y0OmOYXdQBc2rSYAHRmA4l4rzNqPnyhuXbEipcgzQgY,5727
-notionary/elements/registry/block_registry.py,sha256=T2yKRyzsdC9OSWdsiG-AI2T60SmtaR-7QaM6lOz0qrw,5028
-notionary/elements/registry/block_registry_builder.py,sha256=KU1Qh3qaB1lMrSBj1iyi8Hkx1h0HfxtajmkXZhMb68k,9545
+notionary/elements/registry/block_registry.py,sha256=g0id_Q6guzTyNY6HfnB9AjOBvCR4CvtpnUeFAY8kgY0,5027
+notionary/elements/registry/block_registry_builder.py,sha256=5zRKnw2102rAeHpANs6Csu4DVufOazf1peEovChWcgs,9572
 notionary/exceptions/database_exceptions.py,sha256=I-Tx6bYRLpi5pjGPtbT-Mqxvz3BFgYTiuZxknJeLxtI,2638
 notionary/exceptions/page_creation_exception.py,sha256=4v7IuZD6GsQLrqhDLriGjuG3ML638gAO53zDCrLePuU,281
 notionary/models/notion_block_response.py,sha256=gzL4C6K9QPcaMS6NbAZaRceSEnMbNwYBVVzxysza5VU,6002
 notionary/models/notion_database_response.py,sha256=FMAasQP20S12J_KMdMlNpcHHwxFKX2YtbE4Q9xn-ruQ,1213
 notionary/models/notion_page_response.py,sha256=r4fwMwwDocj92JdbSmyrzIqBKsnEaz4aDUiPabrg9BM,1762
-notionary/page/markdown_to_notion_converter.py,sha256=QYlxotQoBK5Ruj7UvfYfMdbsylQCMw7OX6Ng5CyMeVo,17097
+notionary/page/markdown_to_notion_converter.py,sha256=-IC2yJimrmJ7e5EorV-48V6V12n1VBmsOHKejZxAKCo,20909
 notionary/page/notion_page.py,sha256=NDxAJaNk4tlKUrenhKBdnuvjlVgnxC0Z6fprf2LyNeE,18046
 notionary/page/notion_page_factory.py,sha256=2A3M5Ub_kV2-q7PPRqDgfwBjhkGCwtL5i3Kr2RfvvVo,7213
 notionary/page/notion_to_markdown_converter.py,sha256=vUQss0J7LUFLULGvW27PjaTFuWi8OsRQAUBowSYorkM,6408
 notionary/page/content/notion_page_content_chunker.py,sha256=xRks74Dqec-De6-AVTxMPnXs-MSJBzSm1HfJfaHiKr8,3330
 notionary/page/content/page_content_retriever.py,sha256=f8IU1CIfSTTT07m72-vgpUr_VOCsisqqFHQ1JeOhb3g,2222
-notionary/page/content/page_content_writer.py,sha256=ZLqDBiYdkdCjgZgucoBGiUH8qM46zltIbJqu1aBqXzw,4425
+notionary/page/content/page_content_writer.py,sha256=LOn70vFLOzPoCP2vqH922eNEh96B3cNiBuI3eDy8yLA,7439
 notionary/page/metadata/metadata_editor.py,sha256=HI7m8Zn_Lz6x36rBnW1EnbicVS-4Q8NmCJYKN-OlY-c,5130
 notionary/page/metadata/notion_icon_manager.py,sha256=6a9GS5sT0trfuAb0hlF2Cw_Wc1oM59a1QA4kO9asvMA,2576
 notionary/page/metadata/notion_page_cover_manager.py,sha256=gHQSA8EtO4gbkMt_C3nKc0DF44SY_4ycd57cJSihdqk,2215
@@ -50,12 +50,12 @@ notionary/page/relations/notion_page_relation_manager.py,sha256=tfkvLHClaYel_uEa
 notionary/page/relations/notion_page_title_resolver.py,sha256=dIjiEeHjjNT-DrIhz1nynkfHkMpUuJJFOEjb25Wy7f4,3575
 notionary/page/relations/page_database_relation.py,sha256=8lEp8fQjPwjWhA8nZu3k8mW6EEc54ki1Uwf4iUV1DOU,2245
 notionary/prompting/element_prompt_content.py,sha256=tHref-SKA81Ua_IQD2Km7y7BvFtHl74haSIjHNYE3FE,4403
-notionary/prompting/markdown_syntax_prompt_generator.py,sha256=WHTpftR7LdY-yA54TlicVwt6R-mhZ2OpUFmNKaCSG0I,5096
+notionary/prompting/markdown_syntax_prompt_generator.py,sha256=_1qIYlqSfI6q6Fut10t6gGwTQuS8c3QBcC_5DBme9Mo,5084
 notionary/util/logging_mixin.py,sha256=b6wHj0IoVSWXbHh0yynfJlwvIR33G2qmaGNzrqyb7Gs,1825
 notionary/util/page_id_utils.py,sha256=EYNMxgf-7ghzL5K8lKZBZfW7g5CsdY0Xuj4IYmU8RPk,1381
 notionary/util/warn_direct_constructor_usage.py,sha256=vyJR73F95XVSRWIbyij-82IGOpAne9SBPM25eDpZfSU,1715
-notionary-0.2.7.dist-info/licenses/LICENSE,sha256=zOm3cRT1qD49eg7vgw95MI79rpUAZa1kRBFwL2FkAr8,1120
-notionary-0.2.7.dist-info/METADATA,sha256=KZbjwvx9HJQ2BCg5RnRgZrhOGa43r8QMOWF2yKwY1uA,7116
-notionary-0.2.7.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
-notionary-0.2.7.dist-info/top_level.txt,sha256=fhONa6BMHQXqthx5PanWGbPL0b8rdFqhrJKVLf_adSs,10
-notionary-0.2.7.dist-info/RECORD,,
+notionary-0.2.8.dist-info/licenses/LICENSE,sha256=zOm3cRT1qD49eg7vgw95MI79rpUAZa1kRBFwL2FkAr8,1120
+notionary-0.2.8.dist-info/METADATA,sha256=RtbtcBYg8U9oqX64Tl2VD79bf199uwLZEqVD9QQ2jio,7521
+notionary-0.2.8.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+notionary-0.2.8.dist-info/top_level.txt,sha256=fhONa6BMHQXqthx5PanWGbPL0b8rdFqhrJKVLf_adSs,10
+notionary-0.2.8.dist-info/RECORD,,

{notionary-0.2.7.dist-info → notionary-0.2.8.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.4.0)
+Generator: setuptools (80.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any