notionary 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

notionary/page/content/parser/parsers/file_like_block.py

@@ -0,0 +1,89 @@
+from abc import abstractmethod
+from pathlib import Path
+from typing import Generic, TypeVar, override
+
+from notionary.blocks.schemas import (
+    ExternalFileWithCaption,
+    FileUploadFileWithCaption,
+    FileWithCaption,
+)
+from notionary.exceptions.file_upload import UploadFailedError, UploadTimeoutError
+from notionary.file_upload.service import NotionFileUpload
+from notionary.page.content.parser.parsers.base import BlockParsingContext, LineParser
+from notionary.page.content.syntax import SyntaxRegistry
+from notionary.page.content.syntax.models import SyntaxDefinition
+from notionary.shared.models.file import ExternalFileData, FileUploadedFileData
+from notionary.utils.mixins.logging import LoggingMixin
+
+_TBlock = TypeVar("_TBlock")
+
+
+class FileLikeBlockParser(LineParser, LoggingMixin, Generic[_TBlock]):
+    def __init__(self, syntax_registry: SyntaxRegistry, file_upload_service: NotionFileUpload | None = None) -> None:
+        super().__init__(syntax_registry)
+        self._syntax = self._get_syntax(syntax_registry)
+        self._file_upload_service = file_upload_service or NotionFileUpload()
+
+    @abstractmethod
+    def _get_syntax(self, syntax_registry: SyntaxRegistry) -> SyntaxDefinition:
+        pass
+
+    @abstractmethod
+    def _create_block(self, file_data: FileWithCaption) -> _TBlock:
+        pass
+
+    @override
+    def _can_handle(self, context: BlockParsingContext) -> bool:
+        if context.is_inside_parent_context():
+            return False
+        return self._syntax.regex_pattern.search(context.line) is not None
+
+    @override
+    async def _process(self, context: BlockParsingContext) -> None:
+        path_or_url = self._extract_path_or_url(context.line)
+        if not path_or_url:
+            return
+
+        try:
+            if self._is_external_url(path_or_url):
+                file_data = ExternalFileWithCaption(external=ExternalFileData(url=path_or_url))
+            else:
+                file_data = await self._upload_local_file(path_or_url)
+
+            block = self._create_block(file_data)
+            context.result_blocks.append(block)
+
+        except FileNotFoundError:
+            self.logger.warning("File not found: '%s' - skipping block", path_or_url)
+        except PermissionError:
+            self.logger.warning("No permission to read file: '%s' - skipping block", path_or_url)
+        except IsADirectoryError:
+            self.logger.warning("Path is a directory, not a file: '%s' - skipping block", path_or_url)
+        except (UploadFailedError, UploadTimeoutError) as e:
+            self.logger.warning("Upload failed for '%s': %s - skipping block", path_or_url, e)
+        except OSError as e:
+            self.logger.warning("IO error reading file '%s': %s - skipping block", path_or_url, e)
+        except Exception as e:
+            self.logger.warning("Unexpected error processing file '%s': %s - skipping block", path_or_url, e)
+
+    def _extract_path_or_url(self, line: str) -> str | None:
+        match = self._syntax.regex_pattern.search(line)
+        return match.group(1).strip() if match else None
+
+    def _is_external_url(self, path_or_url: str) -> bool:
+        if path_or_url.startswith("http://") or path_or_url.startswith("https://"):
+            return True
+
+        if path_or_url.startswith("data:"):
+            return True
+
+        return path_or_url.startswith("/")
+
+    async def _upload_local_file(self, file_path: str) -> FileUploadFileWithCaption:
+        path = Path(file_path)
+        self.logger.debug("Uploading local file: '%s'", path)
+        upload_response = await self._file_upload_service.upload_file(path)
+
+        return FileUploadFileWithCaption(
+            file_upload=FileUploadedFileData(id=upload_response.id),
+        )

notionary/page/content/parser/parsers/image.py

@@ -1,42 +1,15 @@
-"""Parser for image blocks."""
-
 from typing import override
 
-from notionary.blocks.schemas import (
-    CreateImageBlock,
-    ExternalFile,
-    FileData,
-    FileType,
-)
-from notionary.page.content.parser.parsers.base import BlockParsingContext, LineParser
-from notionary.page.content.syntax import SyntaxRegistry
-
+from notionary.blocks.schemas import CreateImageBlock, ExternalFileWithCaption
+from notionary.page.content.parser.parsers.file_like_block import FileLikeBlockParser
+from notionary.page.content.syntax import SyntaxDefinition, SyntaxRegistry
 
-class ImageParser(LineParser):
-    def __init__(self, syntax_registry: SyntaxRegistry) -> None:
-        super().__init__(syntax_registry)
-        self._syntax = syntax_registry.get_image_syntax()
 
+class ImageParser(FileLikeBlockParser[CreateImageBlock]):
     @override
-    def _can_handle(self, context: BlockParsingContext) -> bool:
-        if context.is_inside_parent_context():
-            return False
-        return self._syntax.regex_pattern.search(context.line) is not None
+    def _get_syntax(self, syntax_registry: SyntaxRegistry) -> SyntaxDefinition:
+        return syntax_registry.get_image_syntax()
 
     @override
-    async def _process(self, context: BlockParsingContext) -> None:
-        url = self._extract_url(context.line)
-        if not url:
-            return
-
-        image_data = FileData(
-            type=FileType.EXTERNAL,
-            external=ExternalFile(url=url),
-            caption=[],
-        )
-        block = CreateImageBlock(image=image_data)
-        context.result_blocks.append(block)
-
-    def _extract_url(self, line: str) -> str | None:
-        match = self._syntax.regex_pattern.search(line)
-        return match.group(1).strip() if match else None
+    def _create_block(self, file_data: ExternalFileWithCaption) -> CreateImageBlock:
+        return CreateImageBlock(image=file_data)

notionary/page/content/parser/parsers/pdf.py

@@ -1,42 +1,15 @@
-"""Parser for PDF blocks."""
-
 from typing import override
 
-from notionary.blocks.schemas import (
-    CreatePdfBlock,
-    ExternalFile,
-    FileData,
-    FileType,
-)
-from notionary.page.content.parser.parsers.base import BlockParsingContext, LineParser
-from notionary.page.content.syntax import SyntaxRegistry
-
+from notionary.blocks.schemas import CreatePdfBlock, ExternalFileWithCaption
+from notionary.page.content.parser.parsers.file_like_block import FileLikeBlockParser
+from notionary.page.content.syntax import SyntaxDefinition, SyntaxRegistry
 
-class PdfParser(LineParser):
-    def __init__(self, syntax_registry: SyntaxRegistry) -> None:
-        super().__init__(syntax_registry)
-        self._syntax = syntax_registry.get_pdf_syntax()
 
+class PdfParser(FileLikeBlockParser[CreatePdfBlock]):
     @override
-    def _can_handle(self, context: BlockParsingContext) -> bool:
-        if context.is_inside_parent_context():
-            return False
-        return self._syntax.regex_pattern.search(context.line) is not None
+    def _get_syntax(self, syntax_registry: SyntaxRegistry) -> SyntaxDefinition:
+        return syntax_registry.get_pdf_syntax()
 
     @override
-    async def _process(self, context: BlockParsingContext) -> None:
-        url = self._extract_url(context.line)
-        if not url:
-            return
-
-        pdf_data = FileData(
-            type=FileType.EXTERNAL,
-            external=ExternalFile(url=url),
-            caption=[],
-        )
-        block = CreatePdfBlock(pdf=pdf_data)
-        context.result_blocks.append(block)
-
-    def _extract_url(self, line: str) -> str | None:
-        match = self._syntax.regex_pattern.search(line)
-        return match.group(1).strip() if match else None
+    def _create_block(self, file_data: ExternalFileWithCaption) -> CreatePdfBlock:
+        return CreatePdfBlock(pdf=file_data)

notionary/page/content/parser/parsers/video.py

@@ -1,42 +1,15 @@
-"""Parser for video blocks."""
-
 from typing import override
 
-from notionary.blocks.schemas import (
-    CreateVideoBlock,
-    ExternalFile,
-    FileData,
-    FileType,
-)
-from notionary.page.content.parser.parsers.base import BlockParsingContext, LineParser
-from notionary.page.content.syntax import SyntaxRegistry
-
+from notionary.blocks.schemas import CreateVideoBlock, ExternalFileWithCaption
+from notionary.page.content.parser.parsers.file_like_block import FileLikeBlockParser
+from notionary.page.content.syntax import SyntaxDefinition, SyntaxRegistry
 
-class VideoParser(LineParser):
-    def __init__(self, syntax_registry: SyntaxRegistry) -> None:
-        super().__init__(syntax_registry)
-        self._syntax = syntax_registry.get_video_syntax()
 
+class VideoParser(FileLikeBlockParser[CreateVideoBlock]):
     @override
-    def _can_handle(self, context: BlockParsingContext) -> bool:
-        if context.is_inside_parent_context():
-            return False
-        return self._syntax.regex_pattern.search(context.line) is not None
+    def _get_syntax(self, syntax_registry: SyntaxRegistry) -> SyntaxDefinition:
+        return syntax_registry.get_video_syntax()
 
     @override
-    async def _process(self, context: BlockParsingContext) -> None:
-        url = self._extract_url(context.line)
-        if not url:
-            return
-
-        video_data = FileData(
-            type=FileType.EXTERNAL,
-            external=ExternalFile(url=url),
-            caption=[],
-        )
-        block = CreateVideoBlock(video=video_data)
-        context.result_blocks.append(block)
-
-    def _extract_url(self, line: str) -> str | None:
-        match = self._syntax.regex_pattern.search(line)
-        return match.group(1).strip() if match else None
+    def _create_block(self, file_data: ExternalFileWithCaption) -> CreateVideoBlock:
+        return CreateVideoBlock(video=file_data)

notionary/page/content/parser/pre_processsing/handlers/__init__.py

@@ -1,11 +1,13 @@
 from .column_syntax import ColumnSyntaxPreProcessor
 from .indentation import IndentationNormalizer
 from .port import PreProcessor
+from .video_syntax import VideoFormatPreProcessor
 from .whitespace import WhitespacePreProcessor
 
 __all__ = [
     "ColumnSyntaxPreProcessor",
     "IndentationNormalizer",
     "PreProcessor",
+    "VideoFormatPreProcessor",
     "WhitespacePreProcessor",
 ]

notionary/page/content/parser/pre_processsing/handlers/column_syntax.py

@@ -4,13 +4,14 @@ from typing import override
 from notionary.exceptions.block_parsing import InsufficientColumnsError, InvalidColumnRatioSumError
 from notionary.page.content.parser.pre_processsing.handlers.port import PreProcessor
 from notionary.page.content.syntax import MarkdownGrammar, SyntaxRegistry
+from notionary.utils.decorators import time_execution_sync
 from notionary.utils.mixins.logging import LoggingMixin
 
-RATIO_TOLERANCE = 0.0001
-MINIMUM_COLUMNS = 2
-
 
 class ColumnSyntaxPreProcessor(PreProcessor, LoggingMixin):
+    _RATIO_TOLERANCE = 0.0001
+    _MINIMUM_COLUMNS = 2
+
     def __init__(
         self, syntax_registry: SyntaxRegistry | None = None, markdown_grammar: MarkdownGrammar | None = None
     ) -> None:
@@ -24,6 +25,7 @@ class ColumnSyntaxPreProcessor(PreProcessor, LoggingMixin):
         self._column_pattern = self._syntax_registry.get_column_syntax().regex_pattern
 
     @override
+    @time_execution_sync()
     def process(self, markdown_text: str) -> str:
         if not self._contains_column_lists(markdown_text):
             return markdown_text
@@ -96,8 +98,10 @@ class ColumnSyntaxPreProcessor(PreProcessor, LoggingMixin):
         return list(self._column_pattern.finditer(content))
 
     def _validate_minimum_column_count(self, column_count: int) -> None:
-        if column_count < MINIMUM_COLUMNS:
-            self.logger.error(f"Column list must contain at least {MINIMUM_COLUMNS} columns, found {column_count}")
+        if column_count < self._MINIMUM_COLUMNS:
+            self.logger.error(
+                f"Column list must contain at least {self._MINIMUM_COLUMNS} columns, found {column_count}"
+            )
             raise InsufficientColumnsError(column_count)
 
     def _extract_column_ratios(self, column_matches: list[re.Match]) -> list[float]:
@@ -120,11 +124,11 @@ class ColumnSyntaxPreProcessor(PreProcessor, LoggingMixin):
         total_ratio = sum(ratios)
 
         if not self._is_ratio_sum_valid(total_ratio):
-            self.logger.error(f"Column ratios must sum to 1.0 (±{RATIO_TOLERANCE}), but sum to {total_ratio:.4f}")
-            raise InvalidColumnRatioSumError(total_ratio, RATIO_TOLERANCE)
+            self.logger.error(f"Column ratios must sum to 1.0 (±{self._RATIO_TOLERANCE}), but sum to {total_ratio:.4f}")
+            raise InvalidColumnRatioSumError(total_ratio, self._RATIO_TOLERANCE)
 
     def _should_validate_ratios(self, ratios: list[float], column_count: int) -> bool:
         return len(ratios) > 0 and len(ratios) == column_count
 
     def _is_ratio_sum_valid(self, total: float) -> bool:
-        return abs(total - 1.0) <= RATIO_TOLERANCE
+        return abs(total - 1.0) <= self._RATIO_TOLERANCE

notionary/page/content/parser/pre_processsing/handlers/indentation.py

@@ -3,6 +3,7 @@ from typing import override
 
 from notionary.page.content.parser.pre_processsing.handlers.port import PreProcessor
 from notionary.page.content.syntax import MarkdownGrammar, SyntaxRegistry
+from notionary.utils.decorators import time_execution_sync
 from notionary.utils.mixins.logging import LoggingMixin
 
 
@@ -18,6 +19,7 @@ class IndentationNormalizer(PreProcessor, LoggingMixin):
         self._code_block_start_delimiter = self._syntax_registry.get_code_syntax().start_delimiter
 
     @override
+    @time_execution_sync()
     def process(self, markdown_text: str) -> str:
         if self._is_empty(markdown_text):
             return ""

notionary/page/content/parser/pre_processsing/handlers/video_syntax.py

@@ -0,0 +1,66 @@
+import re
+from typing import override
+from urllib.parse import urlparse
+
+from notionary.blocks.enums import VideoFileType
+from notionary.exceptions import UnsupportedVideoFormatError
+from notionary.page.content.parser.pre_processsing.handlers.port import PreProcessor
+from notionary.page.content.syntax import SyntaxRegistry
+from notionary.utils.decorators import time_execution_sync
+from notionary.utils.mixins.logging import LoggingMixin
+
+
+class VideoFormatPreProcessor(PreProcessor, LoggingMixin):
+    YOUTUBE_WATCH_PATTERN = re.compile(r"^https?://(?:www\.)?youtube\.com/watch\?.*v=[\w-]+", re.IGNORECASE)
+    YOUTUBE_EMBED_PATTERN = re.compile(r"^https?://(?:www\.)?youtube\.com/embed/[\w-]+", re.IGNORECASE)
+
+    def __init__(self, syntax_registry: SyntaxRegistry | None = None) -> None:
+        super().__init__()
+        self._syntax_registry = syntax_registry or SyntaxRegistry()
+        self._video_syntax = self._syntax_registry.get_video_syntax()
+
+    @override
+    @time_execution_sync()
+    def process(self, markdown_text: str) -> str:
+        lines = markdown_text.split("\n")
+        validated_lines = [self._validate_or_reject_line(line) for line in lines]
+        return "\n".join(validated_lines)
+
+    def _validate_or_reject_line(self, line: str) -> str:
+        if not self._contains_video_block(line):
+            return line
+
+        url = self._extract_url_from_video_block(line)
+
+        if self._is_supported_video_url(url):
+            return line
+
+        supported_formats = list(VideoFileType.get_all_extensions())
+        raise UnsupportedVideoFormatError(url, supported_formats)
+
+    def _contains_video_block(self, line: str) -> bool:
+        return self._video_syntax.regex_pattern.search(line) is not None
+
+    def _extract_url_from_video_block(self, line: str) -> str:
+        match = self._video_syntax.regex_pattern.search(line)
+        return match.group(1).strip() if match else ""
+
+    def _is_supported_video_url(self, url: str) -> bool:
+        return (
+            self._is_youtube_video(url)
+            or self._has_valid_video_extension(url)
+            or self._url_path_has_valid_extension(url)
+        )
+
+    def _is_youtube_video(self, url: str) -> bool:
+        return bool(self.YOUTUBE_WATCH_PATTERN.match(url) or self.YOUTUBE_EMBED_PATTERN.match(url))
+
+    def _has_valid_video_extension(self, url: str) -> bool:
+        return VideoFileType.is_valid_extension(url)
+
+    def _url_path_has_valid_extension(self, url: str) -> bool:
+        try:
+            parsed_url = urlparse(url)
+            return VideoFileType.is_valid_extension(parsed_url.path.lower())
+        except Exception:
+            return False

notionary/page/content/parser/pre_processsing/handlers/whitespace.py

@@ -1,10 +1,12 @@
 from typing import override
 
 from notionary.page.content.parser.pre_processsing.handlers.port import PreProcessor
+from notionary.utils.decorators import time_execution_sync
 
 
 class WhitespacePreProcessor(PreProcessor):
     @override
+    @time_execution_sync()
     def process(self, markdown_text: str) -> str:
         if not markdown_text:
             return ""

notionary/page/content/renderer/renderers/audio.py

@@ -1,31 +1,19 @@
 from typing import override
 
-from notionary.blocks.schemas import Block, BlockType
-from notionary.page.content.renderer.renderers.captioned_block import CaptionedBlockRenderer
+from notionary.blocks.schemas import Block, BlockType, ExternalFileWithCaption, NotionHostedFileWithCaption
+from notionary.page.content.renderer.renderers.file_like_block import FileLikeBlockRenderer
+from notionary.page.content.syntax import SyntaxDefinition
 
 
-class AudioRenderer(CaptionedBlockRenderer):
+class AudioRenderer(FileLikeBlockRenderer):
     @override
     def _can_handle(self, block: Block) -> bool:
         return block.type == BlockType.AUDIO
 
     @override
-    async def _render_main_content(self, block: Block) -> str:
-        url = self._extract_audio_url(block)
+    def _get_syntax(self) -> SyntaxDefinition:
+        return self._syntax_registry.get_audio_syntax()
 
-        if not url:
-            return ""
-
-        syntax = self._syntax_registry.get_audio_syntax()
-        return f"{syntax.start_delimiter}{url}{syntax.end_delimiter}"
-
-    def _extract_audio_url(self, block: Block) -> str:
-        if not block.audio:
-            return ""
-
-        if block.audio.external:
-            return block.audio.external.url or ""
-        elif block.audio.file:
-            return block.audio.file.url or ""
-
-        return ""
+    @override
+    def _get_file_data(self, block: Block) -> ExternalFileWithCaption | NotionHostedFileWithCaption | None:
+        return block.audio

notionary/page/content/renderer/renderers/file.py

@@ -1,34 +1,22 @@
 from typing import override
 
-from notionary.blocks.schemas import Block, BlockType
-from notionary.page.content.renderer.renderers.captioned_block import CaptionedBlockRenderer
+from notionary.blocks.schemas import Block, BlockType, ExternalFileWithCaption, NotionHostedFileWithCaption
+from notionary.page.content.renderer.renderers.file_like_block import FileLikeBlockRenderer
+from notionary.page.content.syntax import SyntaxDefinition
 
 
-class FileRenderer(CaptionedBlockRenderer):
+class FileRenderer(FileLikeBlockRenderer):
     @override
     def _can_handle(self, block: Block) -> bool:
         return block.type == BlockType.FILE
 
     @override
-    async def _render_main_content(self, block: Block) -> str:
-        url = self._extract_file_url(block)
+    def _get_syntax(self) -> SyntaxDefinition:
+        return self._syntax_registry.get_file_syntax()
 
-        if not url:
-            return ""
-
-        syntax = self._syntax_registry.get_file_syntax()
-        return f"{syntax.start_delimiter}{url}{syntax.end_delimiter}"
-
-    def _extract_file_url(self, block: Block) -> str:
-        if not block.file:
-            return ""
-
-        if block.file.external:
-            return block.file.external.url or ""
-        elif block.file.file:
-            return block.file.file.url or ""
-
-        return ""
+    @override
+    def _get_file_data(self, block: Block) -> ExternalFileWithCaption | NotionHostedFileWithCaption | None:
+        return block.file
 
     def _extract_file_name(self, block: Block) -> str:
         if not block.file:

notionary/page/content/renderer/renderers/file_like_block.py

@@ -0,0 +1,43 @@
+from abc import abstractmethod
+from typing import override
+
+from notionary.blocks.schemas import (
+    Block,
+    ExternalFileWithCaption,
+    NotionHostedFileWithCaption,
+)
+from notionary.page.content.renderer.renderers.captioned_block import CaptionedBlockRenderer
+from notionary.page.content.syntax import SyntaxDefinition
+
+
+class FileLikeBlockRenderer(CaptionedBlockRenderer):
+    @abstractmethod
+    def _get_syntax(self) -> SyntaxDefinition:
+        pass
+
+    @abstractmethod
+    def _get_file_data(self, block: Block) -> ExternalFileWithCaption | NotionHostedFileWithCaption | None:
+        pass
+
+    @override
+    async def _render_main_content(self, block: Block) -> str:
+        url = self._extract_url(block)
+
+        if not url:
+            return ""
+
+        syntax = self._get_syntax()
+        return f"{syntax.start_delimiter}{url}{syntax.end_delimiter}"
+
+    def _extract_url(self, block: Block) -> str:
+        file_data = self._get_file_data(block)
+
+        if not file_data:
+            return ""
+
+        if isinstance(file_data, ExternalFileWithCaption):
+            return file_data.external.url or ""
+        elif isinstance(file_data, NotionHostedFileWithCaption):
+            return file_data.file.url or ""
+
+        return ""

notionary/page/content/renderer/renderers/image.py

@@ -1,31 +1,19 @@
 from typing import override
 
-from notionary.blocks.schemas import Block, BlockType
-from notionary.page.content.renderer.renderers.captioned_block import CaptionedBlockRenderer
+from notionary.blocks.schemas import Block, BlockType, ExternalFileWithCaption, NotionHostedFileWithCaption
+from notionary.page.content.renderer.renderers.file_like_block import FileLikeBlockRenderer
+from notionary.page.content.syntax import SyntaxDefinition
 
 
-class ImageRenderer(CaptionedBlockRenderer):
+class ImageRenderer(FileLikeBlockRenderer):
     @override
     def _can_handle(self, block: Block) -> bool:
         return block.type == BlockType.IMAGE
 
     @override
-    async def _render_main_content(self, block: Block) -> str:
-        url = self._extract_image_url(block)
+    def _get_syntax(self) -> SyntaxDefinition:
+        return self._syntax_registry.get_image_syntax()
 
-        if not url:
-            return ""
-
-        syntax = self._syntax_registry.get_image_syntax()
-        return f"{syntax.start_delimiter}{url}{syntax.end_delimiter}"
-
-    def _extract_image_url(self, block: Block) -> str:
-        if not block.image:
-            return ""
-
-        if block.image.external:
-            return block.image.external.url or ""
-        elif block.image.file:
-            return block.image.file.url or ""
-
-        return ""
+    @override
+    def _get_file_data(self, block: Block) -> ExternalFileWithCaption | NotionHostedFileWithCaption | None:
+        return block.image

notionary/page/content/renderer/renderers/pdf.py

@@ -1,31 +1,19 @@
 from typing import override
 
-from notionary.blocks.schemas import Block, BlockType
-from notionary.page.content.renderer.renderers.captioned_block import CaptionedBlockRenderer
+from notionary.blocks.schemas import Block, BlockType, ExternalFileWithCaption, NotionHostedFileWithCaption
+from notionary.page.content.renderer.renderers.file_like_block import FileLikeBlockRenderer
+from notionary.page.content.syntax import SyntaxDefinition
 
 
-class PdfRenderer(CaptionedBlockRenderer):
+class PdfRenderer(FileLikeBlockRenderer):
     @override
     def _can_handle(self, block: Block) -> bool:
         return block.type == BlockType.PDF
 
     @override
-    async def _render_main_content(self, block: Block) -> str:
-        url = self._extract_pdf_url(block)
+    def _get_syntax(self) -> SyntaxDefinition:
+        return self._syntax_registry.get_pdf_syntax()
 
-        if not url:
-            return ""
-
-        syntax = self._syntax_registry.get_pdf_syntax()
-        return f"{syntax.start_delimiter}{url}{syntax.end_delimiter}"
-
-    def _extract_pdf_url(self, block: Block) -> str:
-        if not block.pdf:
-            return ""
-
-        if block.pdf.external:
-            return block.pdf.external.url or ""
-        elif block.pdf.file:
-            return block.pdf.file.url or ""
-
-        return ""
+    @override
+    def _get_file_data(self, block: Block) -> ExternalFileWithCaption | NotionHostedFileWithCaption | None:
+        return block.pdf

notionary/page/content/renderer/renderers/video.py

@@ -1,31 +1,19 @@
 from typing import override
 
-from notionary.blocks.schemas import Block, BlockType
-from notionary.page.content.renderer.renderers.captioned_block import CaptionedBlockRenderer
+from notionary.blocks.schemas import Block, BlockType, ExternalFileWithCaption, NotionHostedFileWithCaption
+from notionary.page.content.renderer.renderers.file_like_block import FileLikeBlockRenderer
+from notionary.page.content.syntax import SyntaxDefinition
 
 
-class VideoRenderer(CaptionedBlockRenderer):
+class VideoRenderer(FileLikeBlockRenderer):
     @override
     def _can_handle(self, block: Block) -> bool:
         return block.type == BlockType.VIDEO
 
     @override
-    async def _render_main_content(self, block: Block) -> str:
-        url = self._extract_video_url(block)
+    def _get_syntax(self) -> SyntaxDefinition:
+        return self._syntax_registry.get_video_syntax()
 
-        if not url:
-            return ""
-
-        syntax = self._syntax_registry.get_video_syntax()
-        return f"{syntax.start_delimiter}{url}{syntax.end_delimiter}"
-
-    def _extract_video_url(self, block: Block) -> str:
-        if not block.video:
-            return ""
-
-        if block.video.external:
-            return block.video.external.url or ""
-        elif block.video.file:
-            return block.video.file.url or ""
-
-        return ""
+    @override
+    def _get_file_data(self, block: Block) -> ExternalFileWithCaption | NotionHostedFileWithCaption | None:
+        return block.video