notionary 0.2.27__py3-none-any.whl → 0.3.0__py3-none-any.whl

notionary/blocks/base_block_element.py

@@ -1,42 +0,0 @@
-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,12 +0,0 @@
-from notionary.blocks.bookmark.bookmark_element import BookmarkElement
-from notionary.blocks.bookmark.bookmark_markdown_node import (
-    BookmarkMarkdownNode,
-)
-from notionary.blocks.bookmark.bookmark_models import BookmarkBlock, CreateBookmarkBlock
-
-__all__ = [
-    "BookmarkElement",
-    "BookmarkBlock",
-    "CreateBookmarkBlock",
-    "BookmarkMarkdownNode",
-]

notionary/blocks/bookmark/bookmark_element.py

@@ -1,83 +0,0 @@
-from __future__ import annotations
-
-import re
-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
-
-
-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)(caption:This is a caption) - URL with caption
-    - (caption:This is a caption)[bookmark](https://example.com) - caption before URL
-    """
-
-    # 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
-    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())
-
-        # 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)
-
-        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_rich_text)
-        return CreateBookmarkBlock(bookmark=bookmark_data)
-
-    @classmethod
-    async def notion_to_markdown(cls, block: Block) -> Optional[str]:
-        if block.type != BlockType.BOOKMARK or block.bookmark is None:
-            return None
-
-        bm = block.bookmark
-        url = bm.url
-        if not url:
-            return None
-
-        result = f"[bookmark]({url})"
-
-        # Add caption if present
-        caption_markdown = await cls.format_caption_for_markdown(bm.caption or [])
-        if caption_markdown:
-            result += caption_markdown
-
-        return result
-
-    @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

@@ -1,28 +0,0 @@
-from typing import Optional
-
-from notionary.blocks.markdown.markdown_node import MarkdownNode
-from notionary.blocks.mixins.captions import CaptionMarkdownNodeMixin
-
-
-class BookmarkMarkdownNode(MarkdownNode, CaptionMarkdownNodeMixin):
-    """
-    Enhanced Bookmark node with Pydantic integration.
-    Programmatic interface for creating Notion-style bookmark Markdown blocks.
-    """
-
-    url: str
-    title: Optional[str] = None
-    caption: Optional[str] = None
-
-    def to_markdown(self) -> str:
-        """Return the Markdown representation.
-
-        Examples:
-        - [bookmark](https://example.com)
-        - [bookmark](https://example.com)(caption:Some caption)
-        """
-        # 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

@@ -1,15 +0,0 @@
-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

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

notionary/blocks/breadcrumbs/breadcrumb_element.py

@@ -1,39 +0,0 @@
-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

@@ -1,13 +0,0 @@
-from notionary.blocks.markdown.markdown_node import MarkdownNode
-
-
-class BreadcrumbMarkdownNode(MarkdownNode):
-    """
-    Enhanced Breadcrumb node with Pydantic integration.
-    Programmatic interface for creating Markdown breadcrumb blocks.
-    Example:
-    [breadcrumb]
-    """
-
-    def to_markdown(self) -> str:
-        return "[breadcrumb]"

notionary/blocks/breadcrumbs/breadcrumb_models.py

@@ -1,12 +0,0 @@
-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,15 +0,0 @@
-from notionary.blocks.bulleted_list.bulleted_list_element import BulletedListElement
-from notionary.blocks.bulleted_list.bulleted_list_markdown_node import (
-    BulletedListMarkdownNode,
-)
-from notionary.blocks.bulleted_list.bulleted_list_models import (
-    BulletedListItemBlock,
-    CreateBulletedListItemBlock,
-)
-
-__all__ = [
-    "BulletedListElement",
-    "BulletedListItemBlock",
-    "CreateBulletedListItemBlock",
-    "BulletedListMarkdownNode",
-]

notionary/blocks/bulleted_list/bulleted_list_element.py

@@ -1,74 +0,0 @@
-from __future__ import annotations
-
-import re
-from typing import Optional
-
-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(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
-    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
-
-        # Extract the content part (second capture group)
-        content = match.group(2)
-
-        # Parse inline markdown formatting into RichTextObject list
-        rich_text = await TextInlineFormatter.parse_inline_formatting(content)
-
-        # 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
-    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_list = block.bulleted_list_item.rich_text
-        if not rich_list:
-            return "-"
-
-        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/bulleted_list/bulleted_list_markdown_node.py

@@ -1,20 +0,0 @@
-from notionary.blocks.markdown.markdown_node import MarkdownNode
-
-
-class BulletedListMarkdownNode(MarkdownNode):
-    """
-    Enhanced BulletedList node with Pydantic integration.
-    Programmatic interface for creating Markdown bulleted list items.
-    Example:
-    - First item
-    - Second item
-    - Third item
-    """
-
-    texts: list[str]
-
-    def to_markdown(self) -> str:
-        result = []
-        for text in self.texts:
-            result.append(f"- {text}")
-        return "\n".join(result)

notionary/blocks/bulleted_list/bulleted_list_models.py

@@ -1,17 +0,0 @@
-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
-
-
-class CreateBulletedListItemBlock(BaseModel):
-    type: Literal["bulleted_list_item"] = "bulleted_list_item"
-    bulleted_list_item: BulletedListItemBlock

notionary/blocks/callout/__init__.py

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

notionary/blocks/callout/callout_element.py

@@ -1,99 +0,0 @@
-from __future__ import annotations
-
-import re
-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(BaseBlockElement):
-    """
-    Handles conversion between Markdown callouts and Notion callout blocks.
-
-    Markdown callout syntax:
-    - [callout](Text) - Simple callout with default emoji
-    - [callout](Text "emoji") - Callout with custom emoji
-
-    Where:
-    - Text is the required callout content
-    - emoji is an optional emoji character (enclosed in quotes)
-    """
-
-    PATTERN = re.compile(
-        r"^\[callout\]\("  # prefix
-        r"([^\"]+?)"  # content
-        r"(?:\s+\"([^\"]+)\")?"  # optional emoji
-        r"\)$"
-    )
-
-    DEFAULT_EMOJI = "💡"
-    DEFAULT_COLOR = "gray_background"
-
-    @classmethod
-    def match_notion(cls, block: Block) -> bool:
-        return block.type == BlockType.CALLOUT and block.callout
-
-    @classmethod
-    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, emoji = match.group(1), match.group(2)
-        if not content:
-            return None
-
-        if not emoji:
-            emoji = cls.DEFAULT_EMOJI
-
-        rich_text = await TextInlineFormatter.parse_inline_formatting(content.strip())
-
-        callout_content = CalloutBlock(
-            rich_text=rich_text,
-            icon=EmojiIcon(emoji=emoji),
-            color=cls.DEFAULT_COLOR,
-        )
-        return CreateCalloutBlock(callout=callout_content)
-
-    @classmethod
-    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 = await TextInlineFormatter.extract_text_with_formatting(data.rich_text)
-        if not content:
-            return None
-
-        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 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,19 +0,0 @@
-from typing import Optional
-from notionary.blocks.markdown.markdown_node import MarkdownNode
-
-
-class CalloutMarkdownNode(MarkdownNode):
-    """
-    Enhanced Callout node with Pydantic integration.
-    Programmatic interface for creating Notion-style callout Markdown blocks.
-    Example: [callout](This is important "⚠️")
-    """
-
-    text: str
-    emoji: Optional[str] = None
-
-    def to_markdown(self) -> str:
-        if self.emoji and self.emoji != "💡":
-            return f'[callout]({self.text} "{self.emoji}")'
-        else:
-            return f"[callout]({self.text})"

notionary/blocks/callout/callout_models.py

@@ -1,33 +0,0 @@
-from typing import Literal, Optional, Union
-
-from pydantic import BaseModel, Field, model_serializer
-
-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]
-    color: BlockColor = BlockColor.DEFAULT
-    icon: Optional[IconObject] = None
-    children: Optional[list[Block]] = None
-
-
-class CreateCalloutBlock(BaseModel):
-    type: Literal["callout"] = "callout"
-    callout: CalloutBlock

notionary/blocks/child_database/__init__.py

@@ -1,14 +0,0 @@
-"""
-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

@@ -1,59 +0,0 @@
-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,12 +0,0 @@
-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

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