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

notionary/blocks/video/video_element.py

@@ -1,182 +1,111 @@
+from __future__ import annotations
+
 import re
-from typing import Dict, Any, Optional, List
+from typing import Optional
 
-from notionary.blocks import (
-    ElementPromptContent,
-    ElementPromptBuilder,
-    NotionBlockResult,
-    NotionBlockElement,
-)
+from notionary.blocks.base_block_element import BaseBlockElement
+from notionary.blocks.file.file_element_models import ExternalFile, FileBlock, FileType
+from notionary.blocks.mixins.captions import CaptionMixin
+from notionary.blocks.syntax_prompt_builder import BlockElementMarkdownInformation
+from notionary.blocks.models import Block, BlockCreateResult
+from notionary.blocks.types import BlockType
+from notionary.blocks.video.video_element_models import CreateVideoBlock
 
 
-class VideoElement(NotionBlockElement):
+class VideoElement(BaseBlockElement, CaptionMixin):
     """
     Handles conversion between Markdown video embeds and Notion video blocks.
 
     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)
+    - [video](https://example.com/video.mp4) - URL only
+    - [video](https://example.com/video.mp4)(caption:Demo Video) - URL with caption
+    - (caption:Tutorial video)[video](https://youtube.com/watch?v=abc123) - caption before URL
 
-    Supports various video URLs including YouTube, Vimeo, and direct video file links.
+    Supports YouTube, Vimeo, and direct file URLs.
     """
 
-    # Regex pattern for video syntax with optional caption
-    PATTERN = re.compile(
-        r"^\[video\]\("  # [video]( prefix
-        + r'(https?://[^\s"]+)'  # URL (required)
-        + r'(?:\s+"([^"]+)")?'  # Optional caption in quotes
-        + r"\)$"  # closing parenthesis
-    )
+    # Flexible pattern that can handle caption in any position
+    VIDEO_PATTERN = re.compile(r"\[video\]\((https?://[^\s\"]+)\)")
 
-    # YouTube URL 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})"),
+        re.compile(r"(?:https?://)?(?:www\.)?youtube\.com/watch\?v=([\w-]{11})"),
+        re.compile(r"(?:https?://)?(?:www\.)?youtu\.be/([\w-]{11})"),
     ]
 
     @classmethod
-    def match_markdown(cls, text: str) -> bool:
-        """Check if text is a markdown video embed."""
-        return text.strip().startswith("[video]") and bool(
-            VideoElement.PATTERN.match(text.strip())
-        )
+    def match_notion(cls, block: Block) -> bool:
+        return block.type == BlockType.VIDEO and block.video
 
     @classmethod
-    def match_notion(cls, block: Dict[str, Any]) -> bool:
-        """Check if block is a Notion video."""
-        return block.get("type") == "video"
-
-    @classmethod
-    def markdown_to_notion(cls, text: str) -> NotionBlockResult:
-        """Convert markdown video embed to Notion video block."""
-        video_match = VideoElement.PATTERN.match(text.strip())
+    async def markdown_to_notion(cls, text: str) -> BlockCreateResult:
+        """Convert markdown video syntax to a Notion VideoBlock."""
+        # Use our own regex to find the video URL
+        video_match = cls.VIDEO_PATTERN.search(text.strip())
         if not video_match:
             return None
 
         url = video_match.group(1)
-        caption = video_match.group(2)
-
-        if not url:
-            return None
 
-        # Normalize YouTube URLs
-        youtube_id = VideoElement._get_youtube_id(url)
-        if youtube_id:
-            url = f"https://www.youtube.com/watch?v={youtube_id}"
+        vid_id = cls._get_youtube_id(url)
+        if vid_id:
+            url = f"https://www.youtube.com/watch?v={vid_id}"
 
-        video_data = {"type": "external", "external": {"url": url}}
+        # Use mixin to extract caption (if present anywhere in text)
+        caption_text = cls.extract_caption(text.strip())
+        caption_rich_text = cls.build_caption_rich_text(caption_text or "")
 
-        # Add caption if provided
-        if caption:
-            video_data["caption"] = [{"type": "text", "text": {"content": caption}}]
-        else:
-            video_data["caption"] = []
-
-        # Prepare the video block
-        video_block = {"type": "video", "video": video_data}
-
-        # Add empty paragraph after video
-        empty_paragraph = {"type": "paragraph", "paragraph": {"rich_text": []}}
+        video_block = FileBlock(
+            type=FileType.EXTERNAL,
+            external=ExternalFile(url=url),
+            caption=caption_rich_text,
+        )
 
-        return [video_block, empty_paragraph]
+        return CreateVideoBlock(video=video_block)
 
     @classmethod
-    def notion_to_markdown(cls, block: Dict[str, Any]) -> Optional[str]:
-        """Convert Notion video block to markdown video embed."""
-        if block.get("type") != "video":
+    async def notion_to_markdown(cls, block: Block) -> Optional[str]:
+        if block.type != BlockType.VIDEO or not block.video:
             return None
 
-        video_data = block.get("video", {})
-
-        # Extract URL from video data
-        url = VideoElement._extract_video_url(video_data)
-        if not url:
-            return None
+        fo = block.video
 
-        caption_rich_text = video_data.get("caption", [])
-
-        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}")'
+        # URL ermitteln
+        if fo.type == FileType.EXTERNAL and fo.external:
+            url = fo.external.url
+        elif fo.type == FileType.FILE and fo.file:
+            url = fo.file.url
+        else:
+            return None  # (file_upload o.ä. hier nicht supported)
 
-        return f"[video]({url})"
+        result = f"[video]({url})"
 
-    @classmethod
-    def is_multiline(cls) -> bool:
-        """Videos are single-line elements."""
-        return False
+        # Add caption if present
+        caption_markdown = await cls.format_caption_for_markdown(fo.caption or [])
+        if caption_markdown:
+            result += caption_markdown
 
-    @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
+        return result
 
     @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)
+        for pat in cls.YOUTUBE_PATTERNS:
+            m = pat.match(url)
+            if m:
+                return m.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."""
-        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) -> ElementPromptContent:
-        """
-        Returns structured LLM prompt metadata for the video element.
-        """
-        return (
-            ElementPromptBuilder()
-            .with_description(
-                "Embeds video content from external sources like YouTube or direct video URLs."
-            )
-            .with_usage_guidelines(
-                "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('[video](https://example.com/video.mp4 "Optional caption")')
-            .with_examples(
-                [
-                    "[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()
+    def get_system_prompt_information(cls) -> Optional[BlockElementMarkdownInformation]:
+        """Get system prompt information for video blocks."""
+        return BlockElementMarkdownInformation(
+            block_type=cls.__name__,
+            description="Video blocks embed videos from external URLs like YouTube, Vimeo, or direct video files",
+            syntax_examples=[
+                "[video](https://youtube.com/watch?v=abc123)",
+                "[video](https://vimeo.com/123456789)",
+                "[video](https://example.com/video.mp4)(caption:Demo Video)",
+                "(caption:Tutorial)[video](https://youtu.be/abc123)",
+                "[video](https://youtube.com/watch?v=xyz)(caption:**Important** tutorial)",
+            ],
+            usage_guidelines="Use for embedding videos from supported platforms or direct video file URLs. Supports YouTube, Vimeo, and direct video files. Caption supports rich text formatting and describes the video content.",
         )

notionary/blocks/video/video_element_models.py

@@ -0,0 +1,10 @@
+from typing import Literal
+
+from pydantic import BaseModel
+
+from notionary.blocks.file.file_element_models import FileBlock
+
+
+class CreateVideoBlock(BaseModel):
+    type: Literal["video"] = "video"
+    video: FileBlock

notionary/blocks/video/video_markdown_node.py

@@ -1,8 +1,11 @@
 from __future__ import annotations
 
 from typing import Optional
+
 from pydantic import BaseModel
-from notionary.blocks.markdown_node import MarkdownNode
+
+from notionary.markdown.markdown_node import MarkdownNode
+from notionary.blocks.mixins.captions import CaptionMarkdownNodeMixin
 
 
 class VideoMarkdownBlockParams(BaseModel):
@@ -10,10 +13,9 @@ class VideoMarkdownBlockParams(BaseModel):
     caption: Optional[str] = None
 
 
-class VideoMarkdownNode(MarkdownNode):
+class VideoMarkdownNode(MarkdownNode, CaptionMarkdownNodeMixin):
     """
     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):
@@ -25,6 +27,11 @@ class VideoMarkdownNode(MarkdownNode):
         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})"
+        """Return the Markdown representation.
+
+        Examples:
+        - [video](https://example.com/movie.mp4)
+        - [video](https://www.youtube.com/watch?v=dQw4w9WgXcQ)(caption:Music Video)
+        """
+        base_markdown = f"[video]({self.url})"
+        return self.append_caption_to_markdown(base_markdown, self.caption)

notionary/database/client.py

@@ -1,19 +1,16 @@
-from typing import Dict, Any, Optional
-from dotenv import load_dotenv
-from notionary.base_notion_client import BaseNotionClient
+from typing import Any, Dict, Optional
+
+from urllib3.util import response
 
-from notionary.models.notion_database_response import (
+from notionary.base_notion_client import BaseNotionClient
+from notionary.database.models import (
     NotionDatabaseResponse,
     NotionDatabaseSearchResponse,
     NotionPageResponse,
     NotionQueryDatabaseResponse,
 )
-from notionary.util import singleton
 
-load_dotenv()
 
-
-@singleton
 class NotionDatabaseClient(BaseNotionClient):
     """
     Specialized Notion client for database operations.
@@ -23,6 +20,27 @@ class NotionDatabaseClient(BaseNotionClient):
     def __init__(self, token: Optional[str] = None, timeout: int = 30):
         super().__init__(token, timeout)
 
+    async def create_database(
+        self,
+        title: str,
+        parent_page_id: Optional[str],
+        properties: Optional[Dict[str, Any]] = None,
+    ) -> NotionDatabaseResponse:
+        """
+        Creates a new database as child of the specified page.
+        """
+        if properties is None:
+            properties = {"Name": {"title": {}}}
+
+        database_data = {
+            "parent": {"page_id": parent_page_id},
+            "title": [{"type": "text", "text": {"content": title}}],
+            "properties": properties,
+        }
+
+        response = await self.post("databases", database_data)
+        return NotionDatabaseResponse.model_validate(response)
+
     async def get_database(self, database_id: str) -> NotionDatabaseResponse:
         """
         Gets metadata for a Notion database by its ID.

notionary/database/database.py

@@ -1,25 +1,24 @@
 from __future__ import annotations
+
 import asyncio
 import random
-from typing import Any, AsyncGenerator, Dict, Optional
+from typing import Any, AsyncGenerator, Optional
 
 from notionary.database.client import NotionDatabaseClient
-from notionary.models.notion_database_response import (
+from notionary.database.database_filter_builder import DatabaseFilterBuilder
+from notionary.database.database_provider import NotionDatabaseProvider
+from notionary.database.models import (
     NotionDatabaseResponse,
     NotionPageResponse,
     NotionQueryDatabaseResponse,
 )
 from notionary.page.notion_page import NotionPage
-
-from notionary.database.database_provider import NotionDatabaseProvider
-
-from notionary.database.database_filter_builder import DatabaseFilterBuilder
 from notionary.telemetry import (
-    ProductTelemetry,
     DatabaseFactoryUsedEvent,
+    ProductTelemetry,
     QueryOperationEvent,
 )
-from notionary.util import factory_only, LoggingMixin
+from notionary.util import LoggingMixin, factory_only
 
 
 class NotionDatabase(LoggingMixin):
@@ -38,7 +37,7 @@ class NotionDatabase(LoggingMixin):
         title: str,
         url: str,
         emoji_icon: Optional[str] = None,
-        properties: Optional[Dict[str, Any]] = None,
+        properties: Optional[dict[str, Any]] = None,
         token: Optional[str] = None,
     ):
         """
@@ -103,7 +102,7 @@ class NotionDatabase(LoggingMixin):
         return self._emoji_icon
 
     @property
-    def properties(self) -> Optional[Dict[str, Any]]:
+    def properties(self) -> Optional[dict[str, Any]]:
         """Get the database properties (readonly)."""
         return self._properties
 
@@ -328,7 +327,7 @@ class NotionDatabase(LoggingMixin):
     async def _iter_pages(
         self,
         page_size: int = 100,
-        filter_conditions: Optional[Dict[str, Any]] = None,
+        filter_conditions: Optional[dict[str, Any]] = None,
     ) -> AsyncGenerator[NotionPage, None]:
         """
         Asynchronous generator that yields NotionPage objects from the database.
@@ -422,7 +421,7 @@ class NotionDatabase(LoggingMixin):
         except (KeyError, TypeError, AttributeError):
             return None
 
-    async def _get_relation_options(self, property_name: str) -> list[Dict[str, Any]]:
+    async def _get_relation_options(self, property_name: str) -> list[dict[str, Any]]:
         """
         Retrieve the titles of all pages related to a relation property.
 
@@ -445,7 +444,7 @@ class NotionDatabase(LoggingMixin):
     async def _paginate_database(
         self,
         page_size: int = 100,
-        filter_conditions: Optional[Dict[str, Any]] = None,
+        filter_conditions: Optional[dict[str, Any]] = None,
     ) -> AsyncGenerator[list[NotionPageResponse], None]:
         """
         Central pagination logic for Notion Database queries.
@@ -461,7 +460,7 @@ class NotionDatabase(LoggingMixin):
         has_more = True
 
         while has_more:
-            query_data: Dict[str, Any] = {"page_size": page_size}
+            query_data: dict[str, Any] = {"page_size": page_size}
 
             if start_cursor:
                 query_data["start_cursor"] = start_cursor

notionary/database/database_filter_builder.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
-from typing import Any, Dict, List
-from datetime import datetime, timedelta
 from dataclasses import dataclass, field
+from datetime import datetime, timedelta
+from typing import Any, Dict, List
 
 
 @dataclass

notionary/database/database_provider.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
 
-from typing import Dict, Optional, TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
+
 from notionary.database.client import NotionDatabaseClient
 from notionary.database.exceptions import DatabaseNotFoundException
-from notionary.models.notion_database_response import NotionDatabaseResponse
-from notionary.util import LoggingMixin, format_uuid, SingletonMetaClass
+from notionary.database.models import NotionDatabaseResponse
+from notionary.util import LoggingMixin, SingletonMetaClass, format_uuid
 from notionary.util.fuzzy import find_best_match
 
 if TYPE_CHECKING:
@@ -22,7 +23,7 @@ class NotionDatabaseProvider(LoggingMixin, metaclass=SingletonMetaClass):
     """
 
     def __init__(self):
-        self._database_cache: Dict[str, NotionDatabase] = {}
+        self._database_cache: dict[str, NotionDatabase] = {}
 
     async def get_database_by_id(
         self, database_id: str, token: Optional[str] = None, force_refresh: bool = False