notionary 0.2.23__py3-none-any.whl → 0.2.24__py3-none-any.whl

notionary/blocks/table_of_contents/table_of_contents_element.py

@@ -10,7 +10,7 @@ from notionary.blocks.table_of_contents.table_of_contents_models import (
     CreateTableOfContentsBlock,
     TableOfContentsBlock,
 )
-from notionary.blocks.types import BlockType
+from notionary.blocks.types import BlockType, BlockColor
 
 
 class TableOfContentsElement(BaseBlockElement):
@@ -18,7 +18,7 @@ class TableOfContentsElement(BaseBlockElement):
     Handles conversion between Markdown [toc] syntax and Notion table_of_contents blocks.
 
     Markdown syntax:
-    - [toc]                        → default color
+    - [toc]                        → default color (enum default)
     - [toc](blue)                  → custom color
     - [toc](blue_background)       → custom background color
     """
@@ -34,35 +34,47 @@ class TableOfContentsElement(BaseBlockElement):
         if not (input_match := cls.PATTERN.match(text.strip())):
             return None
 
-        color = (input_match.group("color") or "default").lower()
-        return CreateTableOfContentsBlock(
-            table_of_contents=TableOfContentsBlock(color=color)
-        )
+        color_str = input_match.group("color")
+        if color_str:
+            # Validate against the enum; fallback to default if unknown
+            try:
+                color = BlockColor(color_str.lower())
+                toc_payload = TableOfContentsBlock(color=color)
+            except ValueError:
+                # Unknown color → omit to use enum default
+                toc_payload = TableOfContentsBlock()
+        else:
+            # No color provided → omit to let enum default apply
+            toc_payload = TableOfContentsBlock()
+
+        return CreateTableOfContentsBlock(table_of_contents=toc_payload)
 
     @classmethod
     async def notion_to_markdown(cls, block: Block) -> Optional[str]:
-        # Fix: Use 'or' instead of 'and'
+        # Correct guard: if not a TOC or missing payload → no match
         if block.type != BlockType.TABLE_OF_CONTENTS or not block.table_of_contents:
             return None
 
-        color = block.table_of_contents.color.value
-
-        if color == "default":
+        color = block.table_of_contents.color
+        # If None or default → plain [toc]
+        if color is None or color == BlockColor.DEFAULT:
             return "[toc]"
-        return f"[toc]({color})"
+        return f"[toc]({color.value})"
 
-    @classmethod
     @classmethod
     def get_system_prompt_information(cls) -> Optional[BlockElementMarkdownInformation]:
-        """Get system prompt information for table of contents blocks."""
+        """System prompt info for table of contents blocks."""
         return BlockElementMarkdownInformation(
             block_type=cls.__name__,
-            description="Table of contents blocks automatically generate navigation for page headings",
+            description="Table of contents blocks automatically generate navigation for page headings.",
             syntax_examples=[
                 "[toc]",
                 "[toc](blue)",
                 "[toc](blue_background)",
                 "[toc](gray_background)",
             ],
-            usage_guidelines="Use to automatically generate a clickable table of contents from page headings. Optional color parameter changes the appearance. Default color is gray.",
+            usage_guidelines=(
+                "Use to auto-generate a clickable table of contents from page headings. "
+                "The color parameter is optional; if omitted, the default enum color is used."
+            ),
         )

notionary/blocks/table_of_contents/table_of_contents_markdown_node.py

@@ -1,18 +1,11 @@
-from __future__ import annotations
-
 from typing import Optional
 
-from pydantic import BaseModel
-
-from notionary.markdown.markdown_node import MarkdownNode
-
-
-class TableOfContentsMarkdownBlockParams(BaseModel):
-    color: Optional[str] = "default"
+from notionary.blocks.markdown.markdown_node import MarkdownNode
 
 
 class TableOfContentsMarkdownNode(MarkdownNode):
     """
+    Enhanced Table of Contents node with Pydantic integration.
     Programmatic interface for creating Markdown table of contents blocks.
     Example:
     [toc]
@@ -20,14 +13,7 @@ class TableOfContentsMarkdownNode(MarkdownNode):
     [toc](blue_background)
     """
 
-    def __init__(self, color: Optional[str] = "default"):
-        self.color = color or "default"
-
-    @classmethod
-    def from_params(
-        cls, params: TableOfContentsMarkdownBlockParams
-    ) -> TableOfContentsMarkdownNode:
-        return cls(color=params.color)
+    color: Optional[str] = "default"
 
     def to_markdown(self) -> str:
         if self.color == "default":

notionary/blocks/table_of_contents/table_of_contents_models.py

@@ -1,4 +1,4 @@
-from typing import Literal
+from typing import Literal, Optional
 
 from pydantic import BaseModel
 
@@ -8,7 +8,7 @@ from notionary.blocks.types import BlockColor
 class TableOfContentsBlock(BaseModel):
     """Inneres Payload-Objekt: { table_of_contents: { color: ... } }"""
 
-    color: BlockColor = BlockColor.DEFAULT
+    color: Optional[BlockColor] = BlockColor.DEFAULT
 
 
 class CreateTableOfContentsBlock(BaseModel):

notionary/blocks/todo/__init__.py

@@ -1,6 +1,5 @@
 from notionary.blocks.todo.todo_element import TodoElement
 from notionary.blocks.todo.todo_markdown_node import (
-    TodoMarkdownBlockParams,
     TodoMarkdownNode,
 )
 from notionary.blocks.todo.todo_models import CreateToDoBlock, ToDoBlock
@@ -10,5 +9,4 @@ __all__ = [
     "ToDoBlock",
     "CreateToDoBlock",
     "TodoMarkdownNode",
-    "TodoMarkdownBlockParams",
 ]

notionary/blocks/todo/todo_markdown_node.py

@@ -1,32 +1,21 @@
-from __future__ import annotations
-
-from pydantic import BaseModel
-
-from notionary.markdown.markdown_node import MarkdownNode
-
-
-class TodoMarkdownBlockParams(BaseModel):
-    text: str
-    checked: bool = False
-    marker: str = "-"
+from pydantic import Field
+from notionary.blocks.markdown.markdown_node import MarkdownNode
 
 
 class TodoMarkdownNode(MarkdownNode):
     """
+    Enhanced Todo node with Pydantic integration.
     Programmatic interface for creating Markdown todo items (checkboxes).
     Supports checked and unchecked states.
     Example: - [ ] Task, - [x] Done
     """
 
-    def __init__(self, text: str, checked: bool = False, marker: str = "-"):
-        self.text = text
-        self.checked = checked
-        self.marker = marker if marker in {"-", "*", "+"} else "-"
-
-    @classmethod
-    def from_params(cls, params: TodoMarkdownBlockParams) -> TodoMarkdownNode:
-        return cls(text=params.text, checked=params.checked, marker=params.marker)
+    text: str
+    checked: bool = False
+    marker: str = Field(default="-")
 
     def to_markdown(self) -> str:
+        # Validate marker in to_markdown to ensure it's valid
+        valid_marker = self.marker if self.marker in {"-", "*", "+"} else "-"
         checkbox = "[x]" if self.checked else "[ ]"
-        return f"{self.marker} {checkbox} {self.text}"
+        return f"{valid_marker} {checkbox} {self.text}"

notionary/blocks/todo/todo_models.py

@@ -1,6 +1,6 @@
-from typing import Literal
+from typing import Literal, Optional
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
 
 from notionary.blocks.models import Block
 from notionary.blocks.rich_text.rich_text_models import RichTextObject
@@ -11,7 +11,6 @@ class ToDoBlock(BaseModel):
     rich_text: list[RichTextObject]
     checked: bool = False
     color: BlockColor = BlockColor.DEFAULT
-    children: list[Block] = Field(default_factory=list)
 
 
 class CreateToDoBlock(BaseModel):

notionary/blocks/toggle/__init__.py

@@ -1,6 +1,5 @@
 from notionary.blocks.toggle.toggle_element import ToggleElement
 from notionary.blocks.toggle.toggle_markdown_node import (
-    ToggleMarkdownBlockParams,
     ToggleMarkdownNode,
 )
 from notionary.blocks.toggle.toggle_models import CreateToggleBlock, ToggleBlock
@@ -10,5 +9,4 @@ __all__ = [
     "ToggleBlock",
     "CreateToggleBlock",
     "ToggleMarkdownNode",
-    "ToggleMarkdownBlockParams",
 ]

notionary/blocks/toggle/toggle_markdown_node.py

@@ -1,18 +1,9 @@
-from __future__ import annotations
-
-from pydantic import BaseModel
-
-from notionary.markdown.markdown_node import MarkdownNode
-
-
-class ToggleMarkdownBlockParams(BaseModel):
-    title: str
-    children: list[MarkdownNode]
-    model_config = {"arbitrary_types_allowed": True}
+from notionary.blocks.markdown.markdown_node import MarkdownNode
 
 
 class ToggleMarkdownNode(MarkdownNode):
     """
+    Enhanced Toggle node with Pydantic integration.
     Clean programmatic interface for creating Notion-style Markdown toggle blocks
     with the simplified +++ "Title" syntax.
 
@@ -23,16 +14,11 @@ class ToggleMarkdownNode(MarkdownNode):
         +++
     """
 
-    def __init__(self, title: str, children: list[MarkdownNode]):
-        self.title = title
-        self.children = children
-
-    @classmethod
-    def from_params(cls, params: ToggleMarkdownBlockParams) -> ToggleMarkdownNode:
-        return cls(title=params.title, children=params.children)
+    title: str
+    children: list[MarkdownNode] = []
 
     def to_markdown(self) -> str:
-        result = f"+++{self.title}"
+        result = f"+++ {self.title}"
 
         if not self.children:
             result += "\n+++"

notionary/blocks/toggleable_heading/__init__.py

@@ -2,12 +2,10 @@ from notionary.blocks.toggleable_heading.toggleable_heading_element import (
     ToggleableHeadingElement,
 )
 from notionary.blocks.toggleable_heading.toggleable_heading_markdown_node import (
-    ToggleableHeadingMarkdownBlockParams,
     ToggleableHeadingMarkdownNode,
 )
 
 __all__ = [
     "ToggleableHeadingElement",
     "ToggleableHeadingMarkdownNode",
-    "ToggleableHeadingMarkdownBlockParams",
 ]

notionary/blocks/toggleable_heading/toggleable_heading_markdown_node.py

@@ -1,19 +1,11 @@
-from __future__ import annotations
+from pydantic import Field
 
-from pydantic import BaseModel
-
-from notionary.markdown.markdown_node import MarkdownNode
-
-
-class ToggleableHeadingMarkdownBlockParams(BaseModel):
-    text: str
-    level: int
-    children: list[MarkdownNode]
-    model_config = {"arbitrary_types_allowed": True}
+from notionary.blocks.markdown.markdown_node import MarkdownNode
 
 
 class ToggleableHeadingMarkdownNode(MarkdownNode):
     """
+    Enhanced Toggleable Heading node with Pydantic integration.
     Clean programmatic interface for creating collapsible Markdown headings (toggleable headings)
     with pipe-prefixed nested content using MarkdownNode children.
 
@@ -23,18 +15,9 @@ class ToggleableHeadingMarkdownNode(MarkdownNode):
         +++
     """
 
-    def __init__(self, text: str, level: int, children: list[MarkdownNode]):
-        if not (1 <= level <= 3):
-            raise ValueError("Only heading levels 1-3 are supported (H1, H2, H3)")
-        self.text = text
-        self.level = level
-        self.children = children
-
-    @classmethod
-    def from_params(
-        cls, params: ToggleableHeadingMarkdownBlockParams
-    ) -> ToggleableHeadingMarkdownNode:
-        return cls(text=params.text, level=params.level, children=params.children)
+    text: str
+    level: int = Field(ge=1, le=3)
+    children: list[MarkdownNode] = []
 
     def to_markdown(self) -> str:
         prefix = "+++" + ("#" * self.level)

notionary/blocks/video/__init__.py

@@ -1,7 +1,6 @@
 from notionary.blocks.video.video_element import VideoElement
 from notionary.blocks.video.video_element_models import CreateVideoBlock
 from notionary.blocks.video.video_markdown_node import (
-    VideoMarkdownBlockParams,
     VideoMarkdownNode,
 )
 
@@ -9,5 +8,4 @@ __all__ = [
     "VideoElement",
     "CreateVideoBlock",
     "VideoMarkdownNode",
-    "VideoMarkdownBlockParams",
 ]

notionary/blocks/video/video_element.py

@@ -1,66 +1,126 @@
 from __future__ import annotations
 
 import re
+from pathlib import Path
 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.file.file_element_models import (
+    ExternalFile,
+    FileBlock,
+    FileType,
+    FileUploadFile,
+)
 from notionary.blocks.mixins.captions import CaptionMixin
+from notionary.blocks.mixins.file_upload.file_upload_mixin import FileUploadMixin
 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(BaseBlockElement, CaptionMixin):
-    """
+class VideoElement(BaseBlockElement, CaptionMixin, FileUploadMixin):
+    r"""
     Handles conversion between Markdown video embeds and Notion video blocks.
 
-    Markdown video syntax:
-    - [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 external URLs (YouTube, Vimeo, direct links) and local video file uploads.
 
-    Supports YouTube, Vimeo, and direct file URLs.
+    Markdown video syntax:
+    - [video](https://example.com/video.mp4) - External URL
+    - [video](./local/movie.mp4) - Local video file (will be uploaded)
+    - [video](C:\Videos\tutorial.mov) - Absolute local path (will be uploaded)
+    - [video](https://youtube.com/watch?v=abc123)(caption:Demo Video) - URL with caption
+    - (caption:Tutorial video)[video](./local.mp4) - Caption before URL
     """
 
-    # Flexible pattern that can handle caption in any position
-    VIDEO_PATTERN = re.compile(r"\[video\]\((https?://[^\s\"]+)\)")
+    # Pattern matches both URLs and file paths
+    VIDEO_PATTERN = re.compile(r"\[video\]\(([^)]+)\)")
 
     YOUTUBE_PATTERNS = [
         re.compile(r"(?:https?://)?(?:www\.)?youtube\.com/watch\?v=([\w-]{11})"),
         re.compile(r"(?:https?://)?(?:www\.)?youtu\.be/([\w-]{11})"),
     ]
 
+    SUPPORTED_EXTENSIONS = {
+        ".mp4",
+        ".avi",
+        ".mov",
+        ".wmv",
+        ".flv",
+        ".webm",
+        ".mkv",
+        ".m4v",
+        ".3gp",
+    }
+
     @classmethod
     def match_notion(cls, block: Block) -> bool:
         return block.type == BlockType.VIDEO and block.video
 
     @classmethod
-    async def markdown_to_notion(cls, text: str) -> BlockCreateResult:
+    async def markdown_to_notion(cls, text: str) -> Optional[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:
+        # Extract the path/URL
+        path = cls._extract_video_path(text.strip())
+        if not path:
             return None
 
-        url = video_match.group(1)
+        # Check if it's a local file path
+        if cls._is_local_file_path(path):
+            # Verify file exists and has supported extension
+            video_path = Path(path)
+            if not video_path.exists():
+                cls.logger.warning(f"Video file not found: {path}")
+                return None
 
-        vid_id = cls._get_youtube_id(url)
-        if vid_id:
-            url = f"https://www.youtube.com/watch?v={vid_id}"
+            if video_path.suffix.lower() not in cls.SUPPORTED_EXTENSIONS:
+                cls.logger.warning(f"Unsupported video format: {video_path.suffix}")
+                return None
 
-        # 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 "")
+            cls.logger.info(f"Uploading local video file: {path}")
 
-        video_block = FileBlock(
-            type=FileType.EXTERNAL,
-            external=ExternalFile(url=url),
-            caption=caption_rich_text,
-        )
+            # Upload the local video file
+            file_upload_id = await cls._upload_local_file(path, "video")
+            if not file_upload_id:
+                cls.logger.error(f"Failed to upload video file: {path}")
+                return None
+
+            cls.logger.info(
+                f"Successfully uploaded video file with ID: {file_upload_id}"
+            )
+
+            # 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 "")
+
+            video_block = FileBlock(
+                type=FileType.FILE_UPLOAD,
+                file_upload=FileUploadFile(id=file_upload_id),
+                caption=caption_rich_text,
+            )
+
+            return CreateVideoBlock(video=video_block)
+
+        else:
+            # Handle external URL (YouTube, Vimeo, direct links)
+            url = path
 
-        return CreateVideoBlock(video=video_block)
+            # Check for YouTube and normalize URL
+            vid_id = cls._get_youtube_id(url)
+            if vid_id:
+                url = f"https://www.youtube.com/watch?v={vid_id}"
+
+            # 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 "")
+
+            video_block = FileBlock(
+                type=FileType.EXTERNAL,
+                external=ExternalFile(url=url),
+                caption=caption_rich_text,
+            )
+
+            return CreateVideoBlock(video=video_block)
 
     @classmethod
     async def notion_to_markdown(cls, block: Block) -> Optional[str]:
@@ -68,14 +128,16 @@ class VideoElement(BaseBlockElement, CaptionMixin):
             return None
 
         fo = block.video
+        url = None
 
-        # URL ermitteln
+        # Handle both external URLs and uploaded files
         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 url:
+            return None
 
         result = f"[video]({url})"
 
@@ -99,13 +161,27 @@ class VideoElement(BaseBlockElement, CaptionMixin):
         """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",
+            description="Video blocks embed videos from external URLs (YouTube, Vimeo, direct links) or upload local video files with optional captions",
             syntax_examples=[
                 "[video](https://youtube.com/watch?v=abc123)",
                 "[video](https://vimeo.com/123456789)",
+                "[video](./local/tutorial.mp4)",
+                "[video](C:\\Videos\\presentation.mov)",
                 "[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)",
+                "(caption:Tutorial)[video](./demo.mp4)",
+                "[video](./training.mp4)(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.",
+            usage_guidelines="Use for embedding videos from supported platforms or local video files. Supports YouTube, Vimeo, direct video URLs, and local file uploads. Supports common video formats (mp4, avi, mov, wmv, flv, webm, mkv, m4v, 3gp). Caption supports rich text formatting and describes the video content.",
         )
+
+    @classmethod
+    def _extract_video_path(cls, text: str) -> Optional[str]:
+        """Extract video path/URL from text, handling caption patterns."""
+        clean_text = cls.remove_caption(text)
+
+        # Now extract the path/URL from clean text
+        match = cls.VIDEO_PATTERN.search(clean_text)
+        if match:
+            return match.group(1).strip()
+
+        return None

notionary/blocks/video/video_markdown_node.py

@@ -2,29 +2,18 @@ from __future__ import annotations
 
 from typing import Optional
 
-from pydantic import BaseModel
-
-from notionary.markdown.markdown_node import MarkdownNode
+from notionary.blocks.markdown.markdown_node import MarkdownNode
 from notionary.blocks.mixins.captions import CaptionMarkdownNodeMixin
 
 
-class VideoMarkdownBlockParams(BaseModel):
-    url: str
-    caption: Optional[str] = None
-
-
 class VideoMarkdownNode(MarkdownNode, CaptionMarkdownNodeMixin):
     """
+    Enhanced Video node with Pydantic integration.
     Programmatic interface for creating Notion-style video blocks.
     """
 
-    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)
+    url: str
+    caption: Optional[str] = None
 
     def to_markdown(self) -> str:
         """Return the Markdown representation.

notionary/comments/client.py

@@ -208,4 +208,4 @@ class CommentClient(BaseNotionClient):
             content=text,
             display_name=display_name,
             attachments=attachments,
-        )
+        )

notionary/file_upload/client.py

@@ -11,6 +11,7 @@ from notionary.file_upload.models import (
     FileUploadCreateRequest,
     FileUploadListResponse,
     FileUploadResponse,
+    UploadMode,
 )
 
 
@@ -25,7 +26,7 @@ class NotionFileUploadClient(BaseNotionClient):
         filename: str,
         content_type: Optional[str] = None,
         content_length: Optional[int] = None,
-        mode: str = "single_part",
+        mode: UploadMode = UploadMode.SINGLE_PART,
     ) -> Optional[FileUploadResponse]:
         """
         Create a new file upload.
@@ -34,7 +35,7 @@ class NotionFileUploadClient(BaseNotionClient):
             filename: Name of the file (max 900 bytes)
             content_type: MIME type of the file
             content_length: Size of the file in bytes
-            mode: Upload mode ("single_part" or "multi_part")
+            mode: Upload mode (UploadMode.SINGLE_PART or UploadMode.MULTI_PART)
 
         Returns:
             FileUploadResponse or None if failed

notionary/file_upload/models.py

@@ -1,8 +1,17 @@
+from enum import Enum
+
 from typing import Literal, Optional
 
 from pydantic import BaseModel
 
 
+class UploadMode(str, Enum):
+    """Enum for file upload modes."""
+
+    SINGLE_PART = "single_part"
+    MULTI_PART = "multi_part"
+
+
 class FileUploadResponse(BaseModel):
     """
     Represents a Notion file upload object as returned by the File Upload API.
@@ -44,7 +53,7 @@ class FileUploadCreateRequest(BaseModel):
     filename: str
     content_type: Optional[str] = None
     content_length: Optional[int] = None
-    mode: Literal["single_part", "multi_part"] = "single_part"
+    mode: UploadMode = UploadMode.SINGLE_PART
 
     def model_dump(self, **kwargs):
         """Override to exclude None values"""