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

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

notionary/blocks/child_page/child_page_element.py

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

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

notionary/blocks/code/__init__.py

@@ -1,11 +0,0 @@
-from notionary.blocks.code.code_element import CodeElement
-from notionary.blocks.code.code_markdown_node import CodeMarkdownNode
-from notionary.blocks.code.code_models import CodeBlock, CodeLanguage, CreateCodeBlock
-
-__all__ = [
-    "CodeElement",
-    "CodeBlock",
-    "CodeLanguage",
-    "CreateCodeBlock",
-    "CodeMarkdownNode",
-]