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

notionary/blocks/video/video_element.py

@@ -1,182 +1,106 @@
-import re
-from typing import Dict, Any, Optional, List
+from __future__ import annotations
 
-from notionary.blocks import (
-    ElementPromptContent,
-    ElementPromptBuilder,
-    NotionBlockResult,
-    NotionBlockElement,
+import re
+from typing import Optional
+
+from notionary.blocks.base_block_element import BaseBlockElement
+from notionary.blocks.file.file_element_models import ExternalFile, FileBlock, FileType
+from notionary.blocks.models import Block, BlockCreateResult
+from notionary.blocks.paragraph.paragraph_models import (
+    CreateParagraphBlock,
+    ParagraphBlock,
 )
+from notionary.blocks.rich_text.rich_text_models import RichTextObject
+from notionary.blocks.rich_text.text_inline_formatter import TextInlineFormatter
+from notionary.blocks.types import BlockType
+from notionary.blocks.video.video_element_models import CreateVideoBlock
 
 
-class VideoElement(NotionBlockElement):
+class VideoElement(BaseBlockElement):
     """
     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
+    - [video](https://example.com/video.mp4) - URL only
+    - [video](https://example.com/video.mp4 "Caption") - URL + 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.
+    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
+        r"^\[video\]\("  # prefix
+        r"(https?://[^\s\"]+)"  # URL
+        r"(?:\s+\"([^\"]+)\")?"  # optional caption
+        r"\)$"
     )
 
-    # 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())
-        if not video_match:
-            return None
-
-        url = video_match.group(1)
-        caption = video_match.group(2)
-
-        if not url:
+    def markdown_to_notion(cls, text: str) -> BlockCreateResult:
+        """Convert markdown video syntax to a Notion VideoBlock plus an empty paragraph."""
+        match = cls.PATTERN.match(text.strip())
+        if not match:
             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}"
+        url, caption_text = match.group(1), match.group(2) or ""
 
-        video_data = {"type": "external", "external": {"url": url}}
-
-        # Add caption if provided
-        if caption:
-            video_data["caption"] = [{"type": "text", "text": {"content": caption}}]
-        else:
-            video_data["caption"] = []
+        vid_id = cls._get_youtube_id(url)
+        if vid_id:
+            url = f"https://www.youtube.com/watch?v={vid_id}"
 
-        # Prepare the video block
-        video_block = {"type": "video", "video": video_data}
+        video_block = FileBlock(
+            type=FileType.EXTERNAL, external=ExternalFile(url=url), caption=[]
+        )
+        if caption_text.strip():
+            rt = RichTextObject.from_plain_text(caption_text.strip())
+            video_block.caption = [rt]
 
-        # Add empty paragraph after video
-        empty_paragraph = {"type": "paragraph", "paragraph": {"rich_text": []}}
+        empty_para = ParagraphBlock(rich_text=[])
 
-        return [video_block, empty_paragraph]
+        return [
+            CreateVideoBlock(video=video_block),
+            CreateParagraphBlock(paragraph=empty_para),
+        ]
 
     @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":
+    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", [])
+        # 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)
 
-        if not caption_rich_text:
-            # Simple video with URL only
+        # Captions
+        captions = fo.caption or []
+        if not captions:
             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
+        caption_text = "".join(
+            (rt.plain_text or TextInlineFormatter.extract_text_with_formatting([rt]))
+            for rt in captions
+        )
 
-    @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 f'[video]({url} "{caption_text}")'
 
     @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()
-        )

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,10 @@
 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
 
 
 class VideoMarkdownBlockParams(BaseModel):

notionary/database/client.py

@@ -1,19 +1,14 @@
-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 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.

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