notionary 0.2.17__py3-none-any.whl → 0.2.19__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/file_upload/notion_file_upload.py

@@ -23,7 +23,7 @@ class NotionFileUpload(LoggingMixin):
 
     def __init__(self, token: Optional[str] = None):
         """Initialize the file upload service."""
-        from notionary import NotionFileUploadClient
+        from notionary.file_upload import NotionFileUploadClient
 
         self.client = NotionFileUploadClient(token=token)
 

notionary/page/content/markdown_whitespace_processor.py

@@ -0,0 +1,80 @@
+class MarkdownWhitespaceProcessor:
+    """Helper class for processing markdown whitespace."""
+
+    def __init__(self):
+        self.processed_lines = []
+        self.in_code_block = False
+        self.current_code_block = []
+
+    def process_lines(self, lines: list[str]) -> str:
+        """Process all lines and return the processed markdown."""
+        self.processed_lines = []
+        self.in_code_block = False
+        self.current_code_block = []
+
+        for line in lines:
+            self._process_single_line(line)
+
+        # Handle unclosed code block
+        if self.in_code_block and self.current_code_block:
+            self._finish_code_block()
+
+        return "\n".join(self.processed_lines)
+
+    def _process_single_line(self, line: str) -> None:
+        """Process a single line of markdown."""
+        if self._is_code_block_marker(line):
+            self._handle_code_block_marker(line)
+            return
+
+        if self.in_code_block:
+            self.current_code_block.append(line)
+            return
+
+        # Regular text - remove leading whitespace
+        self.processed_lines.append(line.lstrip())
+
+    def _handle_code_block_marker(self, line: str) -> None:
+        """Handle code block start/end markers."""
+        if not self.in_code_block:
+            # Starting new code block
+            self.in_code_block = True
+            self.processed_lines.append(self._normalize_code_block_start(line))
+            self.current_code_block = []
+        else:
+            # Ending code block
+            self._finish_code_block()
+
+    def _finish_code_block(self) -> None:
+        """Finish processing current code block."""
+        self.processed_lines.extend(
+            self._normalize_code_block_content(self.current_code_block)
+        )
+        self.processed_lines.append("```")
+        self.in_code_block = False
+
+    def _is_code_block_marker(self, line: str) -> bool:
+        """Check if line is a code block marker."""
+        return line.lstrip().startswith("```")
+
+    def _normalize_code_block_start(self, line: str) -> str:
+        """Normalize code block opening marker."""
+        language = line.lstrip().replace("```", "", 1).strip()
+        return "```" + language
+
+    def _normalize_code_block_content(self, code_lines: list[str]) -> list[str]:
+        """Normalize code block indentation."""
+        if not code_lines:
+            return []
+
+        # Find minimum indentation from non-empty lines
+        non_empty_lines = [line for line in code_lines if line.strip()]
+        if not non_empty_lines:
+            return [""] * len(code_lines)
+
+        min_indent = min(len(line) - len(line.lstrip()) for line in non_empty_lines)
+        if min_indent == 0:
+            return code_lines
+
+        # Remove common indentation
+        return ["" if not line.strip() else line[min_indent:] for line in code_lines]

notionary/page/content/notion_text_length_utils.py

@@ -0,0 +1,87 @@
+"""
+Utility functions for handling Notion API text length limitations.
+
+This module provides functions to fix text content that exceeds Notion's
+rich_text character limit of 2000 characters per element.
+
+Resolves API errors like:
+"validation_error - body.children[79].toggle.children[2].paragraph.rich_text[0].text.content.length
+should be ≤ 2000, instead was 2162."
+"""
+
+import re
+import logging
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+def fix_blocks_content_length(
+    blocks: list[dict[str, Any]], max_text_length: int = 1900
+) -> list[dict[str, Any]]:
+    """Check each block and ensure text content doesn't exceed Notion's limit."""
+    return [_fix_single_block_content(block, max_text_length) for block in blocks]
+
+
+def _fix_single_block_content(
+    block: dict[str, Any], max_text_length: int
+) -> dict[str, Any]:
+    """Fix content length in a single block and its children recursively."""
+    block_copy = block.copy()
+
+    block_type = block.get("type")
+    if not block_type:
+        return block_copy
+
+    content = block.get(block_type)
+    if not content:
+        return block_copy
+
+    if "rich_text" in content:
+        _fix_rich_text_content(block_copy, block_type, content, max_text_length)
+
+    if "children" in content and content["children"]:
+        block_copy[block_type]["children"] = [
+            _fix_single_block_content(child, max_text_length)
+            for child in content["children"]
+        ]
+
+    return block_copy
+
+
+def _fix_rich_text_content(
+    block_copy: dict[str, Any],
+    block_type: str,
+    content: dict[str, Any],
+    max_text_length: int,
+) -> None:
+    """Fix rich text content that exceeds the length limit."""
+    rich_text = content["rich_text"]
+    for i, text_item in enumerate(rich_text):
+        if "text" not in text_item or "content" not in text_item["text"]:
+            continue
+
+        text_content = text_item["text"]["content"]
+        if len(text_content) <= max_text_length:
+            continue
+
+        logger.warning(
+            "Truncating text content from %d to %d chars",
+            len(text_content),
+            max_text_length,
+        )
+        block_copy[block_type]["rich_text"][i]["text"]["content"] = text_content[
+            :max_text_length
+        ]
+
+
+def split_to_paragraphs(markdown_text: str) -> list[str]:
+    """Split markdown into paragraphs."""
+    paragraphs = re.split(r"\n\s*\n", markdown_text)
+    return [p for p in paragraphs if p.strip()]
+
+
+def split_to_sentences(paragraph: str) -> list[str]:
+    """Split a paragraph into sentences."""
+    sentences = re.split(r"(?<=[.!?])\s+", paragraph)
+    return [s for s in sentences if s.strip()]

notionary/page/content/page_content_retriever.py

@@ -1,8 +1,10 @@
-from typing import Any, Dict, List, Optional
+import json
+from typing import Any, Dict, Optional
 
 from notionary.blocks.registry.block_registry import BlockRegistry
 
 from notionary.blocks import NotionBlockClient
+from notionary.blocks.shared.models import Block
 from notionary.page.notion_to_markdown_converter import (
     NotionToMarkdownConverter,
 )
@@ -23,30 +25,36 @@ class PageContentRetriever(LoggingMixin):
 
     async def get_page_content(self) -> str:
         blocks = await self._get_page_blocks_with_children()
-        return self._notion_to_markdown_converter.convert(blocks)
+
+        # TODO: Fix this quick fix🧯 Quick-Fix: Konvertiere rekursive Block-Objekte in plain dicts
+        blocks_as_dicts = [block.model_dump(mode="python", exclude_unset=True) for block in blocks]
+
+        return self._notion_to_markdown_converter.convert(blocks_as_dicts)
 
     async def _get_page_blocks_with_children(
         self, parent_id: Optional[str] = None
-    ) -> List[Dict[str, Any]]:
-        blocks = (
-            await self.client.get_page_blocks(page_id=self.page_id)
+    ) -> list[Block]:
+        response = (
+            await self.client.get_block_children(block_id=self.page_id)
             if parent_id is None
             else await self.client.get_block_children(parent_id)
         )
 
-        if not blocks:
+        if not response or not response.results:
             return []
 
+        blocks = response.results
+
         for block in blocks:
-            if not block.get("has_children"):
+            if not block.has_children:
                 continue
 
-            block_id = block.get("id")
+            block_id = block.id
             if not block_id:
                 continue
 
             children = await self._get_page_blocks_with_children(block_id)
             if children:
-                block["children"] = children
+                block.children = children
 
-        return blocks
+        return blocks