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

notionary/blocks/{video_element.py → video/video_element.py}

@@ -1,29 +1,38 @@
 import re
 from typing import Dict, Any, Optional, List
 
-from notionary.blocks import NotionBlockElement
-from notionary.blocks import ElementPromptContent, ElementPromptBuilder
+from notionary.blocks import (
+    ElementPromptContent,
+    ElementPromptBuilder,
+    NotionBlockResult,
+    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
+    Markdown video syntax:
+    - [video](https://example.com/video.mp4) - Simple video with URL only
+    - [video](https://example.com/video.mp4 "Caption") - Video with URL and caption
+
+    Where:
+    - URL is the required video URL
+    - Caption is an optional descriptive text (enclosed in quotes)
 
     Supports various video URLs including YouTube, Vimeo, and direct video file links.
     """
 
+    # Regex pattern for video syntax with optional caption
     PATTERN = re.compile(
-        r"^\@\[(.*?)\]"  # @[Caption] part
-        + r'\((https?://[^\s"]+)'  # (URL part
+        r"^\[video\]\("  # [video]( prefix
+        + r'(https?://[^\s"]+)'  # URL (required)
+        + r'(?:\s+"([^"]+)")?'  # Optional caption in quotes
         + r"\)$"  # closing parenthesis
     )
 
+    # YouTube URL patterns
     YOUTUBE_PATTERNS = [
         re.compile(
             r"(?:https?://)?(?:www\.)?youtube\.com/watch\?v=([a-zA-Z0-9_-]{11})"
@@ -34,8 +43,9 @@ class VideoElement(NotionBlockElement):
     @classmethod
     def match_markdown(cls, text: str) -> bool:
         """Check if text is a markdown video embed."""
-        text = text.strip()
-        return text.startswith("@[") and bool(VideoElement.PATTERN.match(text))
+        return text.strip().startswith("[video]") and bool(
+            VideoElement.PATTERN.match(text.strip())
+        )
 
     @classmethod
     def match_notion(cls, block: Dict[str, Any]) -> bool:
@@ -43,51 +53,38 @@ class VideoElement(NotionBlockElement):
         return block.get("type") == "video"
 
     @classmethod
-    def is_youtube_url(cls, 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
-
-    @classmethod
-    def get_youtube_id(cls, 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
-
-    @classmethod
-    def markdown_to_notion(cls, text: str) -> Optional[Dict[str, Any]]:
+    def markdown_to_notion(cls, text: str) -> NotionBlockResult:
         """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)
+        url = video_match.group(1)
+        caption = video_match.group(2)
 
         if not url:
             return None
 
-        youtube_id = VideoElement.get_youtube_id(url)
+        # Normalize YouTube URLs
+        youtube_id = VideoElement._get_youtube_id(url)
         if youtube_id:
             url = f"https://www.youtube.com/watch?v={youtube_id}"
 
-        video_block = {
-            "type": "video",
-            "video": {"type": "external", "external": {"url": url}},
-        }
+        video_data = {"type": "external", "external": {"url": url}}
 
+        # Add caption if provided
         if caption:
-            video_block["video"]["caption"] = [
-                {"type": "text", "text": {"content": caption}}
-            ]
+            video_data["caption"] = [{"type": "text", "text": {"content": caption}}]
+        else:
+            video_data["caption"] = []
 
-        return video_block
+        # Prepare the video block
+        video_block = {"type": "video", "video": video_data}
+
+        # Add empty paragraph after video
+        empty_paragraph = {"type": "paragraph", "paragraph": {"rich_text": []}}
+
+        return [video_block, empty_paragraph]
 
     @classmethod
     def notion_to_markdown(cls, block: Dict[str, Any]) -> Optional[str]:
@@ -97,29 +94,56 @@ class VideoElement(NotionBlockElement):
 
         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
-
+        # Extract URL from video data
+        url = VideoElement._extract_video_url(video_data)
         if not url:
             return None
 
-        caption = ""
         caption_rich_text = video_data.get("caption", [])
-        if caption_rich_text:
-            caption = VideoElement._extract_text_content(caption_rich_text)
 
-        return f"@[{caption}]({url})"
+        if not caption_rich_text:
+            # Simple video with URL only
+            return f"[video]({url})"
+
+        # Extract caption text
+        caption = VideoElement._extract_text_content(caption_rich_text)
+
+        if caption:
+            return f'[video]({url} "{caption}")'
+
+        return f"[video]({url})"
 
     @classmethod
     def is_multiline(cls) -> bool:
         """Videos are single-line elements."""
         return False
 
+    @classmethod
+    def _is_youtube_url(cls, url: str) -> bool:
+        """Check if URL is a YouTube video."""
+        for pattern in VideoElement.YOUTUBE_PATTERNS:
+            if pattern.match(url):
+                return True
+        return False
+
+    @classmethod
+    def _get_youtube_id(cls, 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
+
+    @classmethod
+    def _extract_video_url(cls, video_data: Dict[str, Any]) -> str:
+        """Extract URL from video data, handling both external and uploaded videos."""
+        if video_data.get("type") == "external":
+            return video_data.get("external", {}).get("url", "")
+        elif video_data.get("type") == "file":
+            return video_data.get("file", {}).get("url", "")
+        return ""
+
     @classmethod
     def _extract_text_content(cls, rich_text: List[Dict[str, Any]]) -> str:
         """Extract plain text content from Notion rich_text elements."""
@@ -145,12 +169,13 @@ class VideoElement(NotionBlockElement):
                 "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."
             )
-            .with_syntax("@[Caption](https://example.com/video.mp4)")
+            .with_syntax('[video](https://example.com/video.mp4 "Optional caption")')
             .with_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)",
+                    "[video](https://www.youtube.com/watch?v=dQw4w9WgXcQ)",
+                    '[video](https://example.com/videos/demo.mp4 "Product demo")',
+                    '[video](https://youtu.be/dQw4w9WgXcQ "How to use this feature")',
+                    '[video](https://example.com/tutorial.mp4 "Step-by-step tutorial")',
                 ]
             )
             .build()

notionary/blocks/video/video_markdown_node.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from typing import Optional
+from pydantic import BaseModel
+from notionary.blocks.markdown_node import MarkdownNode
+
+
+class VideoMarkdownBlockParams(BaseModel):
+    url: str
+    caption: Optional[str] = None
+
+
+class VideoMarkdownNode(MarkdownNode):
+    """
+    Programmatic interface for creating Notion-style video blocks.
+    Example: [video](https://example.com/video.mp4 "Optional caption")
+    """
+
+    def __init__(self, url: str, caption: Optional[str] = None):
+        self.url = url
+        self.caption = caption
+
+    @classmethod
+    def from_params(cls, params: VideoMarkdownBlockParams) -> VideoMarkdownNode:
+        return cls(url=params.url, caption=params.caption)
+
+    def to_markdown(self) -> str:
+        if self.caption:
+            return f'[video]({self.url} "{self.caption}")'
+        return f"[video]({self.url})"

notionary/database/__init__.py

@@ -0,0 +1,4 @@
+from .database import NotionDatabase
+from .database_filter_builder import DatabaseFilterBuilder
+
+__all__ = ["NotionDatabase", "DatabaseFilterBuilder"]