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

notionary/blocks/bulleted_list/bulleted_list_element.py

@@ -1,72 +1,74 @@
+from __future__ import annotations
+
 import re
-from typing import Dict, Any, Optional
-from notionary.blocks import NotionBlockElement
-from notionary.blocks import (
-    ElementPromptContent,
-    ElementPromptBuilder,
-    NotionBlockResult,
-)
+from typing import Optional
 
-from notionary.blocks.shared.text_inline_formatter import TextInlineFormatter
+from notionary.blocks.base_block_element import BaseBlockElement
+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
 
 
-class BulletedListElement(NotionBlockElement):
+class BulletedListElement(BaseBlockElement):
     """Class for converting between Markdown bullet lists and Notion bulleted list items."""
 
+    # Regex for markdown bullets (excluding todo items [ ] or [x])
+    PATTERN = re.compile(r"^(\s*)[*\-+]\s+(?!\[[ x]\])(.+)$")
+
     @classmethod
-    def markdown_to_notion(cls, text: str) -> NotionBlockResult:
-        """Convert markdown bulleted list item to Notion block."""
-        pattern = re.compile(
-            r"^(\s*)[*\-+]\s+(?!\[[ x]\])(.+)$"
-        )  # Avoid matching todo items
-        list_match = pattern.match(text)
-        if not list_match:
+    def match_notion(cls, block: Block) -> bool:
+        """Check if this element can handle the given Notion block."""
+        return block.type == BlockType.BULLETED_LIST_ITEM and block.bulleted_list_item
+
+    @classmethod
+    async def markdown_to_notion(cls, text: str) -> BlockCreateResult:
+        """
+        Convert a markdown bulleted list item into a Notion BulletedListItemBlock.
+        """
+        if not (match := cls.PATTERN.match(text.strip())):
             return None
 
-        content = list_match.group(2)
+        # Extract the content part (second capture group)
+        content = match.group(2)
 
-        # Use parse_inline_formatting to handle rich text
-        rich_text = TextInlineFormatter.parse_inline_formatting(content)
+        # Parse inline markdown formatting into RichTextObject list
+        rich_text = await TextInlineFormatter.parse_inline_formatting(content)
 
-        return {
-            "type": "bulleted_list_item",
-            "bulleted_list_item": {"rich_text": rich_text, "color": "default"},
-        }
+        # Return a properly typed Notion block
+        bulleted_list_content = BulletedListItemBlock(
+            rich_text=rich_text, color="default"
+        )
+        return CreateBulletedListItemBlock(bulleted_list_item=bulleted_list_content)
 
     @classmethod
-    def notion_to_markdown(cls, block: Dict[str, Any]) -> Optional[str]:
-        """Convert Notion bulleted list item block to markdown."""
-        if block.get("type") != "bulleted_list_item":
+    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
 
-        rich_text = block.get("bulleted_list_item", {}).get("rich_text", [])
-        content = TextInlineFormatter.extract_text_with_formatting(rich_text)
-
-        return f"- {content}"
-
-    @classmethod
-    def match_markdown(cls, text: str) -> bool:
-        """Check if this element can handle the given markdown text."""
-        pattern = re.compile(r"^(\s*)[*\-+]\s+(?!\[[ x]\])(.+)$")
-        return bool(pattern.match(text))
+        rich_list = block.bulleted_list_item.rich_text
+        if not rich_list:
+            return "-"
 
-    @classmethod
-    def match_notion(cls, block: Dict[str, Any]) -> bool:
-        """Check if this element can handle the given Notion block."""
-        return block.get("type") == "bulleted_list_item"
+        text = await TextInlineFormatter.extract_text_with_formatting(rich_list)
+        return f"- {text}"
 
     @classmethod
-    def get_llm_prompt_content(cls) -> ElementPromptContent:
-        """
-        Returns structured LLM prompt metadata for the bulleted list element.
-        """
-        return (
-            ElementPromptBuilder()
-            .with_description("Creates bulleted list items for unordered lists.")
-            .with_usage_guidelines(
-                "Use for lists where order doesn't matter, such as features, options, or items without hierarchy."
-            )
-            .with_syntax("- Item text")
-            .with_standard_markdown()
-            .build()
+    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/bulleted_list/bulleted_list_markdown_node.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
 from pydantic import BaseModel
-from notionary.blocks.markdown_node import MarkdownNode
+
+from notionary.markdown.markdown_node import MarkdownNode
 
 
 class BulletedListMarkdownBlockParams(BaseModel):

notionary/blocks/bulleted_list/bulleted_list_models.py

@@ -0,0 +1,18 @@
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+from notionary.blocks.models import Block
+from notionary.blocks.rich_text import RichTextObject
+from notionary.blocks.types import BlockColor
+
+
+class BulletedListItemBlock(BaseModel):
+    rich_text: list[RichTextObject]
+    color: BlockColor = BlockColor.DEFAULT
+    children: list[Block] = Field(default_factory=list)
+
+
+class CreateBulletedListItemBlock(BaseModel):
+    type: Literal["bulleted_list_item"] = "bulleted_list_item"
+    bulleted_list_item: BulletedListItemBlock

notionary/blocks/callout/__init__.py

@@ -1,7 +1,14 @@
-from .callout_element import CalloutElement
-from .callout_markdown_node import CalloutMarkdownNode
+from notionary.blocks.callout.callout_element import CalloutElement
+from notionary.blocks.callout.callout_markdown_node import (
+    CalloutMarkdownBlockParams,
+    CalloutMarkdownNode,
+)
+from notionary.blocks.callout.callout_models import CalloutBlock, CreateCalloutBlock
 
 __all__ = [
     "CalloutElement",
+    "CalloutBlock",
+    "CreateCalloutBlock",
     "CalloutMarkdownNode",
+    "CalloutMarkdownBlockParams",
 ]

notionary/blocks/callout/callout_element.py

@@ -1,16 +1,21 @@
+from __future__ import annotations
+
 import re
-from typing import Dict, Any, Optional, List
-
-from notionary.blocks.shared.text_inline_formatter import TextInlineFormatter
-from notionary.blocks import (
-    NotionBlockElement,
-    ElementPromptContent,
-    ElementPromptBuilder,
-    NotionBlockResult,
+from typing import Optional
+
+from notionary.blocks.base_block_element import BaseBlockElement
+from notionary.blocks.callout.callout_models import (
+    CalloutBlock,
+    CreateCalloutBlock,
+    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
 
 
-class CalloutElement(NotionBlockElement):
+class CalloutElement(BaseBlockElement):
     """
     Handles conversion between Markdown callouts and Notion callout blocks.
 
@@ -23,110 +28,72 @@ class CalloutElement(NotionBlockElement):
     - emoji is an optional emoji character (enclosed in quotes)
     """
 
-    # Regex pattern for callout syntax with optional emoji
     PATTERN = re.compile(
-        r"^\[callout\]\("  # [callout]( prefix
-        + r'([^"]+?)'  # Text content (required)
-        + r'(?:\s+"([^"]+)")?'  # Optional emoji in quotes
-        + r"\)$"  # closing parenthesis
+        r"^\[callout\]\("  # prefix
+        r"([^\"]+?)"  # content
+        r"(?:\s+\"([^\"]+)\")?"  # optional emoji
+        r"\)$"
     )
 
-    # Default values
     DEFAULT_EMOJI = "💡"
     DEFAULT_COLOR = "gray_background"
 
     @classmethod
-    def match_markdown(cls, text: str) -> bool:
-        """Check if text is a markdown callout."""
-        return text.strip().startswith("[callout]") and bool(
-            CalloutElement.PATTERN.match(text.strip())
-        )
-
-    @classmethod
-    def match_notion(cls, block: Dict[str, Any]) -> bool:
-        """Check if block is a Notion callout."""
-        return block.get("type") == "callout"
+    def match_notion(cls, block: Block) -> bool:
+        return block.type == BlockType.CALLOUT and block.callout
 
     @classmethod
-    def markdown_to_notion(cls, text: str) -> NotionBlockResult:
-        """Convert markdown callout to Notion callout block."""
-        callout_match = CalloutElement.PATTERN.match(text.strip())
-        if not callout_match:
+    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:
             return None
 
-        content = callout_match.group(1)
-        emoji = callout_match.group(2)
-
+        content, emoji = match.group(1), match.group(2)
         if not content:
             return None
 
-        # Use default emoji if none provided
         if not emoji:
-            emoji = CalloutElement.DEFAULT_EMOJI
+            emoji = cls.DEFAULT_EMOJI
 
-        callout_data = {
-            "rich_text": TextInlineFormatter.parse_inline_formatting(content.strip()),
-            "icon": {"type": "emoji", "emoji": emoji},
-            "color": CalloutElement.DEFAULT_COLOR,
-        }
+        rich_text = await TextInlineFormatter.parse_inline_formatting(content.strip())
 
-        return {"type": "callout", "callout": callout_data}
+        callout_content = CalloutBlock(
+            rich_text=rich_text,
+            icon=EmojiIcon(emoji=emoji),
+            color=cls.DEFAULT_COLOR,
+        )
+        return CreateCalloutBlock(callout=callout_content)
 
     @classmethod
-    def notion_to_markdown(cls, block: Dict[str, Any]) -> Optional[str]:
-        """Convert Notion callout block to markdown callout."""
-        if block.get("type") != "callout":
+    async def notion_to_markdown(cls, block: Block) -> Optional[str]:
+        if block.type != BlockType.CALLOUT or not block.callout:
             return None
 
-        callout_data = block.get("callout", {})
-        rich_text = callout_data.get("rich_text", [])
-        icon = callout_data.get("icon", {})
+        data = block.callout
 
-        content = TextInlineFormatter.extract_text_with_formatting(rich_text)
+        content = await TextInlineFormatter.extract_text_with_formatting(data.rich_text)
         if not content:
             return None
 
-        emoji = CalloutElement._extract_emoji(icon)
-
-        if emoji and emoji != CalloutElement.DEFAULT_EMOJI:
-            return f'[callout]({content} "{emoji}")'
+        icon: Optional[IconObject] = block.callout.icon
+        emoji_char = icon.emoji if isinstance(icon, EmojiIcon) else cls.DEFAULT_EMOJI
 
+        if emoji_char and emoji_char != cls.DEFAULT_EMOJI:
+            return f'[callout]({content} "{emoji_char}")'
         return f"[callout]({content})"
 
     @classmethod
-    def is_multiline(cls) -> bool:
-        """Callouts are single-line elements."""
-        return False
-
-    @classmethod
-    def _extract_emoji(cls, icon: Dict[str, Any]) -> str:
-        """Extract emoji from Notion icon object."""
-        if icon and icon.get("type") == "emoji":
-            return icon.get("emoji", "")
-        return ""
-
-    @classmethod
-    def get_llm_prompt_content(cls) -> ElementPromptContent:
-        """
-        Returns structured LLM prompt metadata for the callout element.
-        """
-        return (
-            ElementPromptBuilder()
-            .with_description(
-                "Creates a callout block to highlight important information with an icon."
-            )
-            .with_usage_guidelines(
-                "Use callouts when you want to draw attention to important information, "
-                "tips, warnings, or notes that stand out from the main content."
-            )
-            .with_syntax('[callout](Text content "Optional emoji")')
-            .with_examples(
-                [
-                    "[callout](This is a default callout with the light bulb emoji)",
-                    '[callout](This is a callout with a bell emoji "🔔")',
-                    '[callout](Warning: This is an important note "⚠️")',
-                    '[callout](Tip: Add emoji that matches your content\'s purpose "💡")',
-                ]
-            )
-            .build()
+    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/callout/callout_markdown_node.py

@@ -1,8 +1,10 @@
 from __future__ import annotations
 
 from typing import Optional
+
 from pydantic import BaseModel
-from notionary.blocks.markdown_node import MarkdownNode
+
+from notionary.markdown.markdown_node import MarkdownNode
 
 
 class CalloutMarkdownBlockParams(BaseModel):

notionary/blocks/callout/callout_models.py

@@ -0,0 +1,33 @@
+from typing import Literal, Optional, Union
+
+from pydantic import BaseModel, Field
+
+from notionary.blocks.file.file_element_models import FileBlock
+from notionary.blocks.models import Block
+from notionary.blocks.rich_text.rich_text_models import RichTextObject
+from notionary.blocks.types import BlockColor
+
+
+class EmojiIcon(BaseModel):
+    type: Literal["emoji"] = "emoji"
+    emoji: str
+
+
+class FileIcon(BaseModel):
+    type: Literal["file"] = "file"
+    file: FileBlock
+
+
+IconObject = Union[EmojiIcon, FileIcon]
+
+
+class CalloutBlock(BaseModel):
+    rich_text: list[RichTextObject]
+    icon: Optional[IconObject] = None
+    color: BlockColor = BlockColor.DEFAULT
+    children: list[Block] = Field(default_factory=list)
+
+
+class CreateCalloutBlock(BaseModel):
+    type: Literal["callout"] = "callout"
+    callout: CalloutBlock

notionary/blocks/child_database/__init__.py

@@ -0,0 +1,14 @@
+"""
+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__ = [
+    "ChildDatabaseElement",
+    "ChildDatabaseBlock",
+    "CreateChildDatabaseBlock",
+]

notionary/blocks/child_database/child_database_element.py

@@ -0,0 +1,61 @@
+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.
+        """
+        cls.logger.warning("Creating database from markdown is not supported via the block api. Call the create_child_page method in NotionPage instead.s")
+        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

@@ -0,0 +1,12 @@
+from typing import Literal
+
+from pydantic import BaseModel
+
+
+class ChildDatabaseBlock(BaseModel):
+    title: str
+
+
+class CreateChildDatabaseBlock(BaseModel):
+    type: Literal["child_database"] = "child_database"
+    child_database: ChildDatabaseBlock

notionary/blocks/child_page/__init__.py

@@ -0,0 +1,9 @@
+from notionary.blocks.child_page.child_page_models import (
+    ChildPageBlock,
+    CreateChildPageBlock,
+)
+
+__all__ = [
+    "ChildPageBlock",
+    "CreateChildPageBlock",
+]

notionary/blocks/child_page/child_page_element.py

@@ -0,0 +1,94 @@
+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, BlockCreateResult, BlockType
+from notionary.page.page_context import get_page_context
+
+
+class ChildPageElement(BaseBlockElement):
+    """
+    Handles conversion between Markdown page references and Notion child page blocks.
+
+    Creates new pages when converting from markdown.
+    """
+
+    PATTERN_BRACKET = re.compile(r"^\[page:\s*(.+)\]$", re.IGNORECASE)
+    PATTERN_EMOJI = re.compile(r"^[📝📄]\s*(.+)$")
+
+    @classmethod
+    def match_notion(cls, block: Block) -> bool:
+        return block.type == BlockType.CHILD_PAGE and getattr(block, "child_page", None)
+
+    @classmethod
+    async def markdown_to_notion(cls, text: str) -> Optional[BlockCreateResult]:
+        """
+        Convert markdown page syntax to an actual Notion page.
+        Returns None since child_page blocks are created implicitly via Pages API (not Blocks API).
+        """
+        context = get_page_context()
+
+        text = text.strip()
+
+        match = cls.PATTERN_BRACKET.match(text)
+        if not match:
+            match = cls.PATTERN_EMOJI.match(text)
+
+        if not match:
+            return None
+
+        title = match.group(1).strip()
+        if not title:
+            return None
+
+        # Reject multiline titles
+        if "\n" in title or "\r" in title:
+            return None
+
+        try:
+            # Create the actual page using context
+            await context.page_client.create_page(
+                title=title,
+                parent_page_id=context.page_id,
+            )
+            # Return None as per BaseBlockElement convention:
+            # child_page blocks cannot be written through the Blocks API directly.
+            # Creating a page under the parent page will automatically insert a child_page block.
+            return None
+
+        except Exception as e:
+            print(f"Failed to create page '{title}': {e}")
+            return None
+
+    @classmethod
+    async def notion_to_markdown(cls, block: Block) -> Optional[str]:
+        if block.type != BlockType.CHILD_PAGE or not getattr(block, "child_page", None):
+            return None
+
+        title = block.child_page.title
+        if not title or not title.strip():
+            return None
+
+        # Use bracket syntax for output
+        return f"[page: {title.strip()}]"
+
+    @classmethod
+    def get_system_prompt_information(cls) -> Optional[BlockElementMarkdownInformation]:
+        """Get system prompt information for child page blocks."""
+        return BlockElementMarkdownInformation(
+            block_type=cls.__name__,
+            description="Creates new sub-pages within a Notion page.",
+            syntax_examples=[
+                "[page: Meeting Notes]",
+                "[page: Ideas]",
+                "📝 Project Overview",
+                "📄 Research Log",
+            ],
+            usage_guidelines=(
+                "Use to create new pages that will appear as child_page blocks in the current page. "
+                "Pages are created via the Pages API with the current page as parent."
+            ),
+        )

notionary/blocks/child_page/child_page_models.py

@@ -0,0 +1,12 @@
+from typing import Literal
+
+from pydantic import BaseModel
+
+
+class ChildPageBlock(BaseModel):
+    title: str
+
+
+class CreateChildPageBlock(BaseModel):
+    type: Literal["child_page"] = "child_page"
+    child_page: ChildPageBlock