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

notionary/blocks/audio/audio_models.py

@@ -1,59 +1,10 @@
-from typing import Optional
-from pydantic import BaseModel
-
-from notionary.blocks.shared.models import RichTextObject
-
-
-# TODO: Diesen Kram hier auch verwenden
-class ExternalAudioSource(BaseModel):
-    """External audio source."""
-
-    url: str
-
-
-class NotionAudioData(BaseModel):
-    """Audio block data."""
-
-    type: str = "external"
-    external: ExternalAudioSource
-    caption: list[dict] = []
+from typing import Literal
 
+from pydantic import BaseModel
 
-class NotionAudioBlock(BaseModel):
-    """Audio block result."""
-
-    type: str = "audio"
-    audio: NotionAudioData
-
-
-# Updated method with typed return
-@classmethod
-def markdown_to_notion(cls, text: str) -> Optional[NotionAudioBlock]:
-    """Convert markdown audio embed to Notion audio block."""
-    audio_match = cls.PATTERN.match(text.strip())
-    if not audio_match:
-        return None
-
-    url = audio_match.group(1)
-    caption_text = audio_match.group(2)
-
-    if not url:
-        return None
-
-    # Validate URL if possible
-    if not cls._is_likely_audio_url(url):
-        # Still proceed - user might know better
-        pass
+from notionary.blocks.file.file_element_models import FileBlock
 
-    # Build caption list
-    caption_list = []
-    if caption_text:
-        caption_rich_text = RichTextObject.from_plain_text(caption_text)
-        caption_list = [caption_rich_text.model_dump()]
 
-    # Create typed result
-    return NotionAudioBlock(
-        audio=NotionAudioData(
-            external=ExternalAudioSource(url=url), caption=caption_list
-        )
-    )
+class CreateAudioBlock(BaseModel):
+    type: Literal["audio"] = "audio"
+    audio: FileBlock

notionary/blocks/base_block_element.py

@@ -0,0 +1,42 @@
+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
+
+
+class BaseBlockElement(ABC):
+    """Base class for elements that can be converted between Markdown and Notion."""
+
+    @classmethod
+    async 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
+    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."""
+        # 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/__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,83 @@
+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.mixins.captions import CaptionMixin
+from notionary.blocks.syntax_prompt_builder import BlockElementMarkdownInformation
+from notionary.blocks.models import Block, BlockCreateResult, BlockType
 
 
-class BookmarkElement(NotionBlockElement):
+class BookmarkElement(BaseBlockElement, CaptionMixin):
     """
     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)(caption:This is a caption) - URL with caption
+    - (caption:This is a caption)[bookmark](https://example.com) - caption before URL
     """
 
-    # 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
-    )
+    # Flexible pattern that can handle caption in any position
+    BOOKMARK_PATTERN = re.compile(r"\[bookmark\]\((https?://[^\s\"]+)\)")
 
     @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())
-        )
+    def match_notion(cls, block: Block) -> bool:
+        return block.type == BlockType.BOOKMARK and block.bookmark
 
     @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"]
+    async def markdown_to_notion(cls, text: str) -> BlockCreateResult:
+        """
+        Convert a markdown bookmark into a Notion BookmarkBlock.
+        """
+        # First remove captions to get clean text for URL extraction
+        clean_text = cls.remove_caption(text.strip())
 
-    @classmethod
-    def markdown_to_notion(cls, text: str) -> NotionBlockResult:
-        """Convert markdown bookmark to Notion bookmark block."""
-        bookmark_match = BookmarkElement.PATTERN.match(text.strip())
+        # Use our own regex to find the bookmark URL
+        bookmark_match = cls.BOOKMARK_PATTERN.search(clean_text)
         if not bookmark_match:
             return None
 
         url = bookmark_match.group(1)
-        title = bookmark_match.group(2)
-        description = bookmark_match.group(3)
-
-        bookmark_data = {"url": url}
 
-        # Build caption string
-        caption_parts = []
-        if title:
-            caption_parts.append(title)
-        if description:
-            caption_parts.append(description)
+        caption_text = cls.extract_caption(text.strip())
+        caption_rich_text = cls.build_caption_rich_text(caption_text or "")
 
-        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"] = []
-
-        return [{"type": "bookmark", "bookmark": bookmark_data}]
+        bookmark_data = BookmarkBlock(url=url, caption=caption_rich_text)
+        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:
+    async 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
-            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}")'
+        result = f"[bookmark]({url})"
 
-        return f"[bookmark]({url})"
+        # Add caption if present
+        caption_markdown = await cls.format_caption_for_markdown(bm.caption or [])
+        if caption_markdown:
+            result += caption_markdown
 
-    @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()
-
-        return full_text.strip(), ""
-
-    @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()
+    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

@@ -1,43 +1,44 @@
 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
+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/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
+    async def markdown_to_notion(cls, text: str) -> BlockCreateResult:
+        if not cls.PATTERN.match(text.strip()):
+            return None
+        return CreateBreadcrumbBlock(breadcrumb=BreadcrumbBlock())
+
+    @classmethod
+    async 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",
 ]