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

notionary/blocks/toggleable_heading/toggleable_heading_element.py

@@ -1,270 +1,100 @@
-import re
-from typing import Dict, Any, Optional, List, Tuple, Callable
+from __future__ import annotations
 
-from notionary.blocks import (
-    ElementPromptContent,
-    ElementPromptBuilder,
-    NotionBlockElement,
-    NotionBlockResult,
+import re
+from typing import Optional
+
+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
 
 
-class ToggleableHeadingElement(NotionBlockElement):
-    """Handles conversion between Markdown collapsible headings and Notion toggleable heading blocks with pipe syntax."""
+class ToggleableHeadingElement(BaseBlockElement):
+    """
+    Simplified ToggleableHeadingElement that works with the stack-based converter.
+    Children are automatically handled by the StackBasedMarkdownConverter.
+    """
 
-    PATTERN = re.compile(r"^\+(?P<level>#{1,3})\s+(?P<content>.+)$")
-    PIPE_CONTENT_PATTERN = re.compile(r"^\|\s?(.*)$")
-
-    @staticmethod
-    def match_markdown(text: str) -> bool:
-        """Check if text is a markdown collapsible heading."""
-        return bool(ToggleableHeadingElement.PATTERN.match(text))
+    # Updated pattern for simplified +++# Title syntax (no quotes!)
+    PATTERN = re.compile(r"^[+]{3}(?P<level>#{1,3})\s+(.+)$", re.IGNORECASE)
 
     @staticmethod
-    def match_notion(block: Dict[str, Any]) -> bool:
+    def match_notion(block: Block) -> bool:
         """Check if block is a Notion toggleable heading."""
-        block_type: str = block.get("type", "")
-        if not block_type.startswith("heading_") or block_type[-1] not in "123":
+        # Use BlockType enum for matching heading blocks
+        if block.type not in (
+            BlockType.HEADING_1,
+            BlockType.HEADING_2,
+            BlockType.HEADING_3,
+        ):
             return False
 
-        # Check if it has the is_toggleable property set to true
-        heading_data = block.get(block_type, {})
-        return heading_data.get("is_toggleable", False) is True
-
-    @staticmethod
-    def markdown_to_notion(text: str) -> NotionBlockResult:
-        """Convert markdown collapsible heading to Notion toggleable heading block."""
-        header_match = ToggleableHeadingElement.PATTERN.match(text)
-        if not header_match:
-            return None
-
-        level = len(header_match.group(1))
-        content = header_match.group(2)
-
-        return {
-            "type": f"heading_{level}",
-            f"heading_{level}": {
-                "rich_text": TextInlineFormatter.parse_inline_formatting(content),
-                "is_toggleable": True,
-                "color": "default",
-                "children": [],  # Will be populated with nested content if needed
-            },
-        }
-
-    @staticmethod
-    def notion_to_markdown(block: Dict[str, Any]) -> Optional[str]:
-        """Convert Notion toggleable heading block to markdown collapsible heading with pipe syntax."""
-        block_type = block.get("type", "")
-
-        if not block_type.startswith("heading_"):
-            return None
-
-        try:
-            level = int(block_type[-1])
-            if not 1 <= level <= 3:
-                return None
-        except ValueError:
-            return None
-
-        heading_data = block.get(block_type, {})
-
-        # Check if it's toggleable
-        if not heading_data.get("is_toggleable", False):
-            return None
-
-        rich_text = heading_data.get("rich_text", [])
-        text = TextInlineFormatter.extract_text_with_formatting(rich_text)
-        prefix = "#" * level
-        return f"+{prefix} {text or ''}"
-
-    @staticmethod
-    def is_multiline() -> bool:
-        """Collapsible headings can have children, so they're multiline elements."""
-        return True
+        if block.heading_1 and block.heading_1.is_toggleable:
+            return True
+        if block.heading_2 and block.heading_2.is_toggleable:
+            return True
+        if block.heading_3 and block.heading_3.is_toggleable:
+            return True
 
     @classmethod
-    def find_matches(
-        cls,
-        text: str,
-        process_nested_content: Callable = None,
-        context_aware: bool = True,
-    ) -> List[Tuple[int, int, Dict[str, Any]]]:
+    def markdown_to_notion(cls, text: str) -> BlockCreateResult:
         """
-        Find all collapsible heading matches in the text with pipe syntax for nested content.
-        Improved version with reduced cognitive complexity.
-
-        Args:
-            text: The text to process
-            process_nested_content: Optional callback function to process nested content
-            context_aware: Whether to consider context when finding collapsible headings
-
-        Returns:
-            List of (start_pos, end_pos, block) tuples
+        Convert markdown collapsible heading to a toggleable Notion HeadingBlock.
+        Children are automatically handled by the StackBasedMarkdownConverter.
         """
-        if not text:
-            return []
-
-        collapsible_blocks = []
-        lines = text.split("\n")
-        line_index = 0
-
-        while line_index < len(lines):
-            current_line = lines[line_index]
-
-            # Skip non-collapsible heading lines
-            if not cls._is_collapsible_heading(current_line):
-                line_index += 1
-                continue
-
-            # Process collapsible heading
-            start_position = cls._calculate_line_position(lines, line_index)
-            heading_block = cls.markdown_to_notion(current_line)
-
-            if not heading_block:
-                line_index += 1
-                continue
+        if not (match := cls.PATTERN.match(text.strip())):
+            return None
 
-            # Extract and process nested content
-            nested_content, next_line_index = cls._extract_nested_content(
-                lines, line_index + 1
-            )
-            end_position = cls._calculate_block_end_position(
-                start_position, current_line, nested_content
-            )
+        level = len(match.group("level"))  # Count # characters
+        content = match.group(2).strip()  # group(2) is the title (no quotes needed)
 
-            cls._process_nested_content(
-                heading_block, nested_content, process_nested_content
-            )
+        if level < 1 or level > 3 or not content:
+            return None
 
-            # Add block to results
-            collapsible_blocks.append((start_position, end_position, heading_block))
-            line_index = next_line_index
+        rich_text = TextInlineFormatter.parse_inline_formatting(content)
 
-        return collapsible_blocks
+        heading_content = HeadingBlock(
+            rich_text=rich_text, color="default", is_toggleable=True, children=[]
+        )
 
-    @classmethod
-    def _is_collapsible_heading(cls, line: str) -> bool:
-        """Check if a line represents a collapsible heading."""
-        return bool(cls.PATTERN.match(line))
+        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)
 
     @staticmethod
-    def _calculate_line_position(lines: List[str], current_index: int) -> int:
-        """Calculate the character position of a line in the text."""
-        position = 0
-        for i in range(current_index):
-            position += len(lines[i]) + 1  # +1 for newline
-        return position
-
-    @classmethod
-    def _extract_nested_content(
-        cls, lines: List[str], start_index: int
-    ) -> Tuple[List[str], int]:
-        """
-        Extract nested content with pipe syntax from lines following a collapsible heading.
-
-        Args:
-            lines: All text lines
-            start_index: Index to start looking for nested content
-
-        Returns:
-            Tuple of (nested_content, next_line_index)
-        """
-        nested_content = []
-        current_index = start_index
-
-        while current_index < len(lines):
-            current_line = lines[current_index]
-
-            # Case 1: Empty line - check if it's followed by pipe content
-            if not current_line.strip():
-                if cls._is_next_line_pipe_content(lines, current_index):
-                    nested_content.append("")
-                    current_index += 1
-                    continue
-
-            # Case 2: Pipe content line - part of nested content
-            pipe_content = cls._extract_pipe_content(current_line)
-            if pipe_content is not None:
-                nested_content.append(pipe_content)
-                current_index += 1
-                continue
-
-            # Case 3: Another collapsible heading - ends current heading's content
-            if cls.PATTERN.match(current_line):
-                break
-
-            # Case 4: Any other line - ends nested content
-            break
-
-        return nested_content, current_index
-
-    @classmethod
-    def _is_next_line_pipe_content(cls, lines: List[str], current_index: int) -> bool:
-        """Check if the next line uses pipe syntax for nested content."""
-        next_index = current_index + 1
-        if next_index >= len(lines):
-            return False
-        return bool(cls.PIPE_CONTENT_PATTERN.match(lines[next_index]))
-
-    @classmethod
-    def _extract_pipe_content(cls, line: str) -> Optional[str]:
-        """Extract content from a line with pipe prefix."""
-        pipe_match = cls.PIPE_CONTENT_PATTERN.match(line)
-        if not pipe_match:
+    def notion_to_markdown(block: Block) -> Optional[str]:
+        """Convert Notion toggleable heading block to markdown collapsible heading."""
+        # Only handle heading blocks via BlockType enum
+        if block.type not in (
+            BlockType.HEADING_1,
+            BlockType.HEADING_2,
+            BlockType.HEADING_3,
+        ):
             return None
-        return pipe_match.group(1)
-
-    @staticmethod
-    def _calculate_block_end_position(
-        start_position: int, heading_line: str, nested_content: List[str]
-    ) -> int:
-        """Calculate the end position of a collapsible heading block including nested content."""
-        block_length = len(heading_line)
-        if nested_content:
-            # Add length of each nested content line plus newline
-            nested_length = sum(len(line) + 1 for line in nested_content)
-            block_length += nested_length
-        return start_position + block_length
 
-    @classmethod
-    def _process_nested_content(
-        cls,
-        heading_block: Dict[str, Any],
-        nested_content: List[str],
-        processor: Optional[Callable],
-    ) -> None:
-        """Process nested content with the provided callback function if available."""
-        if not (nested_content and processor):
-            return
+        # Determine heading level from enum
+        if block.type == BlockType.HEADING_1:
+            level = 1
+        elif block.type == BlockType.HEADING_2:
+            level = 2
+        else:
+            level = 3
 
-        nested_text = "\n".join(nested_content)
-        nested_blocks = processor(nested_text)
-
-        if nested_blocks:
-            block_type = heading_block["type"]
-            heading_block[block_type]["children"] = nested_blocks
+        heading_content = getattr(block, block.type.value)
+        if not isinstance(heading_content, HeadingBlock):
+            return None
 
-    @classmethod
-    def get_llm_prompt_content(cls) -> ElementPromptContent:
-        """
-        Returns structured LLM prompt metadata for the collapsible heading element with pipe syntax.
-        """
-        return (
-            ElementPromptBuilder()
-            .with_description(
-                "Collapsible headings combine heading structure with toggleable visibility."
-            )
-            .with_usage_guidelines(
-                "Use when you want to create a structured section that can be expanded or collapsed."
-            )
-            .with_syntax("+# Collapsible Heading\n| Content with pipe prefix")
-            .with_examples(
-                [
-                    "+# Main Collapsible Section\n| Content under the section",
-                    "+## Subsection\n| This content is hidden until expanded",
-                    "+### Detailed Information\n| Technical details go here",
-                ]
-            )
-            .build()
+        text = TextInlineFormatter.extract_text_with_formatting(
+            heading_content.rich_text
         )
+        prefix = "#" * level
+
+        return f'+++{prefix} {text or ""}'

notionary/blocks/toggleable_heading/toggleable_heading_markdown_node.py

@@ -1,43 +1,51 @@
 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 ToggleableHeadingMarkdownBlockParams(BaseModel):
     text: str
-    level: int = 1
-    content: Optional[List[str]] = None
+    level: int
+    children: list[MarkdownNode]
+    model_config = {"arbitrary_types_allowed": True}
 
 
 class ToggleableHeadingMarkdownNode(MarkdownNode):
     """
-    Programmatic interface for creating collapsible Markdown headings (toggleable headings).
-    Pipe-prefixed lines are used for the collapsible content.
-    Example:
-        +# Section
-        | Hidden content
-        +## Subsection
-        | Details
+    Clean programmatic interface for creating collapsible Markdown headings (toggleable headings)
+    with pipe-prefixed nested content using MarkdownNode children.
+
+    Example syntax for a level-2 toggleable heading:
+        +++## Advanced Section
+        some content
+        +++
     """
 
-    def __init__(self, text: str, level: int = 1, content: Optional[list[str]] = None):
+    def __init__(self, text: str, level: int, children: list[MarkdownNode]):
         if not (1 <= level <= 3):
             raise ValueError("Only heading levels 1-3 are supported (H1, H2, H3)")
         self.text = text
         self.level = level
-        self.content = content or []
+        self.children = children
 
     @classmethod
     def from_params(
         cls, params: ToggleableHeadingMarkdownBlockParams
     ) -> ToggleableHeadingMarkdownNode:
-        return cls(text=params.text, level=params.level, content=params.content)
+        return cls(text=params.text, level=params.level, children=params.children)
 
     def to_markdown(self) -> str:
-        prefix = "+" + ("#" * self.level)
+        prefix = "+++" + ("#" * self.level)
         result = f"{prefix} {self.text}"
-        if self.content:
-            result += "\n" + "\n".join([f"| {line}" for line in self.content])
-        return result
+
+        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/types.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from enum import Enum
+
+
+class BlockColor(str, Enum):
+    BLUE = "blue"
+    BLUE_BACKGROUND = "blue_background"
+    BROWN = "brown"
+    BROWN_BACKGROUND = "brown_background"
+    DEFAULT = "default"
+    GRAY = "gray"
+    GRAY_BACKGROUND = "gray_background"
+    GREEN = "green"
+    GREEN_BACKGROUND = "green_background"
+    ORANGE = "orange"
+    ORANGE_BACKGROUND = "orange_background"
+    YELLOW = "yellow"
+    YELLOW_BACKGROUND = "yellow_background"
+    PINK = "pink"
+    PINK_BACKGROUND = "pink_background"
+    PURPLE = "purple"
+    PURPLE_BACKGROUND = "purple_background"
+    RED = "red"
+    RED_BACKGROUND = "red_background"
+    DEFAULT_BACKGROUND = "default_background"
+
+
+class BlockType(str, Enum):
+    BOOKMARK = "bookmark"
+    BREADCRUMB = "breadcrumb"
+    BULLETED_LIST_ITEM = "bulleted_list_item"
+    CALLOUT = "callout"
+    CHILD_DATABASE = "child_database"
+    CHILD_PAGE = "child_page"
+    COLUMN = "column"
+    COLUMN_LIST = "column_list"
+    CODE = "code"
+    DIVIDER = "divider"
+    EMBED = "embed"
+    EQUATION = "equation"
+    FILE = "file"
+    HEADING_1 = "heading_1"
+    HEADING_2 = "heading_2"
+    HEADING_3 = "heading_3"
+    IMAGE = "image"
+    LINK_PREVIEW = "link_preview"
+    LINK_TO_PAGE = "link_to_page"
+    NUMBERED_LIST_ITEM = "numbered_list_item"
+    PARAGRAPH = "paragraph"
+    PDF = "pdf"
+    QUOTE = "quote"
+    SYNCED_BLOCK = "synced_block"
+    TABLE = "table"
+    TABLE_OF_CONTENTS = "table_of_contents"
+    TABLE_ROW = "table_row"
+    TO_DO = "to_do"
+    TOGGLE = "toggle"
+    UNSUPPORTED = "unsupported"
+    VIDEO = "video"
+    AUDIO = "audio"

notionary/blocks/video/__init__.py

@@ -1,7 +1,13 @@
-from .video_element import VideoElement
-from .video_markdown_node import VideoMarkdownNode
+from notionary.blocks.video.video_element import VideoElement
+from notionary.blocks.video.video_element_models import CreateVideoBlock
+from notionary.blocks.video.video_markdown_node import (
+    VideoMarkdownBlockParams,
+    VideoMarkdownNode,
+)
 
 __all__ = [
     "VideoElement",
+    "CreateVideoBlock",
     "VideoMarkdownNode",
+    "VideoMarkdownBlockParams",
 ]