notionary 0.1.25__py3-none-any.whl → 0.1.27__py3-none-any.whl

notionary/page/metadata/notion_icon_manager.py

@@ -26,19 +26,25 @@ class NotionPageIconManager(LoggingMixin):
         Retrieves the page icon - either emoji or external URL.
 
         Returns:
-            str: Emoji character or URL if set, None if no icon
+            Optional[str]: Emoji character or URL if set, None if no icon
         """
         page_data = await self._client.get_page(self.page_id)
 
-        if not page_data or "icon" not in page_data:
-            return None
-
-        icon_data = page_data.get("icon", {})
+        if not page_data:
+            return ""
+        
+        # Get icon data, default to empty dict if not present or None
+        icon_data = page_data.get("icon")
+        
+        # If icon is None or not present, return None
+        if not icon_data:
+            return ""
+        
         icon_type = icon_data.get("type")
 
         if icon_type == "emoji":
             return icon_data.get("emoji")
-        elif icon_type == "external":
+        if icon_type == "external":
             return icon_data.get("external", {}).get("url")
 
-        return None
+        return ""

notionary/page/notion_page.py

@@ -130,7 +130,7 @@ class NotionPage(LoggingMixin):
             self._url_loaded = True
         return self._url
 
-    async def append_markdown(self, markdown: str, append_divider=False) -> str:
+    async def append_markdown(self, markdown: str) -> str:
         """
         Append markdown content to the page.
 
@@ -140,9 +140,7 @@ class NotionPage(LoggingMixin):
         Returns:
             str: Status or confirmation message.
         """
-        return await self._page_content_manager.append_markdown(
-            markdown_text=markdown, append_divider=append_divider
-        )
+        return await self._page_content_manager.append_markdown(markdown_text=markdown)
 
     async def clear(self) -> str:
         """
@@ -206,7 +204,7 @@ class NotionPage(LoggingMixin):
         """
         return await self._page_icon_manager.set_icon(emoji, external_url)
 
-    async def get_icon(self) -> Optional[str]:
+    async def get_icon(self) -> str:
         """
         Retrieve the page icon - either emoji or external URL.
 

notionary/page/notion_to_markdown_converter.py

@@ -1,8 +1,6 @@
 from typing import Dict, Any, List, Optional
 
-from notionary.elements.registry.block_element_registry import (
-    BlockElementRegistry,
-)
+from notionary.elements.registry.block_element_registry import BlockElementRegistry
 from notionary.elements.registry.block_element_registry_builder import (
     BlockElementRegistryBuilder,
 )
@@ -11,12 +9,12 @@ from notionary.elements.registry.block_element_registry_builder import (
 class NotionToMarkdownConverter:
     """Converts Notion blocks to Markdown text with support for nested structures."""
 
+    TOGGLE_ELEMENT_TYPES = ["toggle", "toggleable_heading"]
+    LIST_ITEM_TYPES = ["numbered_list_item", "bulleted_list_item"]
+
     def __init__(self, block_registry: Optional[BlockElementRegistry] = None):
         """
         Initialize the NotionToMarkdownConverter.
-
-        Args:
-            block_registry: Optional registry of Notion block elements
         """
         self._block_registry = (
             block_registry or BlockElementRegistryBuilder().create_full_registry()
@@ -25,12 +23,6 @@ class NotionToMarkdownConverter:
     def convert(self, blocks: List[Dict[str, Any]]) -> str:
         """
         Convert Notion blocks to Markdown text, handling nested structures.
-
-        Args:
-            blocks: List of Notion blocks
-
-        Returns:
-            Markdown text
         """
         if not blocks:
             return ""
@@ -47,12 +39,6 @@ class NotionToMarkdownConverter:
     def _convert_single_block_with_children(self, block: Dict[str, Any]) -> str:
         """
         Process a single block, including any children.
-
-        Args:
-            block: Notion block to process
-
-        Returns:
-            Markdown representation of the block and its children
         """
         if not block:
             return ""
@@ -68,17 +54,14 @@ class NotionToMarkdownConverter:
 
         block_type = block.get("type", "")
 
-        if block_type == "toggle":
+        if block_type in self.TOGGLE_ELEMENT_TYPES:
             return self._format_toggle_with_children(block_markdown, children_markdown)
 
-        if block_type in ["numbered_list_item", "bulleted_list_item"]:
+        if block_type in self.LIST_ITEM_TYPES:
             return self._format_list_item_with_children(
                 block_markdown, children_markdown
             )
 
-        if block_type in ["column_list", "column"]:
-            return children_markdown
-
         return self._format_standard_block_with_children(
             block_markdown, children_markdown
         )
@@ -86,12 +69,6 @@ class NotionToMarkdownConverter:
     def _has_children(self, block: Dict[str, Any]) -> bool:
         """
         Check if block has children that need processing.
-
-        Args:
-            block: Notion block to check
-
-        Returns:
-            True if block has children to process
         """
         return block.get("has_children", False) and "children" in block
 
@@ -99,14 +76,7 @@ class NotionToMarkdownConverter:
         self, toggle_markdown: str, children_markdown: str
     ) -> str:
         """
-        Format toggle block with its children content.
-
-        Args:
-            toggle_markdown: Markdown for the toggle itself
-            children_markdown: Markdown for toggle's children
-
-        Returns:
-            Formatted markdown with indented children
+        Format toggle or toggleable_heading block with its children content.
         """
         indented_children = self._indent_text(children_markdown)
         return f"{toggle_markdown}\n{indented_children}"
@@ -116,13 +86,6 @@ class NotionToMarkdownConverter:
     ) -> str:
         """
         Format list item with its children content.
-
-        Args:
-            item_markdown: Markdown for the list item itself
-            children_markdown: Markdown for item's children
-
-        Returns:
-            Formatted markdown with indented children
         """
         indented_children = self._indent_text(children_markdown)
         return f"{item_markdown}\n{indented_children}"
@@ -132,26 +95,12 @@ class NotionToMarkdownConverter:
     ) -> str:
         """
         Format standard block with its children content.
-
-        Args:
-            block_markdown: Markdown for the block itself
-            children_markdown: Markdown for block's children
-
-        Returns:
-            Formatted markdown with children after block
         """
         return f"{block_markdown}\n\n{children_markdown}"
 
     def _indent_text(self, text: str, spaces: int = 4) -> str:
         """
         Indent each line of text with specified number of spaces.
-
-        Args:
-            text: Text to indent
-            spaces: Number of spaces to use for indentation
-
-        Returns:
-            Indented text
         """
         indent = " " * spaces
         return "\n".join([f"{indent}{line}" for line in text.split("\n")])
@@ -159,12 +108,6 @@ class NotionToMarkdownConverter:
     def extract_toggle_content(self, blocks: List[Dict[str, Any]]) -> str:
         """
         Extract only the content of toggles from blocks.
-
-        Args:
-            blocks: List of Notion blocks
-
-        Returns:
-            Markdown text with toggle contents
         """
         if not blocks:
             return ""
@@ -181,12 +124,8 @@ class NotionToMarkdownConverter:
     ) -> None:
         """
         Recursively extract toggle content from a block and its children.
-
-        Args:
-            block: Block to process
-            result: List to collect toggle content
         """
-        if self._is_toggle_with_children(block):
+        if self._is_toggle_or_heading_with_children(block):
             self._add_toggle_header_to_result(block, result)
             self._add_toggle_children_to_result(block, result)
 
@@ -194,31 +133,27 @@ class NotionToMarkdownConverter:
             for child in block["children"]:
                 self._extract_toggle_content_recursive(child, result)
 
-    def _is_toggle_with_children(self, block: Dict[str, Any]) -> bool:
+    def _is_toggle_or_heading_with_children(self, block: Dict[str, Any]) -> bool:
         """
-        Check if block is a toggle with children.
-
-        Args:
-            block: Block to check
-
-        Returns:
-            True if block is a toggle with children
+        Check if block is a toggle or toggleable_heading with children.
         """
-        return block.get("type") == "toggle" and "children" in block
+        return block.get("type") in self.TOGGLE_ELEMENT_TYPES and "children" in block
 
     def _add_toggle_header_to_result(
         self, block: Dict[str, Any], result: List[str]
     ) -> None:
         """
         Add toggle header text to result list.
-
-        Args:
-            block: Toggle block
-            result: List to add header to
         """
-        toggle_text = self._extract_text_from_rich_text(
-            block.get("toggle", {}).get("rich_text", [])
-        )
+        block_type = block.get("type")
+        rich_text = None
+
+        if block_type == "toggle":
+            rich_text = block.get("toggle", {}).get("rich_text", [])
+        elif block_type == "toggleable_heading":
+            rich_text = block.get("toggleable_heading", {}).get("rich_text", [])
+
+        toggle_text = self._extract_text_from_rich_text(rich_text or [])
 
         if toggle_text:
             result.append(f"### {toggle_text}")
@@ -228,10 +163,6 @@ class NotionToMarkdownConverter:
     ) -> None:
         """
         Add formatted toggle children to result list.
-
-        Args:
-            block: Toggle block with children
-            result: List to add children content to
         """
         for child in block.get("children", []):
             child_type = child.get("type")
@@ -248,12 +179,6 @@ class NotionToMarkdownConverter:
     def _extract_text_from_rich_text(self, rich_text: List[Dict[str, Any]]) -> str:
         """
         Extract plain text from Notion's rich text array.
-
-        Args:
-            rich_text: List of rich text objects
-
-        Returns:
-            Concatenated plain text
         """
         if not rich_text:
             return ""

{notionary-0.1.25.dist-info → notionary-0.1.27.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: notionary
-Version: 0.1.25
+Version: 0.1.27
 Summary: A toolkit to convert between Markdown and Notion blocks
 Home-page: https://github.com/mathisarends/notionary
 Author: Mathis Arends

notionary-0.1.27.dist-info/RECORD

@@ -0,0 +1,58 @@
+notionary/__init__.py,sha256=ypCkbF1YEcwy5aE2kGFmtJOZq41Vs01lahJNqRO27fU,735
+notionary/notion_client.py,sha256=6YhaDK9UjH18Q0f1bxVVNGMbCvpQhatse6WRVIARGCE,6035
+notionary/database/database_discovery.py,sha256=qDGFhXG9s-_6CXdRg8tMiwX4dvX7jLjgAUFPSNlYtlI,4506
+notionary/database/database_info_service.py,sha256=Ig6gx8jUSPYORJvfgEV5kV6t72pZQsWU8HPMqd43B-o,1336
+notionary/database/notion_database.py,sha256=YCOuzrWfKRJvMiWdVfEt8i3NAEqpKDwHj5SX4GUraEk,8017
+notionary/database/notion_database_factory.py,sha256=Af57yaUHidD8TKJ8uyXOc2nnqHm7on6VGFdDRjxiq9o,6692
+notionary/database/models/page_result.py,sha256=Vmm5_oYpYAkIIJVoTd1ZZGloeC3cmFLMYP255mAmtaw,233
+notionary/elements/audio_element.py,sha256=WpcUpIv4U9grZegiCAmyc-Gj3XM3TQVFKr9PQM-QErg,5352
+notionary/elements/bookmark_element.py,sha256=MS2K3pD-hMmS4Fmk1W8BwNL_-j4baHF42EoOWMNIfXw,8152
+notionary/elements/bulleted_list_element.py,sha256=VdMKlxDlixTeYVQIqwM4vQ55xHqABtqzZDqIUATG9oE,2875
+notionary/elements/callout_element.py,sha256=11qr9XGpF7jWle0wbog5eUrE4SAkThDdK9s4oplOxX0,4499
+notionary/elements/code_block_element.py,sha256=6E-fc9zJegSQ_FjB08HImXL2rDQnmkFoRwoPuN-7PwI,6247
+notionary/elements/divider_element.py,sha256=fLWU7Pn0JXIV8tPcuxvMMua4S54JOi2hQRjLcbVwC7g,2218
+notionary/elements/embed_element.py,sha256=NEQopRLMzMIybVLbTt_y1cgaH1-VZW14xkbGJIDirkE,4586
+notionary/elements/heading_element.py,sha256=Su4OUYeDvb9kvAFCmzagKQCNgkwvxsUn1KXJFTuYTFE,3186
+notionary/elements/image_element.py,sha256=Qo94TavAnmJzGveDfdSkOAZeypij-zqbxsJ14rfbKIc,4765
+notionary/elements/mention_element.py,sha256=B88AcU4XqpEXfhXywS_3K7TJIgoJT_3tWzJ_KcdJ4V4,8234
+notionary/elements/notion_block_element.py,sha256=HN1Bu9wAaFsRIN6jkZSclo6KgB4nNvcVx7hlPWIhmy8,1265
+notionary/elements/numbered_list_element.py,sha256=zW1MjNU_02mJBDGnaQFkAESY_i1rCYgp9o4zl6Au0DQ,2865
+notionary/elements/paragraph_element.py,sha256=JuAN4cFRsJkePD7s7TNhDdSuojZtr6WOaCTGzJsBEGg,3262
+notionary/elements/qoute_element.py,sha256=jG4FkD7Ieec3piBWcOeCZPgvw0GF0KZlxzdx2svQC0M,6129
+notionary/elements/table_element.py,sha256=ujlo6bwrmKrQWRWGuUQebeDS-1T-c_R0SkzaPEPy2m8,11256
+notionary/elements/text_inline_formatter.py,sha256=RdegEHvS5_AzDtqYxKb4b0uDbcpp3UhxHo6GyR84NFc,7780
+notionary/elements/todo_element.py,sha256=cWuu8R55hNj6ubjrLu2yJpoeij7UfWhvmaklqcx8AI8,4131
+notionary/elements/toggle_element.py,sha256=o7Utj0nKZAW5MzF_RMyD36HSWMj1cZmLEmqfGH-BFuY,11089
+notionary/elements/toggleable_heading_element.py,sha256=EAkL9mU6u13JEgUOx6CeAhD8P3L_q6L_M_C8qZ_OTSs,9967
+notionary/elements/video_element.py,sha256=2WwvZuG_UOVBnpEikZFxupe_x321QkczrodZHd5IeCw,5734
+notionary/elements/prompts/element_prompt_content.py,sha256=Snha2FMtWO94kl1KwIJp6n7pY6Z8K-9_zVj1TUyaNNA,3729
+notionary/elements/prompts/synthax_prompt_builder.py,sha256=W3ex5RDszlhMgYPGpemxiEI653hQKl147B-bh_ynR9g,6656
+notionary/elements/registry/block_element_registry.py,sha256=r1V6waYQxZ_4bF6Mx_HmQ42-yhh8E54v-yNRT4PsnLk,3570
+notionary/elements/registry/block_element_registry_builder.py,sha256=C6W64CwFqZBu31hZZqoD-uCZCOMOOXeFVk_SHKSp58U,9048
+notionary/exceptions/database_exceptions.py,sha256=I-Tx6bYRLpi5pjGPtbT-Mqxvz3BFgYTiuZxknJeLxtI,2638
+notionary/exceptions/page_creation_exception.py,sha256=4v7IuZD6GsQLrqhDLriGjuG3ML638gAO53zDCrLePuU,281
+notionary/page/markdown_to_notion_converter.py,sha256=LFnv98uU3QRzxH7sZI0AE5_QxeHkNQZMxVcab-r8Qls,15877
+notionary/page/notion_page.py,sha256=OXE2sw9Drkqduy96uVvXT3vHwHPh5FMJk6QyPRADoFU,17653
+notionary/page/notion_page_factory.py,sha256=UUEZ-cyEWL0OMVPrgjc4vJdcplEa1bO2yHCYooACYC8,8189
+notionary/page/notion_to_markdown_converter.py,sha256=EUiHeurQb73zQJ5Gatvf_67vWd-vOI8qg3yFLz8bf8Q,6452
+notionary/page/content/notion_page_content_chunker.py,sha256=xRks74Dqec-De6-AVTxMPnXs-MSJBzSm1HfJfaHiKr8,3330
+notionary/page/content/page_content_manager.py,sha256=0Bl52mEqKuhDGuJhOEMhGjJWHgxCiqGYjrqO1LqYzJM,6403
+notionary/page/metadata/metadata_editor.py,sha256=61uiw8oB25O8ePhytoJvZDetuof5sjPoM6aoHZGo4wc,4949
+notionary/page/metadata/notion_icon_manager.py,sha256=JWHeJ8yjvAnj1361C-Z3RI8c8aeR9VZw81KP4ks0b6k,1603
+notionary/page/metadata/notion_page_cover_manager.py,sha256=qgQxQE-bx4oWjLFUQvpXD5GzO1Mx7w7htz1xC2BOqUg,1717
+notionary/page/properites/database_property_service.py,sha256=AJuBGahbb53VQa6IGGHxBMoOgCy6vFZg08uR_eDjNUs,11570
+notionary/page/properites/page_property_manager.py,sha256=Xl8Cwn8WVszqpFXT_NvASkmP5igpCTEgRVhG_F45424,6914
+notionary/page/properites/property_formatter.py,sha256=d_Nr5XQxgjB6VIS0u3ey14MOUKY416o_BvdXjbkUNAQ,3667
+notionary/page/properites/property_operation_result.py,sha256=PhxHJJxxG2BdDl7aswhWnMSmf9RQtoinKkRHDoqxwCs,3913
+notionary/page/properites/property_value_extractor.py,sha256=1BfyCYrFzfIUmNTozavrLTjG--6P6Dy2tkewf6rHHwQ,2353
+notionary/page/relations/notion_page_relation_manager.py,sha256=ooN-WxXNPBE_vkNJgbc1wH8iIWBlKa9FHgiMeJjbYdw,13032
+notionary/page/relations/notion_page_title_resolver.py,sha256=XQpa5XY4hoh5UYqpewTYaaftNX52WHyk2XmM4r8B2uY,3016
+notionary/page/relations/page_database_relation.py,sha256=F9aGXFjjL8ZLNbfTGeGm_QAyXhz2AEOw7GgDLdprEcE,2313
+notionary/page/relations/relation_operation_result.py,sha256=NDxBzGntOxc_89ti-HG8xDSqfY6PwyGHKHrrKbCzNjM,5010
+notionary/util/logging_mixin.py,sha256=fKsx9t90bwvL74ZX3dU-sXdC4TZCQyO6qU9I8txkw_U,1369
+notionary/util/page_id_utils.py,sha256=EYNMxgf-7ghzL5K8lKZBZfW7g5CsdY0Xuj4IYmU8RPk,1381
+notionary-0.1.27.dist-info/licenses/LICENSE,sha256=zOm3cRT1qD49eg7vgw95MI79rpUAZa1kRBFwL2FkAr8,1120
+notionary-0.1.27.dist-info/METADATA,sha256=k1K58w6kqtLVWc9pvRgH1O5kFuCR-qivL-vNk9C2IJA,8342
+notionary-0.1.27.dist-info/WHEEL,sha256=GHB6lJx2juba1wDgXDNlMTyM13ckjBMKf-OnwgKOCtA,91
+notionary-0.1.27.dist-info/top_level.txt,sha256=fhONa6BMHQXqthx5PanWGbPL0b8rdFqhrJKVLf_adSs,10
+notionary-0.1.27.dist-info/RECORD,,

{notionary-0.1.25.dist-info → notionary-0.1.27.dist-info}/WHEEL

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

notionary/elements/column_element.py

@@ -1,307 +0,0 @@
-import re
-from typing import Dict, Any, Optional, List, Tuple, Callable
-
-from notionary.elements.notion_block_element import NotionBlockElement
-from notionary.elements.prompts.element_prompt_content import ElementPromptContent
-
-
-class ColumnElement(NotionBlockElement):
-    """
-    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
-    :::
-    :::
-
-    This creates a column layout in Notion with the specified content in each column.
-    """
-
-    COLUMNS_START = re.compile(r"^:::\s*columns\s*$")
-    COLUMN_START = re.compile(r"^:::\s*column\s*$")
-    BLOCK_END = re.compile(r"^:::\s*$")
-
-    _converter_callback = None
-
-    @classmethod
-    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.
-
-        Args:
-            callback: Funktion, die Markdown-Text annimmt und eine Liste von Notion-Blöcken zurückgibt
-        """
-        cls._converter_callback = callback
-
-    @staticmethod
-    def match_markdown(text: str) -> bool:
-        """Check if text starts a columns block."""
-        return bool(ColumnElement.COLUMNS_START.match(text.strip()))
-
-    @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.
-
-        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
-
-        # Create an empty column_list block
-        # Child columns will be added by the column processor
-        return {"type": "column_list", "column_list": {"children": []}}
-
-    @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
-
-        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(":::")
-
-        # End the columns block
-        result.append(":::")
-
-        return "\n".join(result)
-
-    @staticmethod
-    def is_multiline() -> bool:
-        """Column blocks span multiple lines."""
-        return True
-
-    @classmethod
-    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 and blocks.
-
-        Args:
-            text: The input markdown text
-            converter_callback: Optional callback to convert nested content
-
-        Returns:
-            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 = []
-        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, i, 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
-
-        # Process column content using the provided callback
-        column_blocks = converter_callback("\n".join(column_content))
-
-        # Create column block
-        column_block = {"type": "column", "column": {"children": column_blocks}}
-        columns_children.append(column_block)
-
-    @classmethod
-    def get_llm_prompt_content(cls) -> ElementPromptContent:
-        """
-        Returns structured LLM prompt metadata for the column layout element.
-        """
-        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"
-                ":::\n"
-                "::: column\n"
-                "Content for second column\n"
-                ":::\n"
-                ":::"
-            ),
-            "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"
-                ":::",
-            ],
-        }