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

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/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

notionary/page/content/syntax/__init__.py

@@ -1,4 +1,5 @@
 from .grammar import MarkdownGrammar
+from .models import SyntaxDefinition
 from .registry import SyntaxRegistry
 
-__all__ = ["MarkdownGrammar", "SyntaxRegistry"]
+__all__ = ["MarkdownGrammar", "SyntaxDefinition", "SyntaxRegistry"]

notionary/page/content/syntax/registry.py

@@ -4,6 +4,8 @@ from notionary.page.content.syntax.grammar import MarkdownGrammar
 from notionary.page.content.syntax.models import SyntaxDefinition, SyntaxRegistryKey
 
 
+# TODO: Add support for file upload in blocks for file types (refactor file types aswell)
+# differentiate between external and uploaded files (file like blocks)
 class SyntaxRegistry:
     def __init__(self, markdown_markdown_grammar: MarkdownGrammar | None = None) -> None:
         self._markdown_grammar = markdown_markdown_grammar or MarkdownGrammar()
@@ -92,63 +94,79 @@ class SyntaxRegistry:
     def get_heading_syntax(self) -> SyntaxDefinition:
         return self._definitions[SyntaxRegistryKey.HEADING]
 
+    def _create_media_syntax(self, media_type: str, url_pattern: str | None = None) -> SyntaxDefinition:
+        url_pattern = url_pattern or "[^)]+"
+        return SyntaxDefinition(
+            start_delimiter=f"[{media_type}](",
+            end_delimiter=")",
+            regex_pattern=re.compile(rf"(?<!\!)\[{re.escape(media_type)}\]\(({url_pattern})\)"),
+        )
+
+    def _create_url_media_syntax(self, media_type: str) -> SyntaxDefinition:
+        return SyntaxDefinition(
+            start_delimiter=f"[{media_type}](",
+            end_delimiter=")",
+            regex_pattern=re.compile(rf"(?<!\!)\[{re.escape(media_type)}\]\((https?://[^\s)]+)\)"),
+        )
+
     def _register_defaults(self) -> None:
         self._register_audio_syntax()
-        self._register_bookmark_syntax()
-        self._register_image_syntax()
         self._register_video_syntax()
+        self._register_image_syntax()
         self._register_file_syntax()
         self._register_pdf_syntax()
+        self._register_bookmark_syntax()
+        self._register_embed_syntax()
 
-        # List blocks
         self._register_bulleted_list_syntax()
         self._register_numbered_list_syntax()
         self._register_todo_syntax()
         self._register_todo_done_syntax()
 
-        # Container blocks
         self._register_toggle_syntax()
         self._register_toggleable_heading_syntax()
         self._register_callout_syntax()
         self._register_quote_syntax()
         self._register_code_syntax()
 
-        # Column layout blocks
         self._register_column_list_syntax()
         self._register_column_syntax()
 
         self._register_heading_1_syntax()
         self._register_heading_2_syntax()
         self._register_heading_3_syntax()
-        self._register_heading_syntax()  # Shared pattern for regular headings
+        self._register_heading_syntax()
 
         self._register_divider_syntax()
         self._register_breadcrumb_syntax()
         self._register_table_of_contents_syntax()
         self._register_equation_syntax()
-        self._register_embed_syntax()
         self._register_table_syntax()
         self._register_table_row_syntax()
 
-        # Post-processing and utility blocks
         self._register_caption_syntax()
         self._register_space_syntax()
 
     def _register_audio_syntax(self) -> None:
-        definition = SyntaxDefinition(
-            start_delimiter="[audio](",
-            end_delimiter=")",
-            regex_pattern=re.compile(r"\[audio\]\(([^)]+)\)"),
-        )
-        self._definitions[SyntaxRegistryKey.AUDIO] = definition
+        self._definitions[SyntaxRegistryKey.AUDIO] = self._create_media_syntax("audio")
+
+    def _register_video_syntax(self) -> None:
+        self._definitions[SyntaxRegistryKey.VIDEO] = self._create_media_syntax("video")
+
+    def _register_image_syntax(self) -> None:
+        self._definitions[SyntaxRegistryKey.IMAGE] = self._create_media_syntax("image")
+
+    def _register_file_syntax(self) -> None:
+        self._definitions[SyntaxRegistryKey.FILE] = self._create_media_syntax("file")
+
+    def _register_pdf_syntax(self) -> None:
+        self._definitions[SyntaxRegistryKey.PDF] = self._create_media_syntax("pdf")
 
     def _register_bookmark_syntax(self) -> None:
-        definition = SyntaxDefinition(
-            start_delimiter="[bookmark](",
-            end_delimiter=")",
-            regex_pattern=re.compile(r"\[bookmark\]\((https?://[^\s\"]+)\)"),
-        )
-        self._definitions[SyntaxRegistryKey.BOOKMARK] = definition
+        self._definitions[SyntaxRegistryKey.BOOKMARK] = self._create_url_media_syntax("bookmark")
+
+    def _register_embed_syntax(self) -> None:
+        self._definitions[SyntaxRegistryKey.EMBED] = self._create_url_media_syntax("embed")
 
     def _register_breadcrumb_syntax(self) -> None:
         definition = SyntaxDefinition(
@@ -217,14 +235,6 @@ class SyntaxRegistry:
         )
         self._definitions[SyntaxRegistryKey.DIVIDER] = definition
 
-    def _register_embed_syntax(self) -> None:
-        definition = SyntaxDefinition(
-            start_delimiter="[embed](",
-            end_delimiter=")",
-            regex_pattern=re.compile(r"\[embed\]\((https?://[^\s)]+)\)"),
-        )
-        self._definitions[SyntaxRegistryKey.EMBED] = definition
-
     def _register_equation_syntax(self) -> None:
         definition = SyntaxDefinition(
             start_delimiter="$$",
@@ -233,14 +243,6 @@ class SyntaxRegistry:
         )
         self._definitions[SyntaxRegistryKey.EQUATION] = definition
 
-    def _register_file_syntax(self) -> None:
-        definition = SyntaxDefinition(
-            start_delimiter="[file](",
-            end_delimiter=")",
-            regex_pattern=re.compile(r"\[file\]\(([^)]+)\)"),
-        )
-        self._definitions[SyntaxRegistryKey.FILE] = definition
-
     def _register_heading_1_syntax(self) -> None:
         definition = SyntaxDefinition(
             start_delimiter="# ",
@@ -265,14 +267,6 @@ class SyntaxRegistry:
         )
         self._definitions[SyntaxRegistryKey.HEADING_3] = definition
 
-    def _register_image_syntax(self) -> None:
-        definition = SyntaxDefinition(
-            start_delimiter="[image](",
-            end_delimiter=")",
-            regex_pattern=re.compile(r"(?<!!)\[image\]\(([^)]+)\)"),
-        )
-        self._definitions[SyntaxRegistryKey.IMAGE] = definition
-
     def _register_numbered_list_syntax(self) -> None:
         definition = SyntaxDefinition(
             start_delimiter="1. ",
@@ -281,14 +275,6 @@ class SyntaxRegistry:
         )
         self._definitions[SyntaxRegistryKey.NUMBERED_LIST] = definition
 
-    def _register_pdf_syntax(self) -> None:
-        definition = SyntaxDefinition(
-            start_delimiter="[pdf](",
-            end_delimiter=")",
-            regex_pattern=re.compile(r"\[pdf\]\(([^)]+)\)"),
-        )
-        self._definitions[SyntaxRegistryKey.PDF] = definition
-
     def _register_quote_syntax(self) -> None:
         definition = SyntaxDefinition(
             start_delimiter="> ",
@@ -360,14 +346,6 @@ class SyntaxRegistry:
         )
         self._definitions[SyntaxRegistryKey.TOGGLEABLE_HEADING] = definition
 
-    def _register_video_syntax(self) -> None:
-        definition = SyntaxDefinition(
-            start_delimiter="[video](",
-            end_delimiter=")",
-            regex_pattern=re.compile(r"\[video\]\(([^)]+)\)"),
-        )
-        self._definitions[SyntaxRegistryKey.VIDEO] = definition
-
     def _register_caption_syntax(self) -> None:
         definition = SyntaxDefinition(
             start_delimiter="[caption]",

notionary/page/properties/client.py

@@ -4,7 +4,7 @@ from pydantic import BaseModel
 
 from notionary.blocks.rich_text.models import RichText
 from notionary.http.client import NotionHttpClient
-from notionary.page.properties.models import (
+from notionary.page.properties.schemas import (
     DateValue,
     PageCheckboxProperty,
     PageDateProperty,