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

notionary/blocks/callout/callout_element.py

@@ -1,16 +1,20 @@
+from __future__ import annotations
+
 import re
-from typing import Dict, Any, Optional, List
-
-from notionary.blocks.shared.text_inline_formatter import TextInlineFormatter
-from notionary.blocks import (
-    NotionBlockElement,
-    ElementPromptContent,
-    ElementPromptBuilder,
-    NotionBlockResult,
+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.models import Block, BlockCreateResult, BlockType
+from notionary.blocks.rich_text.text_inline_formatter import TextInlineFormatter
 
 
-class CalloutElement(NotionBlockElement):
+class CalloutElement(BaseBlockElement):
     """
     Handles conversion between Markdown callouts and Notion callout blocks.
 
@@ -23,110 +27,57 @@ class CalloutElement(NotionBlockElement):
     - emoji is an optional emoji character (enclosed in quotes)
     """
 
-    # Regex pattern for callout syntax with optional emoji
     PATTERN = re.compile(
-        r"^\[callout\]\("  # [callout]( prefix
-        + r'([^"]+?)'  # Text content (required)
-        + r'(?:\s+"([^"]+)")?'  # Optional emoji in quotes
-        + r"\)$"  # closing parenthesis
+        r"^\[callout\]\("  # prefix
+        r"([^\"]+?)"  # content
+        r"(?:\s+\"([^\"]+)\")?"  # optional emoji
+        r"\)$"
     )
 
-    # Default values
     DEFAULT_EMOJI = "💡"
     DEFAULT_COLOR = "gray_background"
 
     @classmethod
-    def match_markdown(cls, text: str) -> bool:
-        """Check if text is a markdown callout."""
-        return text.strip().startswith("[callout]") and bool(
-            CalloutElement.PATTERN.match(text.strip())
-        )
-
-    @classmethod
-    def match_notion(cls, block: Dict[str, Any]) -> bool:
-        """Check if block is a Notion callout."""
-        return block.get("type") == "callout"
+    def match_notion(cls, block: Block) -> bool:
+        return block.type == BlockType.CALLOUT and block.callout
 
     @classmethod
-    def markdown_to_notion(cls, text: str) -> NotionBlockResult:
-        """Convert markdown callout to Notion callout block."""
-        callout_match = CalloutElement.PATTERN.match(text.strip())
-        if not callout_match:
+    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 = callout_match.group(1)
-        emoji = callout_match.group(2)
-
+        content, emoji = match.group(1), match.group(2)
         if not content:
             return None
 
-        # Use default emoji if none provided
         if not emoji:
-            emoji = CalloutElement.DEFAULT_EMOJI
+            emoji = cls.DEFAULT_EMOJI
 
-        callout_data = {
-            "rich_text": TextInlineFormatter.parse_inline_formatting(content.strip()),
-            "icon": {"type": "emoji", "emoji": emoji},
-            "color": CalloutElement.DEFAULT_COLOR,
-        }
+        rich_text = TextInlineFormatter.parse_inline_formatting(content.strip())
 
-        return {"type": "callout", "callout": callout_data}
+        callout_content = CalloutBlock(
+            rich_text=rich_text,
+            icon=EmojiIcon(emoji=emoji),
+            color=cls.DEFAULT_COLOR,
+        )
+        return CreateCalloutBlock(callout=callout_content)
 
     @classmethod
-    def notion_to_markdown(cls, block: Dict[str, Any]) -> Optional[str]:
-        """Convert Notion callout block to markdown callout."""
-        if block.get("type") != "callout":
+    def notion_to_markdown(cls, block: Block) -> Optional[str]:
+        if block.type != BlockType.CALLOUT or not block.callout:
             return None
 
-        callout_data = block.get("callout", {})
-        rich_text = callout_data.get("rich_text", [])
-        icon = callout_data.get("icon", {})
+        data = block.callout
 
-        content = TextInlineFormatter.extract_text_with_formatting(rich_text)
+        content = TextInlineFormatter.extract_text_with_formatting(data.rich_text)
         if not content:
             return None
 
-        emoji = CalloutElement._extract_emoji(icon)
-
-        if emoji and emoji != CalloutElement.DEFAULT_EMOJI:
-            return f'[callout]({content} "{emoji}")'
+        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 is_multiline(cls) -> bool:
-        """Callouts are single-line elements."""
-        return False
-
-    @classmethod
-    def _extract_emoji(cls, icon: Dict[str, Any]) -> str:
-        """Extract emoji from Notion icon object."""
-        if icon and icon.get("type") == "emoji":
-            return icon.get("emoji", "")
-        return ""
-
-    @classmethod
-    def get_llm_prompt_content(cls) -> ElementPromptContent:
-        """
-        Returns structured LLM prompt metadata for the callout element.
-        """
-        return (
-            ElementPromptBuilder()
-            .with_description(
-                "Creates a callout block to highlight important information with an icon."
-            )
-            .with_usage_guidelines(
-                "Use callouts when you want to draw attention to important information, "
-                "tips, warnings, or notes that stand out from the main content."
-            )
-            .with_syntax('[callout](Text content "Optional emoji")')
-            .with_examples(
-                [
-                    "[callout](This is a default callout with the light bulb emoji)",
-                    '[callout](This is a callout with a bell emoji "🔔")',
-                    '[callout](Warning: This is an important note "⚠️")',
-                    '[callout](Tip: Add emoji that matches your content\'s purpose "💡")',
-                ]
-            )
-            .build()
-        )

notionary/blocks/callout/callout_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 CalloutMarkdownBlockParams(BaseModel):

notionary/blocks/callout/callout_models.py

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

notionary/blocks/child_database/__init__.py

@@ -0,0 +1,7 @@
+from notionary.blocks.child_database.child_database_models import (
+    CreateInlineDatabaseRequest,
+)
+
+__all__ = [
+    "CreateInlineDatabaseRequest",
+]

notionary/blocks/child_database/child_database_models.py

@@ -0,0 +1,19 @@
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+from notionary.blocks.rich_text.rich_text_models import RichTextObject
+
+
+class CreateInlineDatabaseRequest(BaseModel):
+    """
+    Minimaler Create-Payload für eine inline Database.
+    Parent wird von der Page-Schicht gesetzt: {"type": "page_id", "page_id": "..."}.
+    """
+
+    parent: dict[str, str]  # wird von außen injiziert
+    title: list[
+        RichTextObject
+    ]  # z. B. [RichTextObject.from_plain_text("Monatsübersicht")]
+    properties: dict[str, dict[str, Any]]  # mindestens eine Title-Property erforderlich
+    is_inline: bool = True  # inline = erscheint als child_database-Block auf der Page

notionary/blocks/child_page/__init__.py

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

notionary/blocks/child_page/child_page_models.py

@@ -0,0 +1,12 @@
+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/{shared/block_client.py → client.py}

@@ -1,10 +1,9 @@
-from typing import Optional, Dict, Any
+from typing import Any, Optional
+
 from notionary.base_notion_client import BaseNotionClient
-from notionary.util import singleton
-from notionary.blocks.shared.models import Block, BlockChildrenResponse
+from notionary.blocks.models import Block, BlockChildrenResponse, BlockCreateRequest
 
 
-@singleton
 class NotionBlockClient(BaseNotionClient):
     """
     Client for Notion Block API operations.
@@ -25,6 +24,37 @@ class NotionBlockClient(BaseNotionClient):
                 return None
         return None
 
+    # das hier ist falsch (Columns werden nicht richtig abgebildet)
+    async def get_blocks_by_page_id_recursively(
+        self, page_id: str, parent_id: Optional[str] = None
+    ) -> list[Block]:
+        response = (
+            await self.get_block_children(block_id=page_id)
+            if parent_id is None
+            else await self.get_block_children(block_id=parent_id)
+        )
+
+        if not response or not response.results:
+            return []
+
+        blocks = response.results
+
+        for block in blocks:
+            if not block.has_children:
+                continue
+
+            block_id = block.id
+            if not block_id:
+                continue
+
+            children = await self.get_blocks_by_page_id_recursively(
+                page_id=page_id, parent_id=block_id
+            )
+            if children:
+                block.children = children
+
+        return blocks
+
     async def get_block_children(
         self, block_id: str, start_cursor: Optional[str] = None, page_size: int = 100
     ) -> Optional[BlockChildrenResponse]:
@@ -38,13 +68,15 @@ class NotionBlockClient(BaseNotionClient):
             params["start_cursor"] = start_cursor
 
         response = await self.get(f"blocks/{block_id}/children", params=params)
-        if response:
-            try:
-                return BlockChildrenResponse.model_validate(response)
-            except Exception as e:
-                self.logger.error("Failed to parse block children response: %s", str(e))
-                return None
-        return None
+
+        if not response:
+            return None
+
+        try:
+            return BlockChildrenResponse.model_validate(response)
+        except Exception as e:
+            self.logger.error("Failed to parse block children response: %s", str(e))
+            return None
 
     async def get_all_block_children(self, block_id: str) -> list[Block]:
         """
@@ -74,7 +106,10 @@ class NotionBlockClient(BaseNotionClient):
         return all_blocks
 
     async def append_block_children(
-        self, block_id: str, children: list[Dict[str, Any]], after: Optional[str] = None
+        self,
+        block_id: str,
+        children: list[BlockCreateRequest],
+        after: Optional[str] = None,
     ) -> Optional[BlockChildrenResponse]:
         """
         Appends new child blocks to a parent block.
@@ -86,15 +121,18 @@ class NotionBlockClient(BaseNotionClient):
 
         self.logger.debug("Appending %d children to block: %s", len(children), block_id)
 
+        # Convert Pydantic models to dictionaries for API
+        children_dicts = [block.model_dump(exclude_none=True) for block in children]
+
         # If 100 or fewer blocks, use single request
-        if len(children) <= 100:
-            return await self._append_single_batch(block_id, children, after)
+        if len(children_dicts) <= 100:
+            return await self._append_single_batch(block_id, children_dicts, after)
 
         # For more than 100 blocks, use batch processing
-        return await self._append_multiple_batches(block_id, children, after)
+        return await self._append_multiple_batches(block_id, children_dicts, after)
 
     async def _append_single_batch(
-        self, block_id: str, children: list[Dict[str, Any]], after: Optional[str] = None
+        self, block_id: str, children: list[dict[str, Any]], after: Optional[str] = None
     ) -> Optional[BlockChildrenResponse]:
         """
         Appends a single batch of blocks (≤100).
@@ -113,7 +151,7 @@ class NotionBlockClient(BaseNotionClient):
         return None
 
     async def _append_multiple_batches(
-        self, block_id: str, children: list[Dict[str, Any]], after: Optional[str] = None
+        self, block_id: str, children: list[dict[str, Any]], after: Optional[str] = None
     ) -> Optional[BlockChildrenResponse]:
         """
         Appends multiple batches of blocks, handling pagination.
@@ -206,27 +244,6 @@ class NotionBlockClient(BaseNotionClient):
             request_id=responses[-1].request_id,  # Use last request ID
         )
 
-    async def update_block(
-        self, block_id: str, block_data: Dict[str, Any], archived: Optional[bool] = None
-    ) -> Optional[Block]:
-        """
-        Updates an existing block.
-        """
-        self.logger.debug("Updating block: %s", block_id)
-
-        data = block_data.copy()
-        if archived is not None:
-            data["archived"] = archived
-
-        response = await self.patch(f"blocks/{block_id}", data)
-        if response:
-            try:
-                return Block.model_validate(response)
-            except Exception as e:
-                self.logger.error("Failed to parse update response: %s", str(e))
-                return None
-        return None
-
     async def delete_block(self, block_id: str) -> Optional[Block]:
         """
         Deletes (archives) a block.
@@ -238,19 +255,3 @@ class NotionBlockClient(BaseNotionClient):
             # After deletion, retrieve the block to return the updated state
             return await self.get_block(block_id)
         return None
-
-    async def archive_block(self, block_id: str) -> Optional[Block]:
-        """
-        Archives a block by setting archived=True.
-        """
-        self.logger.debug("Archiving block: %s", block_id)
-
-        return await self.update_block(block_id=block_id, block_data={}, archived=True)
-
-    async def unarchive_block(self, block_id: str) -> Optional[Block]:
-        """
-        Unarchives a block by setting archived=False.
-        """
-        self.logger.debug("Unarchiving block: %s", block_id)
-
-        return await self.update_block(block_id=block_id, block_data={}, archived=False)

notionary/blocks/code/__init__.py

@@ -1,7 +1,11 @@
-from .code_element import CodeElement
-from .code_markdown_node import CodeMarkdownNode
+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",
 ]