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

notionary/blocks/base_block_element.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from abc import ABC
+from typing import Optional
+
+from notionary.blocks.models import Block, BlockCreateResult
+
+
+class BaseBlockElement(ABC):
+    """Base class for elements that can be converted between Markdown and Notion."""
+
+    @classmethod
+    def markdown_to_notion(cls, text: str) -> BlockCreateResult:
+        """
+        Convert markdown to Notion block content.
+
+        Returns:
+            - BlockContent: Single block content (e.g., ToDoBlock, ParagraphBlock)
+            - list[BlockContent]: Multiple block contents
+            - None: Cannot convert this markdown
+        """
+
+    @classmethod
+    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

notionary/blocks/bookmark/__init__.py

@@ -1,7 +1,14 @@
-from .bookmark_element import BookmarkElement
-from .bookmark_markdown_node import BookmarkMarkdownNode
+from notionary.blocks.bookmark.bookmark_element import BookmarkElement
+from notionary.blocks.bookmark.bookmark_markdown_node import (
+    BookmarkMarkdownBlockParams,
+    BookmarkMarkdownNode,
+)
+from notionary.blocks.bookmark.bookmark_models import BookmarkBlock, CreateBookmarkBlock
 
 __all__ = [
     "BookmarkElement",
+    "BookmarkBlock",
+    "CreateBookmarkBlock",
     "BookmarkMarkdownNode",
+    "BookmarkMarkdownBlockParams",
 ]

notionary/blocks/bookmark/bookmark_element.py

@@ -1,173 +1,80 @@
+from __future__ import annotations
+
 import re
-from typing import Dict, Any, Optional, List, Tuple
+from typing import Optional
 
-from notionary.blocks import NotionBlockElement
-from notionary.blocks import (
-    ElementPromptContent,
-    ElementPromptBuilder,
-    NotionBlockResult,
-)
-from notionary.blocks.shared.models import RichTextObject
+from notionary.blocks.base_block_element import BaseBlockElement
+from notionary.blocks.bookmark.bookmark_models import BookmarkBlock, CreateBookmarkBlock
+from notionary.blocks.models import Block, BlockCreateResult, BlockType
+from notionary.blocks.rich_text.text_inline_formatter import TextInlineFormatter
 
 
-class BookmarkElement(NotionBlockElement):
+# BookmarkElement implementation using BlockType enum and TextInlineFormatter
+class BookmarkElement(BaseBlockElement):
     """
     Handles conversion between Markdown bookmarks and Notion bookmark blocks.
 
     Markdown bookmark syntax:
-    - [bookmark](https://example.com) - Simple bookmark with URL only
-    - [bookmark](https://example.com "Title") - Bookmark with URL and title
-    - [bookmark](https://example.com "Title" "Description") - Bookmark with URL, title, and description
-
-    Where:
-    - URL is the required bookmark URL
-    - Title is an optional title (enclosed in quotes)
-    - Description is an optional description (enclosed in quotes)
+    - [bookmark](https://example.com) - URL only
+    - [bookmark](https://example.com "Title") - URL + title
+    - [bookmark](https://example.com "Title" "Description") - URL + title + description
     """
 
-    # Regex pattern for bookmark syntax with optional title and description
     PATTERN = re.compile(
-        r"^\[bookmark\]\("  # [bookmark]( prefix
-        + r'(https?://[^\s"]+)'  # URL (required)
-        + r'(?:\s+"([^"]+)")?'  # Optional title in quotes
-        + r'(?:\s+"([^"]+)")?'  # Optional description in quotes
-        + r"\)$"  # closing parenthesis
+        r"^\[bookmark\]\("  # prefix
+        r"(https?://[^\s\"]+)"  # URL
+        r"(?:\s+\"([^\"]+)\")?"  # optional Title
+        r"(?:\s+\"([^\"]+)\")?"  # optional Description
+        r"\)$"
     )
 
     @classmethod
-    def match_markdown(cls, text: str) -> bool:
-        """Check if text is a markdown bookmark."""
-        return text.strip().startswith("[bookmark]") and bool(
-            cls.PATTERN.match(text.strip())
-        )
-
-    @classmethod
-    def match_notion(cls, block: Dict[str, Any]) -> bool:
-        """Check if block is a Notion bookmark."""
-        return block.get("type") in ["bookmark", "external-bookmark"]
+    def match_notion(cls, block: Block) -> bool:
+        return block.type == BlockType.BOOKMARK and block.bookmark
 
     @classmethod
-    def markdown_to_notion(cls, text: str) -> NotionBlockResult:
-        """Convert markdown bookmark to Notion bookmark block."""
-        bookmark_match = BookmarkElement.PATTERN.match(text.strip())
-        if not bookmark_match:
+    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
 
-        url = bookmark_match.group(1)
-        title = bookmark_match.group(2)
-        description = bookmark_match.group(3)
-
-        bookmark_data = {"url": url}
+        url, title, description = m.group(1), m.group(2), m.group(3)
 
-        # Build caption string
-        caption_parts = []
+        # Build caption texts
+        parts: list[str] = []
         if title:
-            caption_parts.append(title)
+            parts.append(title)
         if description:
-            caption_parts.append(description)
+            parts.append(description)
 
-        if caption_parts:
-            caption_text = " - ".join(caption_parts)
-            caption_rich_text = RichTextObject.from_plain_text(caption_text)
-            bookmark_data["caption"] = [caption_rich_text.model_dump()]
-        else:
-            bookmark_data["caption"] = []
+        caption = []
+        if parts:
+            joined = " – ".join(parts)
+            caption = TextInlineFormatter.parse_inline_formatting(joined)
 
-        return [{"type": "bookmark", "bookmark": bookmark_data}]
+        bookmark_data = BookmarkBlock(url=url, caption=caption)
+        return CreateBookmarkBlock(bookmark=bookmark_data)
 
     @classmethod
-    def notion_to_markdown(cls, block: Dict[str, Any]) -> Optional[str]:
-        """Convert Notion bookmark block to markdown bookmark."""
-        block_type = block.get("type", "")
-
-        if block_type == "bookmark":
-            bookmark_data = block.get("bookmark", {})
-        elif block_type == "external-bookmark":
-            url = block.get("url", "")
-            if not url:
-                return None
-
-            return f"[bookmark]({url})"
-        else:
+    def notion_to_markdown(cls, block: Block) -> Optional[str]:
+        if block.type != BlockType.BOOKMARK or block.bookmark is None:
             return None
 
-        url = bookmark_data.get("url", "")
-
+        bm = block.bookmark
+        url = bm.url
         if not url:
             return None
 
-        caption = bookmark_data.get("caption", [])
-
-        if not caption:
-            # Simple bookmark with URL only
+        captions = bm.caption or []
+        if not captions:
             return f"[bookmark]({url})"
 
-        # Extract title and description from caption
-        title, description = BookmarkElement._parse_caption(caption)
-
-        if title and description:
-            return f'[bookmark]({url} "{title}" "{description}")'
-
-        if title:
-            return f'[bookmark]({url} "{title}")'
-
-        return f"[bookmark]({url})"
-
-    @classmethod
-    def is_multiline(cls) -> bool:
-        """Bookmarks are single-line elements."""
-        return False
-
-    @classmethod
-    def _extract_text_content(cls, rich_text: List[Dict[str, Any]]) -> str:
-        """Extract plain text content from Notion rich_text elements."""
-        result = ""
-        for text_obj in rich_text:
-            if text_obj.get("type") == "text":
-                result += text_obj.get("text", {}).get("content", "")
-            elif "plain_text" in text_obj:
-                result += text_obj.get("plain_text", "")
-        return result
-
-    @classmethod
-    def _parse_caption(cls, caption: List[Dict[str, Any]]) -> Tuple[str, str]:
-        """
-        Parse Notion caption into title and description components.
-        Returns a tuple of (title, description).
-        """
-        if not caption:
-            return "", ""
-
-        full_text = BookmarkElement._extract_text_content(caption)
-
-        if " - " in full_text:
-            parts = full_text.split(" - ", 1)
-            return parts[0].strip(), parts[1].strip()
+        text = TextInlineFormatter.extract_text_with_formatting(captions)
 
-        return full_text.strip(), ""
+        if " - " in text:
+            title, desc = map(str.strip, text.split(" - ", 1))
+            return f'[bookmark]({url} "{title}" "{desc}")'
 
-    @classmethod
-    def get_llm_prompt_content(cls) -> ElementPromptContent:
-        """
-        Returns structured LLM prompt metadata for the bookmark element.
-        """
-        return (
-            ElementPromptBuilder()
-            .with_description("Creates a bookmark that links to an external website.")
-            .with_usage_guidelines(
-                "Use bookmarks when you want to reference external content while keeping the page clean and organized. "
-                "Bookmarks display a preview card for the linked content."
-            )
-            .with_syntax(
-                '[bookmark](https://example.com "Optional Title" "Optional Description")'
-            )
-            .with_examples(
-                [
-                    "[bookmark](https://example.com)",
-                    '[bookmark](https://example.com "Example Title")',
-                    '[bookmark](https://example.com "Example Title" "Example description of the site")',
-                    '[bookmark](https://github.com "GitHub" "Where the world builds software")',
-                ]
-            )
-            .build()
-        )
+        return f'[bookmark]({url} "{text}")'

notionary/blocks/bookmark/bookmark_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 BookmarkMarkdownBlockParams(BaseModel):

notionary/blocks/bookmark/bookmark_models.py

@@ -0,0 +1,15 @@
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+from notionary.blocks.rich_text.rich_text_models import RichTextObject
+
+
+class BookmarkBlock(BaseModel):
+    caption: list[RichTextObject] = Field(default_factory=list)
+    url: str
+
+
+class CreateBookmarkBlock(BaseModel):
+    type: Literal["bookmark"] = "bookmark"
+    bookmark: BookmarkBlock

notionary/blocks/breadcrumbs/__init__.py

@@ -0,0 +1,17 @@
+from notionary.blocks.breadcrumbs.breadcrumb_element import BreadcrumbElement
+from notionary.blocks.breadcrumbs.breadcrumb_markdown_node import (
+    BreadcrumbMarkdownBlockParams,
+    BreadcrumbMarkdownNode,
+)
+from notionary.blocks.breadcrumbs.breadcrumb_models import (
+    BreadcrumbBlock,
+    CreateBreadcrumbBlock,
+)
+
+__all__ = [
+    "BreadcrumbElement",
+    "BreadcrumbBlock",
+    "CreateBreadcrumbBlock",
+    "BreadcrumbMarkdownNode",
+    "BreadcrumbMarkdownBlockParams",
+]

notionary/blocks/breadcrumbs/breadcrumb_element.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import re
+from typing import Optional
+
+from notionary.blocks.base_block_element import BaseBlockElement
+from notionary.blocks.breadcrumbs.breadcrumb_models import (
+    BreadcrumbBlock,
+    CreateBreadcrumbBlock,
+)
+from notionary.blocks.models import Block, BlockCreateResult, BlockType
+
+
+class BreadcrumbElement(BaseBlockElement):
+    """
+    Handles conversion between Markdown breadcrumb marker and Notion breadcrumb blocks.
+
+    Markdown syntax:
+      [breadcrumb]
+    """
+
+    BREADCRUMB_MARKER = "[breadcrumb]"
+    PATTERN = re.compile(r"^\[breadcrumb\]\s*$", re.IGNORECASE)
+
+    @classmethod
+    def match_notion(cls, block: Block) -> bool:
+        # Kein extra Payload – nur Typ prüfen
+        return block.type == BlockType.BREADCRUMB and block.breadcrumb
+
+    @classmethod
+    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]:
+        if block.type == BlockType.BREADCRUMB and block.breadcrumb:
+            return cls.BREADCRUMB_MARKER

notionary/blocks/breadcrumbs/breadcrumb_markdown_node.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from notionary.markdown.markdown_node import MarkdownNode
+
+
+class BreadcrumbMarkdownBlockParams(BaseModel):
+    """Parameters for breadcrumb markdown block. No parameters needed."""
+
+    pass
+
+
+class BreadcrumbMarkdownNode(MarkdownNode):
+    """
+    Programmatic interface for creating Markdown breadcrumb blocks.
+    Example:
+    [breadcrumb]
+    """
+
+    def __init__(self):
+        # No parameters needed for breadcrumb
+        pass
+
+    @classmethod
+    def from_params(
+        cls, params: BreadcrumbMarkdownBlockParams
+    ) -> BreadcrumbMarkdownNode:
+        return cls()
+
+    def to_markdown(self) -> str:
+        return "[breadcrumb]"

notionary/blocks/breadcrumbs/breadcrumb_models.py

@@ -0,0 +1,12 @@
+from typing import Literal
+
+from pydantic import BaseModel
+
+
+class BreadcrumbBlock(BaseModel):
+    pass
+
+
+class CreateBreadcrumbBlock(BaseModel):
+    type: Literal["breadcrumb"] = "breadcrumb"
+    breadcrumb: BreadcrumbBlock

notionary/blocks/bulleted_list/__init__.py

@@ -1,7 +1,17 @@
-from .bulleted_list_element import BulletedListElement
-from .bulleted_list_markdown_node import BulletedListMarkdownNode
+from notionary.blocks.bulleted_list.bulleted_list_element import BulletedListElement
+from notionary.blocks.bulleted_list.bulleted_list_markdown_node import (
+    BulletedListMarkdownBlockParams,
+    BulletedListMarkdownNode,
+)
+from notionary.blocks.bulleted_list.bulleted_list_models import (
+    BulletedListItemBlock,
+    CreateBulletedListItemBlock,
+)
 
 __all__ = [
     "BulletedListElement",
+    "BulletedListItemBlock",
+    "CreateBulletedListItemBlock",
     "BulletedListMarkdownNode",
+    "BulletedListMarkdownBlockParams",
 ]

notionary/blocks/bulleted_list/bulleted_list_element.py

@@ -1,72 +1,57 @@
+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.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 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
-    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 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
+        # Parse inline markdown formatting into RichTextObject list
         rich_text = 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":
+    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)
+        rich_list = block.bulleted_list_item.rich_text
+        if not rich_list:
+            return "-"
 
-        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))
-
-    @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"
-
-    @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()
-        )
+        text = TextInlineFormatter.extract_text_with_formatting(rich_list)
+        return f"- {text}"

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",
 ]