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

notionary/blocks/toggle/toggle_element.py

@@ -1,303 +1,112 @@
+from __future__ import annotations
+
 import re
-from typing import Dict, Any, Optional, List, Tuple, Callable
+from typing import Optional
 
-from notionary.blocks import (
-    NotionBlockElement,
-    NotionBlockResult,
-    ElementPromptContent,
-    ElementPromptBuilder,
-)
+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.rich_text_models import RichTextObject
+from notionary.blocks.rich_text.text_inline_formatter import TextInlineFormatter
+from notionary.blocks.toggle.toggle_models import CreateToggleBlock, ToggleBlock
+from notionary.blocks.types import BlockColor
 
 
-class ToggleElement(NotionBlockElement):
+class ToggleElement(BaseBlockElement):
     """
-    Improved ToggleElement class using pipe syntax instead of indentation.
+    Simplified ToggleElement class that works with the stack-based converter.
+    Children are automatically handled by the StackBasedMarkdownConverter.
     """
 
-    TOGGLE_PATTERN = re.compile(r"^[+]{3}\s+(.+)$")
-    PIPE_CONTENT_PATTERN = re.compile(r"^\|\s?(.*)$")
-
-    TRANSCRIPT_TOGGLE_PATTERN = re.compile(r"^[+]{3}\s+Transcript$")
-
-    @classmethod
-    def match_markdown(cls, text: str) -> bool:
-        """Check if the text is a markdown toggle."""
-        return bool(ToggleElement.TOGGLE_PATTERN.match(text.strip()))
+    # Updated pattern for ultra-simplified +++ Title syntax (no quotes!)
+    TOGGLE_PATTERN = re.compile(r"^[+]{3}\s+(.+)$", re.IGNORECASE)
+    TRANSCRIPT_TOGGLE_PATTERN = re.compile(r"^[+]{3}\s+Transcript$", re.IGNORECASE)
 
     @classmethod
-    def match_notion(cls, block: Dict[str, Any]) -> bool:
+    def match_notion(cls, block: Block) -> bool:
         """Check if the block is a Notion toggle block."""
-        return block.get("type") == "toggle"
+        return block.type == BlockType.TOGGLE
 
     @classmethod
-    def markdown_to_notion(cls, text: str) -> NotionBlockResult:
-        """Convert markdown toggle line to Notion toggle block."""
-        toggle_match = ToggleElement.TOGGLE_PATTERN.match(text.strip())
-        if not toggle_match:
-            return None
-
-        # Extract toggle title
-        title = toggle_match.group(1)
-
-        return {
-            "type": "toggle",
-            "toggle": {
-                "rich_text": [{"type": "text", "text": {"content": title}}],
-                "color": "default",
-                "children": [],
-            },
-        }
-
-    @classmethod
-    def extract_nested_content(
-        cls, lines: List[str], start_index: int
-    ) -> Tuple[List[str], int]:
+    async def markdown_to_notion(cls, text: str) -> BlockCreateResult:
         """
-        Extracts the nested content lines of a toggle block using pipe syntax.
-
-        Args:
-            lines: All lines of text.
-            start_index: Starting index to look for nested content.
-
-        Returns:
-            Tuple of (nested_content_lines, next_line_index)
+        Convert markdown toggle line to Notion ToggleBlock.
+        Children are automatically handled by the StackBasedMarkdownConverter.
         """
-        nested_content = []
-        current_index = start_index
-
-        while current_index < len(lines):
-            current_line = lines[current_index]
-
-            # Case 1: Empty line - could be part of the content if next line is a pipe line
-            if not current_line.strip():
-                if ToggleElement.is_next_line_pipe_content(lines, current_index):
-                    nested_content.append("")
-                    current_index += 1
-                    continue
-                else:
-                    # Empty line not followed by pipe ends the block
-                    break
-
-            # Case 2: Pipe-prefixed line - part of the nested content
-            pipe_content = ToggleElement.extract_pipe_content(current_line)
-            if pipe_content is not None:
-                nested_content.append(pipe_content)
-                current_index += 1
-                continue
-
-            # Case 3: Regular line - end of nested content
-            break
+        if not (match := cls.TOGGLE_PATTERN.match(text.strip())):
+            return None
 
-        return nested_content, current_index
+        title = match.group(1).strip()
+        rich_text = await TextInlineFormatter.parse_inline_formatting(title)
 
-    @classmethod
-    def is_next_line_pipe_content(cls, lines: List[str], current_index: int) -> bool:
-        """Checks if the next line starts with a pipe prefix."""
-        next_index = current_index + 1
-        return (
-            next_index < len(lines)
-            and ToggleElement.PIPE_CONTENT_PATTERN.match(lines[next_index]) is not None
+        # Create toggle block with empty children - they will be populated automatically
+        toggle_content = ToggleBlock(
+            rich_text=rich_text, color=BlockColor.DEFAULT, children=[]
         )
 
-    @classmethod
-    def extract_pipe_content(cls, line: str) -> Optional[str]:
-        """
-        Extracts content from a line with pipe prefix.
-
-        Returns:
-            The content without the pipe, or None if not a pipe-prefixed line.
-        """
-        pipe_match = ToggleElement.PIPE_CONTENT_PATTERN.match(line)
-        if pipe_match:
-            return pipe_match.group(1)
-        return None
+        return CreateToggleBlock(toggle=toggle_content)
 
     @classmethod
-    def notion_to_markdown(cls, block: Dict[str, Any]) -> Optional[str]:
+    async def notion_to_markdown(cls, block: Block) -> Optional[str]:
         """
-        Converts a Notion toggle block into markdown using pipe-prefixed lines.
+        Converts a Notion toggle block into markdown using the ultra-simplified +++ syntax.
         """
-        if block.get("type") != "toggle":
+        if block.type != BlockType.TOGGLE:
+            return None
+
+        if not block.toggle:
             return None
 
-        toggle_data = block.get("toggle", {})
+        toggle_data = block.toggle
 
         # Extract title from rich_text
-        title = ToggleElement._extract_text_content(toggle_data.get("rich_text", []))
+        title = cls._extract_text_content(toggle_data.rich_text or [])
 
-        # Create toggle line
+        # Create toggle line with ultra-simplified syntax (no quotes!)
         toggle_line = f"+++ {title}"
 
         # Process children if available
-        children = toggle_data.get("children", [])
+        children = toggle_data.children or []
         if not children:
-            return toggle_line
-
-        # Add a placeholder line for each child using pipe syntax
-        child_lines = ["| [Nested content]" for _ in children]
+            return toggle_line + "\n+++"
 
-        return toggle_line + "\n" + "\n".join(child_lines)
+        # Add a placeholder line for each child
+        child_lines = ["[Nested content]" for _ in children]
 
-    @classmethod
-    def is_multiline(cls) -> bool:
-        """Toggle blocks can span multiple lines due to nested content."""
-        return True
+        return toggle_line + "\n" + "\n".join(child_lines) + "\n+++"
 
     @classmethod
-    def _extract_text_content(cls, rich_text: List[Dict[str, Any]]) -> str:
+    def _extract_text_content(cls, rich_text: list[RichTextObject]) -> str:
         """Extracts plain text content from Notion rich_text blocks."""
         result = ""
         for text_obj in rich_text:
-            if text_obj.get("type") == "text":
-                result += text_obj.get("text", {}).get("content", "")
-            elif "plain_text" in text_obj:
-                result += text_obj.get("plain_text", "")
-        return result
-
-    @classmethod
-    def find_matches(
-        cls,
-        text: str,
-        process_nested_content: Callable = None,
-        context_aware: bool = True,
-    ) -> List[Tuple[int, int, Dict[str, Any]]]:
-        """
-        Finds all toggle elements in markdown using pipe syntax for nested content.
-
-        Args:
-            text: The markdown input.
-            process_nested_content: Optional function to parse nested content into blocks.
-            context_aware: Whether to skip contextually irrelevant transcript toggles.
-
-        Returns:
-            List of (start_pos, end_pos, block) tuples.
-        """
-        if not text:
-            return []
-
-        toggle_blocks = []
-        lines = text.split("\n")
-        current_line_index = 0
-
-        while current_line_index < len(lines):
-            current_line = lines[current_line_index]
-
-            # Check if the current line is a toggle
-            if not cls._is_toggle_line(current_line):
-                current_line_index += 1
-                continue
-
-            # Skip transcript toggles if required by context
-            if cls._should_skip_transcript_toggle(
-                current_line, lines, current_line_index, context_aware
+            if hasattr(text_obj, "plain_text"):
+                result += text_obj.plain_text or ""
+            elif (
+                hasattr(text_obj, "type")
+                and text_obj.type == "text"
+                and hasattr(text_obj, "text")
             ):
-                current_line_index += 1
-                continue
-
-            # Create toggle block and determine character positions
-            start_position = cls._calculate_start_position(lines, current_line_index)
-            toggle_block = cls.markdown_to_notion(current_line)
-
-            if not toggle_block:
-                current_line_index += 1
-                continue
-
-            # Extract nested content
-            nested_content, next_line_index = cls.extract_nested_content(
-                lines, current_line_index + 1
-            )
-            end_position = cls._calculate_end_position(
-                start_position, current_line, nested_content
-            )
-
-            # Process nested content if needed
-            cls._process_nested_content_if_needed(
-                nested_content, process_nested_content, toggle_block
-            )
-
-            # Save result
-            toggle_blocks.append((start_position, end_position, toggle_block))
-            current_line_index = next_line_index
-
-        return toggle_blocks
-
-    @classmethod
-    def _is_toggle_line(cls, line: str) -> bool:
-        """Checks whether the given line is a markdown toggle."""
-        return bool(ToggleElement.TOGGLE_PATTERN.match(line.strip()))
-
-    @classmethod
-    def _should_skip_transcript_toggle(
-        cls, line: str, lines: List[str], current_index: int, context_aware: bool
-    ) -> bool:
-        """Determines if a transcript toggle should be skipped based on the surrounding context."""
-        is_transcript_toggle = cls.TRANSCRIPT_TOGGLE_PATTERN.match(line.strip())
-
-        if not (context_aware and is_transcript_toggle):
-            return False
-
-        # Only keep transcript toggles that follow a list item
-        has_list_item_before = current_index > 0 and lines[
-            current_index - 1
-        ].strip().startswith("- ")
-        return not has_list_item_before
-
-    @classmethod
-    def _calculate_start_position(cls, lines: List[str], current_index: int) -> int:
-        """Calculates the character start position of a line within the full text."""
-        start_pos = 0
-        for index in range(current_index):
-            start_pos += len(lines[index]) + 1  # +1 for line break
-        return start_pos
-
-    @classmethod
-    def _calculate_end_position(
-        cls, start_pos: int, current_line: str, nested_content: List[str]
-    ) -> int:
-        """Calculates the end position of a toggle block including nested lines."""
-        line_length = len(current_line)
-        nested_content_length = sum(
-            len(line) + 1 for line in nested_content
-        )  # +1 for each line break
-        return start_pos + line_length + nested_content_length
+                result += text_obj.text.content or ""
+            # Fallback for dict-style access (backward compatibility)
+            elif isinstance(text_obj, dict):
+                if text_obj.get("type") == "text":
+                    result += text_obj.get("text", {}).get("content", "")
+                elif "plain_text" in text_obj:
+                    result += text_obj.get("plain_text", "")
+        return result
 
     @classmethod
-    def _process_nested_content_if_needed(
-        cls,
-        nested_content: List[str],
-        process_function: Optional[Callable],
-        toggle_block: Dict[str, Any],
-    ) -> None:
-        """Processes nested content using the provided function if applicable."""
-        if not (nested_content and process_function):
-            return
-
-        nested_text = "\n".join(nested_content)
-        nested_blocks = process_function(nested_text)
-
-        if nested_blocks:
-            toggle_block["toggle"]["children"] = nested_blocks
-
     @classmethod
-    def get_llm_prompt_content(cls) -> ElementPromptContent:
-        """
-        Returns structured LLM prompt metadata for the toggle element with pipe syntax examples.
-        """
-        return (
-            ElementPromptBuilder()
-            .with_description(
-                "Toggle elements are collapsible sections that help organize and hide detailed information."
-            )
-            .with_usage_guidelines(
-                "Use toggles for supplementary information that's not essential for the first reading, "
-                "such as details, examples, or technical information."
-            )
-            .with_syntax("+++ Toggle Title\n| Toggle content with pipe prefix")
-            .with_examples(
-                [
-                    "+++ Key Findings\n| The research demonstrates **three main conclusions**:\n| 1. First important point\n| 2. Second important point",
-                    "+++ FAQ\n| **Q: When should I use toggles?**\n| *A: Use toggles for supplementary information.*",
-                ]
-            )
-            .build()
+    def get_system_prompt_information(cls) -> Optional[BlockElementMarkdownInformation]:
+        """Get system prompt information for toggle blocks."""
+        return BlockElementMarkdownInformation(
+            block_type=cls.__name__,
+            description="Toggle blocks create collapsible sections with expandable content",
+            syntax_examples=[
+                "+++Title\nContent goes here\n+++",
+                "+++Details\nMore information\nAdditional content\n+++",
+                "+++FAQ\nFrequently asked questions\n+++",
+            ],
+            usage_guidelines="Use for collapsible content sections. Start with +++Title, add content, end with +++. Great for FAQs, details, or organizing long content.",
         )

notionary/blocks/toggle/toggle_markdown_node.py

@@ -1,35 +1,45 @@
 from __future__ import annotations
 
-from typing import Optional, List
 from pydantic import BaseModel
-from notionary.blocks.markdown_node import MarkdownNode
+
+from notionary.markdown.markdown_node import MarkdownNode
 
 
 class ToggleMarkdownBlockParams(BaseModel):
     title: str
-    content: Optional[List[str]] = None
+    children: list[MarkdownNode]
+    model_config = {"arbitrary_types_allowed": True}
 
 
 class ToggleMarkdownNode(MarkdownNode):
     """
-    Programmatic interface for creating Notion-style Markdown toggle blocks
-    with pipe-prefixed nested content.
+    Clean programmatic interface for creating Notion-style Markdown toggle blocks
+    with the simplified +++ "Title" syntax.
+
     Example:
-        +++ Details
-        | Here are the details.
-        | You can add more lines.
+        +++ "Advanced Details"
+        Content here
+        More content
+        +++
     """
 
-    def __init__(self, title: str, content: Optional[List[str]] = None):
+    def __init__(self, title: str, children: list[MarkdownNode]):
         self.title = title
-        self.content = content or []
+        self.children = children
 
     @classmethod
     def from_params(cls, params: ToggleMarkdownBlockParams) -> ToggleMarkdownNode:
-        return cls(title=params.title, content=params.content)
+        return cls(title=params.title, children=params.children)
 
     def to_markdown(self) -> str:
-        result = f"+++ {self.title}"
-        if self.content:
-            result += "\n" + "\n".join([f"| {line}" for line in self.content])
-        return result
+        result = f"+++{self.title}"
+
+        if not self.children:
+            result += "\n+++"
+            return result
+
+        # Convert children to markdown
+        content_parts = [child.to_markdown() for child in self.children]
+        content_text = "\n\n".join(content_parts)
+
+        return result + "\n" + content_text + "\n+++"

notionary/blocks/toggle/toggle_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 ToggleBlock(BaseModel):
+    rich_text: list[RichTextObject]
+    color: BlockColor = BlockColor.DEFAULT
+    children: list[Block] = Field(default_factory=list)
+
+
+class CreateToggleBlock(BaseModel):
+    type: Literal["toggle"] = "toggle"
+    toggle: ToggleBlock

notionary/blocks/toggleable_heading/__init__.py

@@ -1,9 +1,13 @@
-from .toggleable_heading_element import ToggleableHeadingElement
-from .toggleable_heading_markdown_node import (
+from notionary.blocks.toggleable_heading.toggleable_heading_element import (
+    ToggleableHeadingElement,
+)
+from notionary.blocks.toggleable_heading.toggleable_heading_markdown_node import (
+    ToggleableHeadingMarkdownBlockParams,
     ToggleableHeadingMarkdownNode,
 )
 
 __all__ = [
     "ToggleableHeadingElement",
     "ToggleableHeadingMarkdownNode",
+    "ToggleableHeadingMarkdownBlockParams",
 ]