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

notionary/blocks/heading/heading_element.py

@@ -1,98 +1,93 @@
-import re
-from typing import Dict, Any, Optional
+from __future__ import annotations
 
-from notionary.blocks import NotionBlockElement
-from notionary.blocks import (
-    ElementPromptContent,
-    ElementPromptBuilder,
-    NotionBlockResult,
+import re
+from typing import Optional, cast
+
+from notionary.blocks.base_block_element import BaseBlockElement
+from notionary.blocks.heading.heading_models import (
+    CreateHeading1Block,
+    CreateHeading2Block,
+    CreateHeading3Block,
+    HeadingBlock,
 )
-from notionary.blocks.shared.text_inline_formatter import TextInlineFormatter
+from notionary.blocks.models import Block, BlockCreateResult, BlockType
+from notionary.blocks.rich_text.text_inline_formatter import TextInlineFormatter
+from notionary.blocks.types import BlockColor
 
 
-class HeadingElement(NotionBlockElement):
+class HeadingElement(BaseBlockElement):
     """Handles conversion between Markdown headings and Notion heading blocks."""
 
-    # Pattern: #, ## oder ###, dann mind. 1 Leerzeichen/Tab, dann mind. 1 sichtbares Zeichen (kein Whitespace-only)
     PATTERN = re.compile(r"^(#{1,3})[ \t]+(.+)$")
 
     @classmethod
-    def match_markdown(cls, text: str) -> bool:
-        """Check if text is a markdown heading with non-empty content."""
-        match = cls.PATTERN.match(text)
-        if not match:
-            return False
-        content = match.group(2)
-        return bool(content.strip())  # Reject headings with only whitespace
-
-    @classmethod
-    def match_notion(cls, block: Dict[str, Any]) -> bool:
-        """Check if block is a Notion heading."""
-        block_type: str = block.get("type", "")
-        return block_type.startswith("heading_") and block_type[-1] in "123"
+    def match_notion(cls, block: Block) -> bool:
+        return (
+            block.type
+            in (
+                BlockType.HEADING_1,
+                BlockType.HEADING_2,
+                BlockType.HEADING_3,
+            )
+            and getattr(block, block.type.value) is not None
+        )
 
     @classmethod
-    def markdown_to_notion(cls, text: str) -> NotionBlockResult:
-        """Convert markdown heading to Notion heading block with preceding empty paragraph."""
-        match = cls.PATTERN.match(text)
+    def markdown_to_notion(cls, text: str) -> BlockCreateResult:
+        """Convert markdown headings (#, ##, ###) to Notion HeadingBlock."""
+        match = cls.PATTERN.match(text.strip())
         if not match:
             return None
 
         level = len(match.group(1))
-        if not 1 <= level <= 3:
+        if level < 1 or level > 3:
+            return None
+
+        content = match.group(2).strip()
+        if not content:
             return None
 
-        content = match.group(2).lstrip()  # Entferne führende Leerzeichen im Content
-        if not content.strip():
-            return None  # Leerer Inhalt nach Entfernen der Whitespaces
+        rich_text = TextInlineFormatter.parse_inline_formatting(content)
+        heading_content = HeadingBlock(
+            rich_text=rich_text, color=BlockColor.DEFAULT, is_toggleable=False
+        )
 
-        header_block = {
-            "type": f"heading_{level}",
-            f"heading_{level}": {
-                "rich_text": TextInlineFormatter.parse_inline_formatting(content)
-            },
-        }
-        return [header_block]
+        if level == 1:
+            return CreateHeading1Block(heading_1=heading_content)
+        elif level == 2:
+            return CreateHeading2Block(heading_2=heading_content)
+        else:
+            return CreateHeading3Block(heading_3=heading_content)
 
     @classmethod
-    def notion_to_markdown(cls, block: Dict[str, Any]) -> Optional[str]:
-        """Convert Notion heading block to markdown heading."""
-        block_type = block.get("type", "")
-
-        if not block_type.startswith("heading_"):
+    def notion_to_markdown(cls, block: Block) -> Optional[str]:
+        # Only handle heading blocks via BlockType enum
+        if block.type not in (
+            BlockType.HEADING_1,
+            BlockType.HEADING_2,
+            BlockType.HEADING_3,
+        ):
             return None
 
-        try:
-            level = int(block_type[-1])
-            if not 1 <= level <= 3:
-                return None
-        except ValueError:
-            return None
+        # Determine heading level from enum
+        if block.type == BlockType.HEADING_1:
+            level = 1
+        elif block.type == BlockType.HEADING_2:
+            level = 2
+        else:
+            level = 3
 
-        heading_data = block.get(block_type, {})
-        rich_text = heading_data.get("rich_text", [])
+        heading_obj = getattr(block, block.type.value)
+        if not heading_obj:
+            return None
 
-        text = TextInlineFormatter.extract_text_with_formatting(rich_text)
-        prefix = "#" * level
-        return f"{prefix} {text}" if text else None
+        heading_data = cast(HeadingBlock, heading_obj)
+        if not heading_data.rich_text:
+            return None
 
-    @classmethod
-    def is_multiline(cls) -> bool:
-        return False
+        text = TextInlineFormatter.extract_text_with_formatting(heading_data.rich_text)
+        if not text:
+            return None
 
-    @classmethod
-    def get_llm_prompt_content(cls) -> ElementPromptContent:
-        return (
-            ElementPromptBuilder()
-            .with_description(
-                "Use Markdown headings (#, ##, ###) to structure content hierarchically."
-            )
-            .with_usage_guidelines(
-                "Use to group content into sections and define a visual hierarchy."
-            )
-            .with_avoidance_guidelines(
-                "Only H1-H3 syntax is supported. H4 and deeper heading levels are not available."
-            )
-            .with_standard_markdown()
-            .build()
-        )
+        # Use hash-style for all heading levels
+        return f"{('#' * level)} {text}"

notionary/blocks/heading/heading_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 HeadingMarkdownBlockParams(BaseModel):

notionary/blocks/heading/heading_models.py

@@ -0,0 +1,29 @@
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+from notionary.blocks.models import Block
+from notionary.blocks.rich_text.rich_text_models import RichTextObject
+from notionary.blocks.types import BlockColor
+
+
+class HeadingBlock(BaseModel):
+    rich_text: list[RichTextObject]
+    color: BlockColor = BlockColor.DEFAULT
+    is_toggleable: bool = False
+    children: list[Block] = Field(default_factory=list)
+
+
+class CreateHeading1Block(BaseModel):
+    type: Literal["heading_1"] = "heading_1"
+    heading_1: HeadingBlock
+
+
+class CreateHeading2Block(BaseModel):
+    type: Literal["heading_2"] = "heading_2"
+    heading_2: HeadingBlock
+
+
+class CreateHeading3Block(BaseModel):
+    type: Literal["heading_3"] = "heading_3"
+    heading_3: HeadingBlock

notionary/blocks/image_block/__init__.py

@@ -0,0 +1,13 @@
+from notionary.blocks.image_block.image_element import ImageElement
+from notionary.blocks.image_block.image_markdown_node import (
+    ImageMarkdownBlockParams,
+    ImageMarkdownNode,
+)
+from notionary.blocks.image_block.image_models import CreateImageBlock
+
+__all__ = [
+    "ImageElement",
+    "CreateImageBlock",
+    "ImageMarkdownNode",
+    "ImageMarkdownBlockParams",
+]

notionary/blocks/image_block/image_element.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import re
+from typing import Optional
+
+from notionary.blocks.base_block_element import BaseBlockElement
+from notionary.blocks.file.file_element_models import ExternalFile, FileType
+from notionary.blocks.image_block.image_models import CreateImageBlock, FileBlock
+from notionary.blocks.models import Block, BlockCreateResult, BlockType
+from notionary.blocks.paragraph.paragraph_models import (
+    CreateParagraphBlock,
+    ParagraphBlock,
+)
+from notionary.blocks.rich_text.rich_text_models import RichTextObject
+from notionary.blocks.rich_text.text_inline_formatter import TextInlineFormatter
+
+
+class ImageElement(BaseBlockElement):
+    """
+    Handles conversion between Markdown images and Notion image blocks.
+
+    Markdown image syntax:
+    - [image](https://example.com/image.jpg) - URL only
+    - [image](https://example.com/image.jpg "Caption") - URL + caption
+    """
+
+    PATTERN = re.compile(
+        r"^\[image\]\("  # prefix
+        r"(https?://[^\s\"]+)"  # URL (exclude whitespace and ")
+        r"(?:\s+\"([^\"]+)\")?"  # optional caption
+        r"\)$"
+    )
+
+    @classmethod
+    def match_notion(cls, block: Block) -> bool:
+        return block.type == BlockType.IMAGE and block.image
+
+    @classmethod
+    def markdown_to_notion(cls, text: str) -> BlockCreateResult:
+        """Convert markdown image syntax to Notion ImageBlock followed by an empty paragraph."""
+        match = cls.PATTERN.match(text.strip())
+        if not match:
+            return None
+
+        url, caption_text = match.group(1), match.group(2) or ""
+        # Build ImageBlock
+        image_block = FileBlock(
+            type="external", external=ExternalFile(url=url), caption=[]
+        )
+        if caption_text.strip():
+            rt = RichTextObject.from_plain_text(caption_text.strip())
+            image_block.caption = [rt]
+
+        empty_para = ParagraphBlock(rich_text=[])
+
+        return [
+            CreateImageBlock(image=image_block),
+            CreateParagraphBlock(paragraph=empty_para),
+        ]
+
+    @classmethod
+    def notion_to_markdown(cls, block: Block) -> Optional[str]:
+        if block.type != BlockType.IMAGE or not block.image:
+            return None
+
+        fo = block.image
+
+        if fo.type == FileType.EXTERNAL and fo.external:
+            url = fo.external.url
+        elif fo.type == FileType.FILE and fo.file:
+            url = fo.file.url
+        else:
+            return None
+
+        captions = fo.caption or []
+        if not captions:
+            return f"[image]({url})"
+
+        caption_text = "".join(
+            (rt.plain_text or TextInlineFormatter.extract_text_with_formatting([rt]))
+            for rt in captions
+        )
+
+        return f'[image]({url} "{caption_text}")'

notionary/blocks/{image → image_block}/image_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 ImageMarkdownBlockParams(BaseModel):

notionary/blocks/image_block/image_models.py

@@ -0,0 +1,10 @@
+from typing import Literal
+
+from pydantic import BaseModel
+
+from notionary.blocks.file.file_element_models import FileBlock
+
+
+class CreateImageBlock(BaseModel):
+    type: Literal["image"] = "image"
+    image: FileBlock

notionary/blocks/models.py

@@ -0,0 +1,172 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Literal, Optional, Union
+
+from pydantic import BaseModel
+
+from notionary.blocks.types import BlockType
+
+if TYPE_CHECKING:
+    from notionary.blocks.bookmark import BookmarkBlock, CreateBookmarkBlock
+    from notionary.blocks.breadcrumbs import BreadcrumbBlock, CreateBreadcrumbBlock
+    from notionary.blocks.bulleted_list import (
+        BulletedListItemBlock,
+        CreateBulletedListItemBlock,
+    )
+    from notionary.blocks.callout import CalloutBlock, CreateCalloutBlock
+    from notionary.blocks.child_page import ChildPageBlock, CreateChildPageBlock
+    from notionary.blocks.code import CodeBlock, CreateCodeBlock
+    from notionary.blocks.column import (
+        ColumnBlock,
+        ColumnListBlock,
+        CreateColumnBlock,
+        CreateColumnListBlock,
+    )
+    from notionary.blocks.divider import CreateDividerBlock, DividerBlock
+    from notionary.blocks.embed import CreateEmbedBlock, EmbedBlock
+    from notionary.blocks.equation import CreateEquationBlock, EquationBlock
+    from notionary.blocks.file import CreateFileBlock, FileBlock
+    from notionary.blocks.heading import (
+        CreateHeading1Block,
+        CreateHeading2Block,
+        CreateHeading3Block,
+        HeadingBlock,
+    )
+    from notionary.blocks.image_block import CreateImageBlock
+    from notionary.blocks.numbered_list import (
+        CreateNumberedListItemBlock,
+        NumberedListItemBlock,
+    )
+    from notionary.blocks.paragraph import CreateParagraphBlock, ParagraphBlock
+    from notionary.blocks.pdf import CreatePdfBlock
+    from notionary.blocks.quote import CreateQuoteBlock, QuoteBlock
+    from notionary.blocks.table import CreateTableBlock, TableBlock, TableRowBlock
+    from notionary.blocks.table_of_contents import (
+        CreateTableOfContentsBlock,
+        TableOfContentsBlock,
+    )
+    from notionary.blocks.todo import CreateToDoBlock, ToDoBlock
+    from notionary.blocks.toggle import CreateToggleBlock, ToggleBlock
+    from notionary.blocks.video import CreateVideoBlock
+
+
+class BlockChildrenResponse(BaseModel):
+    object: Literal["list"]
+    results: list["Block"]
+    next_cursor: Optional[str] = None
+    has_more: bool
+    type: Literal["block"]
+    block: dict = {}
+    request_id: str
+
+
+class PageParent(BaseModel):
+    type: Literal["page_id"]
+    page_id: str
+
+
+class DatabaseParent(BaseModel):
+    type: Literal["database_id"]
+    database_id: str
+
+
+class BlockParent(BaseModel):
+    type: Literal["block_id"]
+    block_id: str
+
+
+class WorkspaceParent(BaseModel):
+    type: Literal["workspace"]
+    workspace: bool = True
+
+
+ParentObject = Union[PageParent, DatabaseParent, BlockParent, WorkspaceParent]
+
+
+class PartialUser(BaseModel):
+    object: Literal["user"]
+    id: str
+
+
+class Block(BaseModel):
+    object: Literal["block"]
+    id: str
+    parent: Optional[ParentObject] = None
+    type: BlockType
+    created_time: str
+    last_edited_time: str
+    created_by: PartialUser
+    last_edited_by: PartialUser
+    archived: bool = False
+    in_trash: bool = False
+    has_children: bool = False
+
+    children: Optional[list[Block]] = None
+
+    # Block type-specific content (only one will be populated based on type)
+    audio: Optional[FileBlock] = None
+    bookmark: Optional[BookmarkBlock] = None
+    breadcrumb: Optional[BreadcrumbBlock] = None
+    bulleted_list_item: Optional[BulletedListItemBlock] = None
+    callout: Optional[CalloutBlock] = None
+    child_page: Optional[ChildPageBlock] = None
+    code: Optional[CodeBlock] = None
+    column_list: Optional[ColumnListBlock] = None
+    column: Optional[ColumnBlock] = None
+    divider: Optional[DividerBlock] = None
+    embed: Optional[EmbedBlock] = None
+    equation: Optional[EquationBlock] = None
+    file: Optional[FileBlock] = None
+    heading_1: Optional[HeadingBlock] = None
+    heading_2: Optional[HeadingBlock] = None
+    heading_3: Optional[HeadingBlock] = None
+    image: Optional[FileBlock] = None
+    numbered_list_item: Optional[NumberedListItemBlock] = None
+    paragraph: Optional[ParagraphBlock] = None
+    quote: Optional[QuoteBlock] = None
+    table: Optional[TableBlock] = None
+    table_row: Optional[TableRowBlock] = None
+    to_do: Optional[ToDoBlock] = None
+    toggle: Optional[ToggleBlock] = None
+    video: Optional[FileBlock] = None
+    pdf: Optional[FileBlock] = None
+    table_of_contents: Optional[TableOfContentsBlock] = None
+
+    def get_block_content(self) -> Optional[Any]:
+        """Get the content object for this block based on its type."""
+        return getattr(self, self.type, None)
+
+
+if TYPE_CHECKING:
+    BlockCreateRequest = Union[
+        CreateBookmarkBlock,
+        CreateBreadcrumbBlock,
+        CreateBulletedListItemBlock,
+        CreateCalloutBlock,
+        CreateChildPageBlock,
+        CreateCodeBlock,
+        CreateColumnListBlock,
+        CreateColumnBlock,
+        CreateDividerBlock,
+        CreateEmbedBlock,
+        CreateEquationBlock,
+        CreateFileBlock,
+        CreateHeading1Block,
+        CreateHeading2Block,
+        CreateHeading3Block,
+        CreateImageBlock,
+        CreateNumberedListItemBlock,
+        CreateParagraphBlock,
+        CreateQuoteBlock,
+        CreateToDoBlock,
+        CreateToggleBlock,
+        CreateVideoBlock,
+        CreateTableOfContentsBlock,
+        CreatePdfBlock,
+        CreateTableBlock,
+    ]
+    BlockCreateResult = Optional[Union[list[BlockCreateRequest], BlockCreateRequest]]
+else:
+    # at runtime there are no typings anyway
+    BlockCreateRequest = Any
+    BlockCreateResult = Any

notionary/blocks/numbered_list/__init__.py

@@ -1,7 +1,17 @@
-from .numbered_list_element import NumberedListElement
-from .numbered_list_markdown_node import NumberedListMarkdownNode
+from notionary.blocks.numbered_list.numbered_list_element import NumberedListElement
+from notionary.blocks.numbered_list.numbered_list_markdown_node import (
+    NumberedListMarkdownBlockParams,
+    NumberedListMarkdownNode,
+)
+from notionary.blocks.numbered_list.numbered_list_models import (
+    CreateNumberedListItemBlock,
+    NumberedListItemBlock,
+)
 
 __all__ = [
     "NumberedListElement",
+    "NumberedListItemBlock",
+    "CreateNumberedListItemBlock",
     "NumberedListMarkdownNode",
+    "NumberedListMarkdownBlockParams",
 ]

notionary/blocks/numbered_list/numbered_list_element.py

@@ -1,73 +1,48 @@
+from __future__ import annotations
+
 import re
-from typing import Any, Optional
-from notionary.blocks import NotionBlockElement
-from notionary.blocks import (
-    ElementPromptContent,
-    ElementPromptBuilder,
-    NotionBlockResult,
+from typing import Optional
+
+from notionary.blocks.base_block_element import BaseBlockElement
+from notionary.blocks.models import Block, BlockCreateResult, BlockType
+from notionary.blocks.numbered_list.numbered_list_models import (
+    CreateNumberedListItemBlock,
+    NumberedListItemBlock,
 )
-from notionary.blocks.shared.text_inline_formatter import TextInlineFormatter
+from notionary.blocks.rich_text.text_inline_formatter import TextInlineFormatter
+from notionary.blocks.types import BlockColor
+
 
+class NumberedListElement(BaseBlockElement):
+    """Converts between Markdown numbered lists and Notion numbered list items."""
 
-class NumberedListElement(NotionBlockElement):
-    """Class for converting between Markdown numbered lists and Notion numbered list items."""
+    PATTERN = re.compile(r"^\s*(\d+)\.\s+(.+)$")
 
     @classmethod
-    def markdown_to_notion(cls, text: str) -> NotionBlockResult:
-        """Convert markdown numbered list item to Notion block."""
-        pattern = re.compile(r"^\s*(\d+)\.\s+(.+)$")
-        numbered_match = pattern.match(text)
-        if not numbered_match:
-            return None
+    def match_notion(cls, block: Block) -> bool:
+        return block.type == BlockType.NUMBERED_LIST_ITEM and block.numbered_list_item
 
-        content = numbered_match.group(2)
+    @classmethod
+    def markdown_to_notion(cls, text: str) -> BlockCreateResult:
+        """Convert markdown numbered list item to Notion NumberedListItemBlock."""
+        match = cls.PATTERN.match(text.strip())
+        if not match:
+            return None
 
-        # Use parse_inline_formatting to handle rich text
+        content = match.group(2)
         rich_text = TextInlineFormatter.parse_inline_formatting(content)
 
-        return {
-            "type": "numbered_list_item",
-            "numbered_list_item": {"rich_text": rich_text, "color": "default"},
-        }
+        numbered_list_content = NumberedListItemBlock(
+            rich_text=rich_text, color=BlockColor.DEFAULT
+        )
+        return CreateNumberedListItemBlock(numbered_list_item=numbered_list_content)
 
+    # FIX: Roundtrip conversions will never work this way here
     @classmethod
-    def notion_to_markdown(cls, block: dict[str, Any]) -> Optional[str]:
-        """Convert Notion numbered list item block to markdown."""
-        if block.get("type") != "numbered_list_item":
+    def notion_to_markdown(cls, block: Block) -> Optional[str]:
+        if block.type != BlockType.NUMBERED_LIST_ITEM or not block.numbered_list_item:
             return None
 
-        rich_text = block.get("numbered_list_item", {}).get("rich_text", [])
-        content = TextInlineFormatter.extract_text_with_formatting(rich_text)
-
+        rich = block.numbered_list_item.rich_text
+        content = TextInlineFormatter.extract_text_with_formatting(rich)
         return f"1. {content}"
-
-    @classmethod
-    def match_markdown(cls, text: str) -> bool:
-        """Check if this element can handle the given markdown text."""
-        pattern = re.compile(r"^\s*\d+\.\s+(.+)$")
-        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") == "numbered_list_item"
-
-    @classmethod
-    def is_multiline(cls) -> bool:
-        return False
-
-    @classmethod
-    def get_llm_prompt_content(cls) -> ElementPromptContent:
-        """
-        Returns structured LLM prompt metadata for the numbered list element.
-        """
-        return (
-            ElementPromptBuilder()
-            .with_description("Creates numbered list items for ordered sequences.")
-            .with_usage_guidelines(
-                "Use for lists where order matters, such as steps, rankings, or sequential items."
-            )
-            .with_syntax("1. Item text")
-            .with_standard_markdown()
-            .build()
-        )

notionary/blocks/numbered_list/numbered_list_markdown_node.py

@@ -1,6 +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 NumberedListMarkdownBlockParams(BaseModel):

notionary/blocks/numbered_list/numbered_list_models.py

@@ -0,0 +1,17 @@
+from pydantic import BaseModel, Field
+from typing_extensions import Literal
+
+from notionary.blocks.models import Block
+from notionary.blocks.rich_text.rich_text_models import RichTextObject
+from notionary.blocks.types import BlockColor
+
+
+class NumberedListItemBlock(BaseModel):
+    rich_text: list[RichTextObject]
+    color: BlockColor = BlockColor.DEFAULT
+    children: list[Block] = Field(default_factory=list)
+
+
+class CreateNumberedListItemBlock(BaseModel):
+    type: Literal["numbered_list_item"] = "numbered_list_item"
+    numbered_list_item: NumberedListItemBlock