notionary 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

notionary/core/converters/elements/todo_lists.py

@@ -0,0 +1,114 @@
+import re
+from typing import Dict, Any, Optional
+from typing_extensions import override
+from notionary.core.converters.elements.notion_block_element import NotionBlockElement
+from notionary.core.converters.elements.text_inline_formatter import TextInlineFormatter
+
+
+class TodoElement(NotionBlockElement):
+    """
+    Handles conversion between Markdown todo items and Notion to_do blocks.
+
+    Markdown syntax examples:
+    - [ ] Unchecked todo item
+    - [x] Checked todo item
+    * [ ] Also works with asterisk
+    + [ ] 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+(.+)$")
+
+    @override
+    @staticmethod
+    def match_markdown(text: str) -> bool:
+        """Check if text is a markdown todo item."""
+        return bool(
+            TodoElement.TODO_PATTERN.match(text) or TodoElement.DONE_PATTERN.match(text)
+        )
+
+    @override
+    @staticmethod
+    def match_notion(block: Dict[str, Any]) -> bool:
+        """Check if block is a Notion to_do block."""
+        return block.get("type") == "to_do"
+
+    @override
+    @staticmethod
+    def markdown_to_notion(text: str) -> Optional[Dict[str, Any]]:
+        """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)
+
+        todo_match = TodoElement.TODO_PATTERN.match(text)
+        if todo_match:
+            content = todo_match.group(1)
+            return TodoElement._create_todo_block(content, False)
+
+        return None
+
+    @override
+    @staticmethod
+    def notion_to_markdown(block: Dict[str, Any]) -> Optional[str]:
+        """Convert Notion to_do block to markdown todo item."""
+        if block.get("type") != "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 "[ ]"
+        return f"- {checkbox} {content}"
+
+    @staticmethod
+    def _create_todo_block(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",
+            },
+        }
+
+    @override
+    @staticmethod
+    def is_multiline() -> bool:
+        return False
+
+    @classmethod
+    def get_llm_prompt_content(cls) -> dict:
+        """Returns information for LLM prompts about this element."""
+        return {
+            "description": "Creates interactive to-do items with checkboxes that can be marked as complete.",
+            "when_to_use": "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.",
+            "syntax": ["- [ ] Unchecked to-do item", "- [x] Checked to-do item"],
+            "notes": [
+                "Can use any list indicator (-, *, +) before the checkbox",
+                "Space in brackets [ ] indicates unchecked status",
+                "x in brackets [x] indicates checked status",
+                "To-do items support inline formatting like **bold** and *italic*",
+            ],
+            "examples": [
+                "- [ ] Draft project proposal\n- [ ] Schedule kickoff meeting\n- [x] Create initial timeline",
+                "* [ ] Review code changes\n* [x] Write documentation\n* [ ] Deploy to production",
+            ],
+        }

notionary/core/converters/elements/toggle_element.py

@@ -0,0 +1,205 @@
+import re
+from typing import Dict, Any, Optional, List, Tuple, Callable
+
+from notionary.core.converters.elements.notion_block_element import NotionBlockElement
+
+
+class ToggleElement(NotionBlockElement):
+    """
+    Handles conversion between Markdown toggle blocks and Notion toggle blocks.
+
+    Markdown toggle syntax:
+    +++ Toggle title
+       Indented content that belongs to the toggle
+       More indented content
+
+    Non-indented content marks the end of the toggle block.
+    """
+
+    TOGGLE_PATTERN = re.compile(r"^[+]{3}\s+(.+)$")
+
+    INDENT_PATTERN = re.compile(r"^(\s{2,}|\t+)(.+)$")
+
+    @staticmethod
+    def match_markdown(text: str) -> bool:
+        """Check if text is a markdown toggle."""
+        return bool(ToggleElement.TOGGLE_PATTERN.match(text.strip()))
+
+    @staticmethod
+    def match_notion(block: Dict[str, Any]) -> bool:
+        """Check if block is a Notion toggle."""
+        return block.get("type") == "toggle"
+
+    @staticmethod
+    def markdown_to_notion(text: str) -> Optional[Dict[str, Any]]:
+        """Convert markdown toggle to Notion toggle block.
+
+        Note: This method only converts the toggle title line.
+        The nested content needs to be processed separately.
+        """
+        toggle_match = ToggleElement.TOGGLE_PATTERN.match(text.strip())
+        if not toggle_match:
+            return None
+
+        # Extract content
+        title = toggle_match.group(1)
+
+        return {
+            "type": "toggle",
+            "toggle": {
+                "rich_text": [{"type": "text", "text": {"content": title}}],
+                "color": "default",
+                "children": [],  # Will be populated with nested content
+            },
+        }
+
+    @staticmethod
+    def extract_nested_content(
+        lines: List[str], start_index: int
+    ) -> Tuple[List[str], int]:
+        """
+        Extract the nested content of a toggle element.
+
+        Args:
+            lines: All lines of text
+            start_index: Starting index to look for nested content
+
+        Returns:
+            Tuple of (nested_content_lines, next_line_index)
+        """
+        nested_content = []
+        current_index = start_index
+
+        while current_index < len(lines):
+            line = lines[current_index]
+
+            # Empty line is still part of toggle content
+            if not line.strip():
+                nested_content.append("")
+                current_index += 1
+                continue
+
+            # Check if line is indented (part of toggle content)
+            if line.startswith("  ") or line.startswith("\t"):
+                # Extract content with indentation removed
+                content_line = ToggleElement._remove_indentation(line)
+                nested_content.append(content_line)
+                current_index += 1
+                continue
+
+            # Non-indented, non-empty line marks the end of toggle content
+            break
+
+        return nested_content, current_index
+
+    @staticmethod
+    def _remove_indentation(line: str) -> str:
+        """Remove indentation from a line, handling both spaces and tabs."""
+        if line.startswith("\t"):
+            return line[1:]
+        else:
+            # Find number of leading spaces
+            leading_spaces = len(line) - len(line.lstrip(" "))
+            # Remove at least 2 spaces, but not more than what's there
+            return line[min(2, leading_spaces) :]
+
+    @staticmethod
+    def notion_to_markdown(block: Dict[str, Any]) -> Optional[str]:
+        """Convert Notion toggle block to markdown toggle."""
+        if block.get("type") != "toggle":
+            return None
+
+        toggle_data = block.get("toggle", {})
+
+        # Extract title from rich_text
+        title = ToggleElement._extract_text_content(toggle_data.get("rich_text", []))
+
+        # Create the toggle line
+        toggle_line = f"+++ {title}"
+
+        # Process children if any
+        children = toggle_data.get("children", [])
+        if children:
+            child_lines = []
+            for child_block in children:
+                # This would need to be handled by a full converter that can dispatch
+                # to the appropriate element type for each child block
+                child_markdown = "  [Nested content]"  # Placeholder
+                child_lines.append(f"  {child_markdown}")
+
+            return toggle_line + "\n" + "\n".join(child_lines)
+
+        return toggle_line
+
+    @staticmethod
+    def is_multiline() -> bool:
+        """Toggle blocks can span multiple lines due to their nested content."""
+        return True
+
+    @staticmethod
+    def _extract_text_content(rich_text: List[Dict[str, Any]]) -> str:
+        """Extract plain text content from Notion rich_text elements."""
+        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
+    ) -> List[Tuple[int, int, Dict[str, Any]]]:
+        """
+        Find all toggle elements in the text and process them.
+
+        Args:
+            text: The text to search in
+            process_nested_content: Optional callback function to process nested content
+                It should accept a string and return a list of Notion blocks
+
+        Returns:
+            List of (start_pos, end_pos, block) tuples
+        """
+        if not text:
+            return []
+
+        toggle_blocks = []
+        lines = text.split("\n")
+
+        i = 0
+        while i < len(lines):
+            line = lines[i]
+
+            # Check if line is a toggle
+            if not cls.match_markdown(line):
+                i += 1
+                continue
+
+            start_pos = 0
+            for j in range(i):
+                start_pos += len(lines[j]) + 1
+
+            toggle_block = cls.markdown_to_notion(line)
+            if not toggle_block:
+                i += 1
+                continue
+
+            # Extract nested content
+            nested_content, next_index = cls.extract_nested_content(lines, i + 1)
+
+            # Calculate ending position
+            end_pos = start_pos + len(line) + sum(len(l) + 1 for l in nested_content)
+
+            if nested_content and process_nested_content:
+                nested_text = "\n".join(nested_content)
+                nested_blocks = process_nested_content(nested_text)
+                if nested_blocks:
+                    toggle_block["toggle"]["children"] = nested_blocks
+
+            toggle_blocks.append((start_pos, end_pos, toggle_block))
+
+            i = next_index
+
+        return toggle_blocks

notionary/core/converters/elements/video_element.py

@@ -0,0 +1,159 @@
+import re
+from typing import Dict, Any, Optional, List
+from notionary.core.converters.elements.notion_block_element import NotionBlockElement
+
+
+class VideoElement(NotionBlockElement):
+    """
+    Handles conversion between Markdown video embeds and Notion video blocks.
+
+    Markdown video syntax (custom format since standard Markdown doesn't support videos):
+    - @[Caption](https://example.com/video.mp4) - Basic video with caption
+    - @[](https://example.com/video.mp4) - Video without caption
+    - @[Caption](https://www.youtube.com/watch?v=dQw4w9WgXcQ) - YouTube video
+    - @[Caption](https://youtu.be/dQw4w9WgXcQ) - YouTube shortened URL
+
+    Supports various video URLs including YouTube, Vimeo, and direct video file links.
+    """
+
+    # Regex pattern for video syntax
+    PATTERN = re.compile(
+        r"^\@\[(.*?)\]"  # @[Caption] part
+        + r'\((https?://[^\s"]+)'  # (URL part
+        + r"\)$"  # closing parenthesis
+    )
+
+    # YouTube specific patterns
+    YOUTUBE_PATTERNS = [
+        re.compile(
+            r"(?:https?://)?(?:www\.)?youtube\.com/watch\?v=([a-zA-Z0-9_-]{11})"
+        ),
+        re.compile(r"(?:https?://)?(?:www\.)?youtu\.be/([a-zA-Z0-9_-]{11})"),
+    ]
+
+    @staticmethod
+    def match_markdown(text: str) -> bool:
+        """Check if text is a markdown video embed."""
+        text = text.strip()
+        return text.startswith("@[") and bool(VideoElement.PATTERN.match(text))
+
+    @staticmethod
+    def match_notion(block: Dict[str, Any]) -> bool:
+        """Check if block is a Notion video."""
+        return block.get("type") == "video"
+
+    @staticmethod
+    def is_youtube_url(url: str) -> bool:
+        """Check if URL is a YouTube video and return video ID if it is."""
+        for pattern in VideoElement.YOUTUBE_PATTERNS:
+            match = pattern.match(url)
+            if match:
+                return True
+        return False
+
+    @staticmethod
+    def get_youtube_id(url: str) -> Optional[str]:
+        """Extract YouTube video ID from URL."""
+        for pattern in VideoElement.YOUTUBE_PATTERNS:
+            match = pattern.match(url)
+            if match:
+                return match.group(1)
+        return None
+
+    @staticmethod
+    def markdown_to_notion(text: str) -> Optional[Dict[str, Any]]:
+        """Convert markdown video embed to Notion video block."""
+        video_match = VideoElement.PATTERN.match(text.strip())
+        if not video_match:
+            return None
+
+        caption = video_match.group(1)
+        url = video_match.group(2)
+
+        if not url:
+            return None
+
+        # For YouTube videos, ensure we use the full embed URL
+        youtube_id = VideoElement.get_youtube_id(url)
+        if youtube_id:
+            url = f"https://www.youtube.com/watch?v={youtube_id}"
+
+        # Prepare the video block
+        video_block = {
+            "type": "video",
+            "video": {"type": "external", "external": {"url": url}},
+        }
+
+        # Add caption if provided
+        if caption:
+            video_block["video"]["caption"] = [
+                {"type": "text", "text": {"content": caption}}
+            ]
+
+        return video_block
+
+    @staticmethod
+    def notion_to_markdown(block: Dict[str, Any]) -> Optional[str]:
+        """Convert Notion video block to markdown video embed."""
+        if block.get("type") != "video":
+            return None
+
+        video_data = block.get("video", {})
+
+        # Handle both external and file (uploaded) videos
+        if video_data.get("type") == "external":
+            url = video_data.get("external", {}).get("url", "")
+        elif video_data.get("type") == "file":
+            url = video_data.get("file", {}).get("url", "")
+        else:
+            return None
+
+        if not url:
+            return None
+
+        # Extract caption if available
+        caption = ""
+        caption_rich_text = video_data.get("caption", [])
+        if caption_rich_text:
+            caption = VideoElement._extract_text_content(caption_rich_text)
+
+        return f"@[{caption}]({url})"
+
+    @staticmethod
+    def is_multiline() -> bool:
+        """Videos are single-line elements."""
+        return False
+
+    @staticmethod
+    def _extract_text_content(rich_text: List[Dict[str, Any]]) -> str:
+        """Extract plain text content from Notion rich_text elements."""
+        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 get_llm_prompt_content(cls) -> dict:
+        """Returns information for LLM prompts about this element."""
+        return {
+            "description": "Embeds video content from external sources like YouTube or direct video URLs.",
+            "when_to_use": "Use video embeds when you want to include multimedia content directly in your document. Videos are useful for tutorials, demonstrations, presentations, or any content that benefits from visual explanation.",
+            "syntax": [
+                "@[](https://example.com/video.mp4) - Video without caption",
+                "@[Caption text](https://example.com/video.mp4) - Video with caption",
+            ],
+            "supported_sources": [
+                "YouTube videos (https://youtube.com/watch?v=ID or https://youtu.be/ID)",
+                "Vimeo videos",
+                "Direct links to video files (.mp4, .mov, etc.)",
+                "Other video hosting platforms supported by Notion",
+            ],
+            "examples": [
+                "@[How to use this feature](https://www.youtube.com/watch?v=dQw4w9WgXcQ)",
+                "@[Product demo](https://example.com/videos/demo.mp4)",
+                "@[](https://youtu.be/dQw4w9WgXcQ)",
+            ],
+        }