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

notionary/blocks/_bootstrap.py

@@ -34,6 +34,7 @@ def bootstrap_blocks() -> None:
         toggle,
         toggleable_heading,
         video,
+        child_database,
     )
 
     # Collect all exports from modules
@@ -61,6 +62,7 @@ def bootstrap_blocks() -> None:
         video,
         toggleable_heading,
         table_of_contents,
+        child_database,
     ):
         ns.update(vars(m))
 
@@ -123,6 +125,10 @@ def bootstrap_blocks() -> None:
     from notionary.blocks.toggle.toggle_models import CreateToggleBlock, ToggleBlock
     from notionary.blocks.types import BlockType
     from notionary.blocks.video.video_element_models import CreateVideoBlock
+    from notionary.blocks.child_database.child_database_models import (
+        CreateChildDatabaseBlock,
+        ChildDatabaseBlock,
+    )
 
     # Define the Union types that are needed for model rebuilding
     BlockCreateRequest = Union[
@@ -150,9 +156,10 @@ def bootstrap_blocks() -> None:
         CreateVideoBlock,
         CreateTableOfContentsBlock,
         CreatePdfBlock,
+        CreateChildDatabaseBlock,
     ]
 
-    BlockCreateResult = Optional[Union[list[BlockCreateRequest], BlockCreateRequest]]
+    BlockCreateResult = Optional[BlockCreateRequest]
 
     # Add all block types to namespace
     ns.update(
@@ -202,6 +209,7 @@ def bootstrap_blocks() -> None:
             "CreateVideoBlock": CreateVideoBlock,
             "TableOfContentsBlock": TableOfContentsBlock,
             "CreateTableOfContentsBlock": CreateTableOfContentsBlock,
+            "ChildDatabaseBlock": ChildDatabaseBlock,
             # Add the Union types
             "BlockCreateRequest": BlockCreateRequest,
             "BlockCreateResult": BlockCreateResult,

notionary/blocks/audio/audio_element.py

@@ -6,27 +6,40 @@ from typing import Optional
 from notionary.blocks.audio.audio_models import CreateAudioBlock
 from notionary.blocks.base_block_element import BaseBlockElement
 from notionary.blocks.file.file_element_models import ExternalFile, FileBlock, FileType
+from notionary.blocks.mixins.captions import CaptionMixin
+from notionary.blocks.syntax_prompt_builder import BlockElementMarkdownInformation
 from notionary.blocks.models import Block, BlockCreateResult, BlockType
-from notionary.blocks.rich_text.rich_text_models import RichTextObject
-from notionary.blocks.rich_text.text_inline_formatter import TextInlineFormatter
 
 
-class AudioElement(BaseBlockElement):
+class AudioElement(BaseBlockElement, CaptionMixin):
     """
     Handles conversion between Markdown audio embeds and Notion audio blocks.
 
     Markdown audio syntax:
     - [audio](https://example.com/audio.mp3) - Simple audio embed
-    - [audio](https://example.com/audio.mp3 "Caption text") - Audio with optional caption
+    - [audio](https://example.com/audio.mp3)(caption:Episode 1) - Audio with caption
+    - (caption:Background music)[audio](https://example.com/song.mp3) - caption before URL
 
     Where:
     - URL is the required audio file URL
-    - Caption is optional descriptive text (enclosed in quotes)
+    - Caption supports rich text formatting and is optional
     """
 
-    URL_PATTERN = r"(https?://[^\s\"]+)"
-    CAPTION_PATTERN = r'(?:\s+"([^"]+)")?'
-    PATTERN = re.compile(r"^\[audio\]\(" + URL_PATTERN + CAPTION_PATTERN + r"\)$")
+    # Simple pattern that matches just the audio link, CaptionMixin handles caption separately
+    AUDIO_PATTERN = re.compile(r"\[audio\]\((https?://[^\s\"]+)\)")
+
+    @classmethod
+    def _extract_audio_url(cls, text: str) -> Optional[str]:
+        """Extract audio URL from text, handling caption patterns."""
+        # First remove any captions to get clean text for URL extraction
+        clean_text = cls.remove_caption(text)
+
+        # Now extract the URL from clean text
+        match = cls.AUDIO_PATTERN.search(clean_text)
+        if match:
+            return match.group(1)
+
+        return None
 
     SUPPORTED_EXTENSIONS = {".mp3", ".wav", ".ogg", ".oga", ".m4a"}
 
@@ -36,33 +49,30 @@ class AudioElement(BaseBlockElement):
         return block.type == BlockType.AUDIO
 
     @classmethod
-    def markdown_to_notion(cls, text: str) -> BlockCreateResult:
-        """Convert markdown audio embed to Notion audio block (or return None if not matching)."""
-        match = cls.PATTERN.match(text.strip())
-        if not match:
+    async def markdown_to_notion(cls, text: str) -> BlockCreateResult:
+        """Convert markdown audio embed to Notion audio block."""
+        # Use our helper method to extract the URL
+        url = cls._extract_audio_url(text.strip())
+        if not url:
             return None
-        url = match.group(1)
 
         if not cls._is_likely_audio_url(url):
             return None
-        caption_text = match.group(2)
 
-        # Create caption rich text objects
-        caption_objects = []
-        if caption_text:
-            caption_rt = RichTextObject.from_plain_text(caption_text)
-            caption_objects = [caption_rt]
+        # Use mixin to extract caption (if present anywhere in text)
+        caption_text = cls.extract_caption(text.strip())
+        caption_rich_text = cls.build_caption_rich_text(caption_text or "")
 
         audio_content = FileBlock(
             type=FileType.EXTERNAL,
             external=ExternalFile(url=url),
-            caption=caption_objects,
+            caption=caption_rich_text,
         )
 
         return CreateAudioBlock(audio=audio_content)
 
     @classmethod
-    def notion_to_markdown(cls, block: Block) -> Optional[str]:
+    async def notion_to_markdown(cls, block: Block) -> Optional[str]:
         """Convert Notion audio block to markdown audio embed."""
         if block.type != BlockType.AUDIO or block.audio is None:
             return None
@@ -76,14 +86,29 @@ class AudioElement(BaseBlockElement):
         if not url:
             return None
 
-        # Extract caption
-        captions = audio.caption or []
-        if captions:
-            # use TextInlineFormatter instead of manual extraction
-            caption_text = TextInlineFormatter.extract_text_with_formatting(captions)
-            return f'[audio]({url} "{caption_text}")'
+        result = f"[audio]({url})"
 
-        return f"[audio]({url})"
+        # Add caption if present
+        caption_markdown = await cls.format_caption_for_markdown(audio.caption or [])
+        if caption_markdown:
+            result += caption_markdown
+
+        return result
+
+    @classmethod
+    def get_system_prompt_information(cls) -> Optional[BlockElementMarkdownInformation]:
+        """Get system prompt information for audio blocks."""
+        return BlockElementMarkdownInformation(
+            block_type=cls.__name__,
+            description="Audio blocks embed audio files from external URLs with optional captions",
+            syntax_examples=[
+                "[audio](https://example.com/song.mp3)",
+                "[audio](https://example.com/podcast.wav)(caption:Episode 1)",
+                "(caption:Background music)[audio](https://soundcloud.com/track/123)",
+                "[audio](https://example.com/interview.mp3)(caption:**Live** interview)",
+            ],
+            usage_guidelines="Use for embedding audio files like music, podcasts, or sound effects. Supports common audio formats (mp3, wav, ogg, m4a). Caption supports rich text formatting and is optional.",
+        )
 
     @classmethod
     def _is_likely_audio_url(cls, url: str) -> bool:

notionary/blocks/audio/audio_markdown_node.py

@@ -5,6 +5,7 @@ from typing import Optional
 from pydantic import BaseModel
 
 from notionary.markdown.markdown_node import MarkdownNode
+from notionary.blocks.mixins.captions import CaptionMarkdownNodeMixin
 
 
 class AudioMarkdownBlockParams(BaseModel):
@@ -12,7 +13,7 @@ class AudioMarkdownBlockParams(BaseModel):
     caption: Optional[str] = None
 
 
-class AudioMarkdownNode(MarkdownNode):
+class AudioMarkdownNode(MarkdownNode, CaptionMarkdownNodeMixin):
     """
     Programmatic interface for creating Notion-style audio blocks.
     """
@@ -26,6 +27,11 @@ class AudioMarkdownNode(MarkdownNode):
         return cls(url=params.url, caption=params.caption)
 
     def to_markdown(self) -> str:
-        if self.caption:
-            return f'[audio]({self.url} "{self.caption}")'
-        return f"[audio]({self.url})"
+        """Return the Markdown representation.
+
+        Examples:
+        - [audio](https://example.com/song.mp3)
+        - [audio](https://example.com/song.mp3)(caption:Background music)
+        """
+        base_markdown = f"[audio]({self.url})"
+        return self.append_caption_to_markdown(base_markdown, self.caption)

notionary/blocks/base_block_element.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from abc import ABC
 from typing import Optional
 
+from notionary.blocks.syntax_prompt_builder import BlockElementMarkdownInformation
 from notionary.blocks.models import Block, BlockCreateResult
 
 
@@ -10,7 +11,7 @@ class BaseBlockElement(ABC):
     """Base class for elements that can be converted between Markdown and Notion."""
 
     @classmethod
-    def markdown_to_notion(cls, text: str) -> BlockCreateResult:
+    async def markdown_to_notion(cls, text: str) -> BlockCreateResult:
         """
         Convert markdown to Notion block content.
 
@@ -21,10 +22,21 @@ class BaseBlockElement(ABC):
         """
 
     @classmethod
-    def notion_to_markdown(cls, block: Block) -> Optional[str]:
+    async def notion_to_markdown(cls, block: Block) -> Optional[str]:
         """Convert Notion block to markdown."""
 
     @classmethod
     def match_notion(cls, block: Block) -> bool:
         """Check if this element can handle the given Notion block."""
-        return bool(cls.notion_to_markdown(block))  # Now calls the class's version
+        # Default implementation - subclasses should override this method
+        # Cannot call async notion_to_markdown here
+        return False
+
+    @classmethod
+    def get_system_prompt_information(cls) -> Optional[BlockElementMarkdownInformation]:
+        """Get system prompt information for this block element.
+
+        Subclasses should override this method to provide their specific information.
+        Return None if the element should not be included in documentation.
+        """
+        return None

notionary/blocks/bookmark/bookmark_element.py

@@ -5,60 +5,51 @@ from typing import Optional
 
 from notionary.blocks.base_block_element import BaseBlockElement
 from notionary.blocks.bookmark.bookmark_models import BookmarkBlock, CreateBookmarkBlock
+from notionary.blocks.mixins.captions import CaptionMixin
+from notionary.blocks.syntax_prompt_builder import BlockElementMarkdownInformation
 from notionary.blocks.models import Block, BlockCreateResult, BlockType
-from notionary.blocks.rich_text.text_inline_formatter import TextInlineFormatter
 
 
-# BookmarkElement implementation using BlockType enum and TextInlineFormatter
-class BookmarkElement(BaseBlockElement):
+class BookmarkElement(BaseBlockElement, CaptionMixin):
     """
     Handles conversion between Markdown bookmarks and Notion bookmark blocks.
 
     Markdown bookmark syntax:
     - [bookmark](https://example.com) - URL only
-    - [bookmark](https://example.com "Title") - URL + title
-    - [bookmark](https://example.com "Title" "Description") - URL + title + description
+    - [bookmark](https://example.com)(caption:This is a caption) - URL with caption
+    - (caption:This is a caption)[bookmark](https://example.com) - caption before URL
     """
 
-    PATTERN = re.compile(
-        r"^\[bookmark\]\("  # prefix
-        r"(https?://[^\s\"]+)"  # URL
-        r"(?:\s+\"([^\"]+)\")?"  # optional Title
-        r"(?:\s+\"([^\"]+)\")?"  # optional Description
-        r"\)$"
-    )
+    # Flexible pattern that can handle caption in any position
+    BOOKMARK_PATTERN = re.compile(r"\[bookmark\]\((https?://[^\s\"]+)\)")
 
     @classmethod
     def match_notion(cls, block: Block) -> bool:
         return block.type == BlockType.BOOKMARK and block.bookmark
 
     @classmethod
-    def markdown_to_notion(cls, text: str) -> BlockCreateResult:
+    async def markdown_to_notion(cls, text: str) -> BlockCreateResult:
         """
         Convert a markdown bookmark into a Notion BookmarkBlock.
         """
-        if not (m := cls.PATTERN.match(text.strip())):
-            return None
+        # First remove captions to get clean text for URL extraction
+        clean_text = cls.remove_caption(text.strip())
 
-        url, title, description = m.group(1), m.group(2), m.group(3)
+        # Use our own regex to find the bookmark URL
+        bookmark_match = cls.BOOKMARK_PATTERN.search(clean_text)
+        if not bookmark_match:
+            return None
 
-        # Build caption texts
-        parts: list[str] = []
-        if title:
-            parts.append(title)
-        if description:
-            parts.append(description)
+        url = bookmark_match.group(1)
 
-        caption = []
-        if parts:
-            joined = " – ".join(parts)
-            caption = TextInlineFormatter.parse_inline_formatting(joined)
+        caption_text = cls.extract_caption(text.strip())
+        caption_rich_text = cls.build_caption_rich_text(caption_text or "")
 
-        bookmark_data = BookmarkBlock(url=url, caption=caption)
+        bookmark_data = BookmarkBlock(url=url, caption=caption_rich_text)
         return CreateBookmarkBlock(bookmark=bookmark_data)
 
     @classmethod
-    def notion_to_markdown(cls, block: Block) -> Optional[str]:
+    async def notion_to_markdown(cls, block: Block) -> Optional[str]:
         if block.type != BlockType.BOOKMARK or block.bookmark is None:
             return None
 
@@ -67,14 +58,26 @@ class BookmarkElement(BaseBlockElement):
         if not url:
             return None
 
-        captions = bm.caption or []
-        if not captions:
-            return f"[bookmark]({url})"
+        result = f"[bookmark]({url})"
 
-        text = TextInlineFormatter.extract_text_with_formatting(captions)
+        # Add caption if present
+        caption_markdown = await cls.format_caption_for_markdown(bm.caption or [])
+        if caption_markdown:
+            result += caption_markdown
 
-        if " - " in text:
-            title, desc = map(str.strip, text.split(" - ", 1))
-            return f'[bookmark]({url} "{title}" "{desc}")'
+        return result
 
-        return f'[bookmark]({url} "{text}")'
+    @classmethod
+    def get_system_prompt_information(cls) -> Optional[BlockElementMarkdownInformation]:
+        """Get system prompt information for bookmark blocks."""
+        return BlockElementMarkdownInformation(
+            block_type=cls.__name__,
+            description="Bookmark blocks create previews of web pages with optional captions",
+            syntax_examples=[
+                "[bookmark](https://example.com)",
+                "[bookmark](https://example.com)(caption:This is a caption)",
+                "(caption:Check out this repository)[bookmark](https://github.com/user/repo)",
+                "[bookmark](https://github.com/user/repo)(caption:Check out this awesome repository)",
+            ],
+            usage_guidelines="Use for linking to external websites with rich previews. URL is required. Caption supports rich text formatting and is optional.",
+        )

notionary/blocks/bookmark/bookmark_markdown_node.py

@@ -5,41 +5,40 @@ from typing import Optional
 from pydantic import BaseModel
 
 from notionary.markdown.markdown_node import MarkdownNode
+from notionary.blocks.mixins.captions import CaptionMarkdownNodeMixin
 
 
 class BookmarkMarkdownBlockParams(BaseModel):
     url: str
     title: Optional[str] = None
-    description: Optional[str] = None
+    caption: Optional[str] = None
 
 
-class BookmarkMarkdownNode(MarkdownNode):
+class BookmarkMarkdownNode(MarkdownNode, CaptionMarkdownNodeMixin):
     """
     Programmatic interface for creating Notion-style bookmark Markdown blocks.
     """
 
     def __init__(
-        self, url: str, title: Optional[str] = None, description: Optional[str] = None
+        self, url: str, title: Optional[str] = None, caption: Optional[str] = None
     ):
         self.url = url
         self.title = title
-        self.description = description
+        self.caption = caption
 
     @classmethod
     def from_params(cls, params: BookmarkMarkdownBlockParams) -> BookmarkMarkdownNode:
-        return cls(url=params.url, title=params.title, description=params.description)
+        return cls(url=params.url, title=params.title, caption=params.caption)
 
     def to_markdown(self) -> str:
+        """Return the Markdown representation.
+
+        Examples:
+        - [bookmark](https://example.com)
+        - [bookmark](https://example.com)(caption:Some caption)
         """
-        Returns the Markdown representation, e.g.:
-        [bookmark](https://example.com "Title" "Description")
-        """
-        parts = [f"[bookmark]({self.url}"]
-        if self.title is not None:
-            parts.append(f'"{self.title}"')
-        if self.description is not None:
-            # Wenn title fehlt, aber description da ist, trotzdem Platzhalter für title:
-            if self.title is None:
-                parts.append('""')
-            parts.append(f'"{self.description}"')
-        return " ".join(parts) + ")"
+        # Use simple bookmark syntax like BookmarkElement
+        base_markdown = f"[bookmark]({self.url})"
+
+        # Append caption using mixin helper
+        return self.append_caption_to_markdown(base_markdown, self.caption)

notionary/blocks/breadcrumbs/breadcrumb_element.py

@@ -28,12 +28,12 @@ class BreadcrumbElement(BaseBlockElement):
         return block.type == BlockType.BREADCRUMB and block.breadcrumb
 
     @classmethod
-    def markdown_to_notion(cls, text: str) -> BlockCreateResult:
+    async def markdown_to_notion(cls, text: str) -> BlockCreateResult:
         if not cls.PATTERN.match(text.strip()):
             return None
         return CreateBreadcrumbBlock(breadcrumb=BreadcrumbBlock())
 
     @classmethod
-    def notion_to_markdown(cls, block: Block) -> Optional[str]:
+    async def notion_to_markdown(cls, block: Block) -> Optional[str]:
         if block.type == BlockType.BREADCRUMB and block.breadcrumb:
             return cls.BREADCRUMB_MARKER

notionary/blocks/bulleted_list/bulleted_list_element.py

@@ -8,6 +8,7 @@ from notionary.blocks.bulleted_list.bulleted_list_models import (
     BulletedListItemBlock,
     CreateBulletedListItemBlock,
 )
+from notionary.blocks.syntax_prompt_builder import BlockElementMarkdownInformation
 from notionary.blocks.models import Block, BlockCreateResult, BlockType
 from notionary.blocks.rich_text.text_inline_formatter import TextInlineFormatter
 
@@ -24,7 +25,7 @@ class BulletedListElement(BaseBlockElement):
         return block.type == BlockType.BULLETED_LIST_ITEM and block.bulleted_list_item
 
     @classmethod
-    def markdown_to_notion(cls, text: str) -> BlockCreateResult:
+    async def markdown_to_notion(cls, text: str) -> BlockCreateResult:
         """
         Convert a markdown bulleted list item into a Notion BulletedListItemBlock.
         """
@@ -35,7 +36,7 @@ class BulletedListElement(BaseBlockElement):
         content = match.group(2)
 
         # Parse inline markdown formatting into RichTextObject list
-        rich_text = TextInlineFormatter.parse_inline_formatting(content)
+        rich_text = await TextInlineFormatter.parse_inline_formatting(content)
 
         # Return a properly typed Notion block
         bulleted_list_content = BulletedListItemBlock(
@@ -44,7 +45,7 @@ class BulletedListElement(BaseBlockElement):
         return CreateBulletedListItemBlock(bulleted_list_item=bulleted_list_content)
 
     @classmethod
-    def notion_to_markdown(cls, block: Block) -> Optional[str]:
+    async def notion_to_markdown(cls, block: Block) -> Optional[str]:
         """Convert Notion bulleted_list_item block to Markdown."""
         if block.type != BlockType.BULLETED_LIST_ITEM or not block.bulleted_list_item:
             return None
@@ -53,5 +54,21 @@ class BulletedListElement(BaseBlockElement):
         if not rich_list:
             return "-"
 
-        text = TextInlineFormatter.extract_text_with_formatting(rich_list)
+        text = await TextInlineFormatter.extract_text_with_formatting(rich_list)
         return f"- {text}"
+
+    @classmethod
+    def get_system_prompt_information(cls) -> Optional[BlockElementMarkdownInformation]:
+        """Get system prompt information for bulleted list blocks."""
+        return BlockElementMarkdownInformation(
+            block_type=cls.__name__,
+            description="Bulleted list items create unordered lists with bullet points",
+            syntax_examples=[
+                "- First item",
+                "* Second item",
+                "+ Third item",
+                "- Item with **bold text**",
+                "- Item with *italic text*",
+            ],
+            usage_guidelines="Use -, *, or + to create bullet points. Supports inline formatting like bold, italic, and links. Do not use for todo items (use [ ] or [x] for those).",
+        )

notionary/blocks/callout/callout_element.py

@@ -10,6 +10,7 @@ from notionary.blocks.callout.callout_models import (
     EmojiIcon,
     IconObject,
 )
+from notionary.blocks.syntax_prompt_builder import BlockElementMarkdownInformation
 from notionary.blocks.models import Block, BlockCreateResult, BlockType
 from notionary.blocks.rich_text.text_inline_formatter import TextInlineFormatter
 
@@ -42,7 +43,7 @@ class CalloutElement(BaseBlockElement):
         return block.type == BlockType.CALLOUT and block.callout
 
     @classmethod
-    def markdown_to_notion(cls, text: str) -> BlockCreateResult:
+    async def markdown_to_notion(cls, text: str) -> BlockCreateResult:
         """Convert a markdown callout into a Notion CalloutBlock."""
         match = cls.PATTERN.match(text.strip())
         if not match:
@@ -55,7 +56,7 @@ class CalloutElement(BaseBlockElement):
         if not emoji:
             emoji = cls.DEFAULT_EMOJI
 
-        rich_text = TextInlineFormatter.parse_inline_formatting(content.strip())
+        rich_text = await TextInlineFormatter.parse_inline_formatting(content.strip())
 
         callout_content = CalloutBlock(
             rich_text=rich_text,
@@ -65,13 +66,13 @@ class CalloutElement(BaseBlockElement):
         return CreateCalloutBlock(callout=callout_content)
 
     @classmethod
-    def notion_to_markdown(cls, block: Block) -> Optional[str]:
+    async def notion_to_markdown(cls, block: Block) -> Optional[str]:
         if block.type != BlockType.CALLOUT or not block.callout:
             return None
 
         data = block.callout
 
-        content = TextInlineFormatter.extract_text_with_formatting(data.rich_text)
+        content = await TextInlineFormatter.extract_text_with_formatting(data.rich_text)
         if not content:
             return None
 
@@ -81,3 +82,18 @@ class CalloutElement(BaseBlockElement):
         if emoji_char and emoji_char != cls.DEFAULT_EMOJI:
             return f'[callout]({content} "{emoji_char}")'
         return f"[callout]({content})"
+
+    @classmethod
+    def get_system_prompt_information(cls) -> Optional[BlockElementMarkdownInformation]:
+        """Get system prompt information for callout blocks."""
+        return BlockElementMarkdownInformation(
+            block_type=cls.__name__,
+            description="Callout blocks create highlighted text boxes with optional custom emojis for emphasis",
+            syntax_examples=[
+                "[callout](This is important information)",
+                '[callout](Warning message "⚠️")',
+                '[callout](Success message "✅")',
+                "[callout](Note with default emoji)",
+            ],
+            usage_guidelines="Use for highlighting important information, warnings, tips, or notes. Default emoji is 💡. Custom emoji should be provided in quotes after the text content.",
+        )

notionary/blocks/child_database/__init__.py

@@ -1,7 +1,14 @@
-from notionary.blocks.child_database.child_database_models import (
-    CreateInlineDatabaseRequest,
-)
+"""
+Child Database Block Module
+
+This module provides functionality for handling Notion child database blocks.
+"""
+
+from .child_database_element import ChildDatabaseElement
+from .child_database_models import ChildDatabaseBlock, CreateChildDatabaseBlock
 
 __all__ = [
-    "CreateInlineDatabaseRequest",
+    "ChildDatabaseElement",
+    "ChildDatabaseBlock",
+    "CreateChildDatabaseBlock",
 ]

notionary/blocks/child_database/child_database_element.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import re
+from typing import Optional
+
+from notionary.blocks.base_block_element import BaseBlockElement
+from notionary.blocks.syntax_prompt_builder import BlockElementMarkdownInformation
+from notionary.blocks.models import Block, BlockType
+from notionary.util import LoggingMixin
+
+
+class ChildDatabaseElement(BaseBlockElement, LoggingMixin):
+    """
+    Handles conversion between Markdown database references and Notion child database blocks.
+
+    Creates new databases when converting from markdown.
+    """
+
+    PATTERN_BRACKET = re.compile(r"^\[database:\s*(.+)\]$", re.IGNORECASE)
+    PATTERN_EMOJI = re.compile(r"^📊\s*(.+)$")
+
+    @classmethod
+    def match_notion(cls, block: Block) -> bool:
+        return block.type == BlockType.CHILD_DATABASE and block.child_database
+
+    @classmethod
+    async def markdown_to_notion(cls, text: str) -> Optional[str]:
+        """
+        Convert markdown database syntax to actual Notion database.
+        Returns the database_id if successful, None otherwise.
+        """
+        return None
+
+    @classmethod
+    async def notion_to_markdown(cls, block: Block) -> Optional[str]:
+        if block.type != BlockType.CHILD_DATABASE or not block.child_database:
+            return None
+
+        title = block.child_database.title
+        if not title or not title.strip():
+            return None
+
+        # Use bracket syntax for output
+        return f"[database: {title.strip()}]"
+
+    @classmethod
+    def get_system_prompt_information(cls) -> Optional[BlockElementMarkdownInformation]:
+        """Get system prompt information for child database blocks."""
+        return BlockElementMarkdownInformation(
+            block_type=cls.__name__,
+            description="Creates new embedded databases within a Notion page",
+            syntax_examples=[
+                "[database: Project Tasks]",
+                "[database: Customer Information]",
+                "📊 Sales Pipeline",
+                "📊 Team Directory",
+            ],
+            usage_guidelines="Use to create new databases that will be embedded in the page. The database will be created with a basic 'Name' property and can be customized later.",
+        )

notionary/blocks/child_database/child_database_models.py

@@ -1,19 +1,12 @@
-from typing import Any
+from typing import Literal
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
 
-from notionary.blocks.rich_text.rich_text_models import RichTextObject
 
+class ChildDatabaseBlock(BaseModel):
+    title: str
 
-class CreateInlineDatabaseRequest(BaseModel):
-    """
-    Minimaler Create-Payload für eine inline Database.
-    Parent wird von der Page-Schicht gesetzt: {"type": "page_id", "page_id": "..."}.
-    """
 
-    parent: dict[str, str]  # wird von außen injiziert
-    title: list[
-        RichTextObject
-    ]  # z. B. [RichTextObject.from_plain_text("Monatsübersicht")]
-    properties: dict[str, dict[str, Any]]  # mindestens eine Title-Property erforderlich
-    is_inline: bool = True  # inline = erscheint als child_database-Block auf der Page
+class CreateChildDatabaseBlock(BaseModel):
+    type: Literal["child_database"] = "child_database"
+    child_database: ChildDatabaseBlock