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

notionary/blocks/table_of_contents/table_of_contents_element.py

@@ -0,0 +1,68 @@
+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
+from notionary.blocks.table_of_contents.table_of_contents_models import (
+    CreateTableOfContentsBlock,
+    TableOfContentsBlock,
+)
+from notionary.blocks.types import BlockType
+
+
+class TableOfContentsElement(BaseBlockElement):
+    """
+    Handles conversion between Markdown [toc] syntax and Notion table_of_contents blocks.
+
+    Markdown syntax:
+    - [toc]                        → default color
+    - [toc](blue)                  → custom color
+    - [toc](blue_background)       → custom background color
+    """
+
+    PATTERN = re.compile(r"^\[toc\](?:\((?P<color>[a-z_]+)\))?$", re.IGNORECASE)
+
+    @classmethod
+    def match_notion(cls, block: Block) -> bool:
+        return block.type == BlockType.TABLE_OF_CONTENTS and block.table_of_contents
+
+    @classmethod
+    async def markdown_to_notion(cls, text: str) -> BlockCreateResult:
+        if not (input_match := cls.PATTERN.match(text.strip())):
+            return None
+
+        color = (input_match.group("color") or "default").lower()
+        return CreateTableOfContentsBlock(
+            table_of_contents=TableOfContentsBlock(color=color)
+        )
+
+    @classmethod
+    async def notion_to_markdown(cls, block: Block) -> Optional[str]:
+        # Fix: Use 'or' instead of 'and'
+        if block.type != BlockType.TABLE_OF_CONTENTS or not block.table_of_contents:
+            return None
+
+        color = block.table_of_contents.color.value
+
+        if color == "default":
+            return "[toc]"
+        return f"[toc]({color})"
+
+    @classmethod
+    @classmethod
+    def get_system_prompt_information(cls) -> Optional[BlockElementMarkdownInformation]:
+        """Get system prompt information for table of contents blocks."""
+        return BlockElementMarkdownInformation(
+            block_type=cls.__name__,
+            description="Table of contents blocks automatically generate navigation for page headings",
+            syntax_examples=[
+                "[toc]",
+                "[toc](blue)",
+                "[toc](blue_background)",
+                "[toc](gray_background)",
+            ],
+            usage_guidelines="Use to automatically generate a clickable table of contents from page headings. Optional color parameter changes the appearance. Default color is gray.",
+        )

notionary/blocks/table_of_contents/table_of_contents_markdown_node.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+from notionary.markdown.markdown_node import MarkdownNode
+
+
+class TableOfContentsMarkdownBlockParams(BaseModel):
+    color: Optional[str] = "default"
+
+
+class TableOfContentsMarkdownNode(MarkdownNode):
+    """
+    Programmatic interface for creating Markdown table of contents blocks.
+    Example:
+    [toc]
+    [toc](blue)
+    [toc](blue_background)
+    """
+
+    def __init__(self, color: Optional[str] = "default"):
+        self.color = color or "default"
+
+    @classmethod
+    def from_params(
+        cls, params: TableOfContentsMarkdownBlockParams
+    ) -> TableOfContentsMarkdownNode:
+        return cls(color=params.color)
+
+    def to_markdown(self) -> str:
+        if self.color == "default":
+            return "[toc]"
+        return f"[toc]({self.color})"

notionary/blocks/table_of_contents/table_of_contents_models.py

@@ -0,0 +1,18 @@
+from typing import Literal
+
+from pydantic import BaseModel
+
+from notionary.blocks.types import BlockColor
+
+
+class TableOfContentsBlock(BaseModel):
+    """Inneres Payload-Objekt: { table_of_contents: { color: ... } }"""
+
+    color: BlockColor = BlockColor.DEFAULT
+
+
+class CreateTableOfContentsBlock(BaseModel):
+    """Create-Payload für den Block: { type: 'table_of_contents', table_of_contents: {...} }"""
+
+    type: Literal["table_of_contents"] = "table_of_contents"
+    table_of_contents: TableOfContentsBlock

notionary/blocks/todo/__init__.py

@@ -1,7 +1,14 @@
-from .todo_element import TodoElement
-from .todo_markdown_node import TodoMarkdownNode
+from notionary.blocks.todo.todo_element import TodoElement
+from notionary.blocks.todo.todo_markdown_node import (
+    TodoMarkdownBlockParams,
+    TodoMarkdownNode,
+)
+from notionary.blocks.todo.todo_models import CreateToDoBlock, ToDoBlock
 
 __all__ = [
     "TodoElement",
+    "ToDoBlock",
+    "CreateToDoBlock",
     "TodoMarkdownNode",
+    "TodoMarkdownBlockParams",
 ]

notionary/blocks/todo/todo_element.py

@@ -1,16 +1,16 @@
+from __future__ import annotations
+
 import re
-from typing import Dict, Any, Optional
+from typing import TYPE_CHECKING, Optional
 
-from notionary.blocks import (
-    ElementPromptContent,
-    ElementPromptBuilder,
-    NotionBlockResult,
-    NotionBlockElement,
-)
-from notionary.blocks.shared.text_inline_formatter import TextInlineFormatter
+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.blocks.rich_text.text_inline_formatter import TextInlineFormatter
+from notionary.blocks.todo.todo_models import CreateToDoBlock, ToDoBlock
 
 
-class TodoElement(NotionBlockElement):
+class TodoElement(BaseBlockElement):
     """
     Handles conversion between Markdown todo items and Notion to_do blocks.
 
@@ -21,101 +21,61 @@ class TodoElement(NotionBlockElement):
     + [ ] Also works with plus sign
     """
 
-    # Patterns for detecting Markdown todo items
-    TODO_PATTERN = re.compile(r"^\s*[-*+]\s+\[\s?\]\s+(.+)$")
-    DONE_PATTERN = re.compile(r"^\s*[-*+]\s+\[x\]\s+(.+)$")
-
-    @classmethod
-    def match_markdown(cls, text: str) -> bool:
-        """Check if text is a markdown todo item."""
-        return bool(
-            TodoElement.TODO_PATTERN.match(text) or TodoElement.DONE_PATTERN.match(text)
-        )
+    PATTERN = re.compile(r"^\s*[-*+]\s+\[ \]\s+(.+)$")
+    DONE_PATTERN = re.compile(r"^\s*[-*+]\s+\[x\]\s+(.+)$", re.IGNORECASE)
 
     @classmethod
-    def match_notion(cls, block: Dict[str, Any]) -> bool:
-        """Check if block is a Notion to_do block."""
-        return block.get("type") == "to_do"
+    def match_notion(cls, block: Block) -> bool:
+        return block.type == BlockType.TO_DO and block.to_do
 
     @classmethod
-    def markdown_to_notion(cls, text: str) -> NotionBlockResult:
-        """Convert markdown todo item to Notion to_do block."""
-        done_match = TodoElement.DONE_PATTERN.match(text)
-        if done_match:
-            content = done_match.group(1)
-            return TodoElement._create_todo_block(content, True)
+    async def markdown_to_notion(cls, text: str) -> BlockCreateResult:
+        """Convert markdown todo or done item to Notion to_do block."""
+        m_done = cls.DONE_PATTERN.match(text)
+        m_todo = None if m_done else cls.PATTERN.match(text)
+
+        if m_done:
+            content = m_done.group(1)
+            checked = True
+        elif m_todo:
+            content = m_todo.group(1)
+            checked = False
+        else:
+            return None
 
-        todo_match = TodoElement.TODO_PATTERN.match(text)
-        if todo_match:
-            content = todo_match.group(1)
-            return TodoElement._create_todo_block(content, False)
+        # build rich text
+        rich = await TextInlineFormatter.parse_inline_formatting(content)
 
-        return None
+        todo_content = ToDoBlock(
+            rich_text=rich,
+            checked=checked,
+            color="default",
+        )
+        return CreateToDoBlock(to_do=todo_content)
 
     @classmethod
-    def notion_to_markdown(cls, block: Dict[str, Any]) -> Optional[str]:
+    async def notion_to_markdown(cls, block: Block) -> Optional[str]:
         """Convert Notion to_do block to markdown todo item."""
-        if block.get("type") != "to_do":
+        if block.type != BlockType.TO_DO or not block.to_do:
             return None
 
-        todo_data = block.get("to_do", {})
-        checked = todo_data.get("checked", False)
-
-        # Extract text content
-        rich_text = todo_data.get("rich_text", [])
-        content = TextInlineFormatter.extract_text_with_formatting(rich_text)
-
-        # Format as markdown todo item
-        checkbox = "[x]" if checked else "[ ]"
+        td = block.to_do
+        content = await TextInlineFormatter.extract_text_with_formatting(td.rich_text)
+        checkbox = "[x]" if td.checked else "[ ]"
         return f"- {checkbox} {content}"
 
     @classmethod
-    def _create_todo_block(cls, content: str, checked: bool) -> Dict[str, Any]:
-        """
-        Create a Notion to_do block.
-
-        Args:
-            content: The text content of the todo item
-            checked: Whether the todo item is checked
-
-        Returns:
-            Notion to_do block dictionary
-        """
-        return {
-            "type": "to_do",
-            "to_do": {
-                "rich_text": TextInlineFormatter.parse_inline_formatting(content),
-                "checked": checked,
-                "color": "default",
-            },
-        }
-
-    @classmethod
-    def is_multiline(cls) -> bool:
-        return False
-
-    @classmethod
-    def get_llm_prompt_content(cls) -> ElementPromptContent:
-        """
-        Returns structured LLM prompt metadata for the todo element.
-        """
-        return (
-            ElementPromptBuilder()
-            .with_description(
-                "Creates interactive to-do items with checkboxes that can be marked as complete."
-            )
-            .with_usage_guidelines(
-                "Use to-do items for task lists, checklists, or tracking progress on items that need to be completed. "
-                "Todo items are interactive in Notion and can be checked/unchecked directly."
-            )
-            .with_syntax("- [ ] Task to complete")
-            .with_examples(
-                [
-                    "- [ ] Draft project proposal",
-                    "- [x] Create initial timeline",
-                    "* [ ] Review code changes",
-                    "+ [x] Finalize handoff checklist",
-                ]
-            )
-            .build()
+    def get_system_prompt_information(cls) -> Optional[BlockElementMarkdownInformation]:
+        """Get system prompt information for todo blocks."""
+        return BlockElementMarkdownInformation(
+            block_type=cls.__name__,
+            description="Todo blocks create interactive checkboxes for task management",
+            syntax_examples=[
+                "- [ ] Unchecked todo item",
+                "- [x] Checked todo item",
+                "* [ ] Todo with asterisk",
+                "+ [ ] Todo with plus sign",
+                "- [x] Completed task",
+            ],
+            usage_guidelines="Use for task lists and checkboxes. [ ] for unchecked, [x] for checked items. Supports -, *, or + as bullet markers. Interactive in Notion interface.",
         )

notionary/blocks/todo/todo_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 TodoMarkdownBlockParams(BaseModel):

notionary/blocks/todo/todo_models.py

@@ -0,0 +1,19 @@
+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 ToDoBlock(BaseModel):
+    rich_text: list[RichTextObject]
+    checked: bool = False
+    color: BlockColor = BlockColor.DEFAULT
+    children: list[Block] = Field(default_factory=list)
+
+
+class CreateToDoBlock(BaseModel):
+    type: Literal["to_do"] = "to_do"
+    to_do: ToDoBlock

notionary/blocks/toggle/__init__.py

@@ -1,4 +1,14 @@
-from .toggle_element import ToggleElement
-from .toggle_markdown_node import ToggleMarkdownNode, ToggleMarkdownBlockParams
+from notionary.blocks.toggle.toggle_element import ToggleElement
+from notionary.blocks.toggle.toggle_markdown_node import (
+    ToggleMarkdownBlockParams,
+    ToggleMarkdownNode,
+)
+from notionary.blocks.toggle.toggle_models import CreateToggleBlock, ToggleBlock
 
-__all__ = ["ToggleElement", "ToggleMarkdownNode", "ToggleMarkdownBlockParams"]
+__all__ = [
+    "ToggleElement",
+    "ToggleBlock",
+    "CreateToggleBlock",
+    "ToggleMarkdownNode",
+    "ToggleMarkdownBlockParams",
+]