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

notionary/page/content/parser/post_processing/handlers/rich_text_length.py

@@ -26,7 +26,9 @@ class RichTextLengthTruncationPostProcessor(PostProcessor, LoggingMixin):
         flattened_blocks = self._flatten_blocks(blocks)
         return [self._process_block(block) for block in flattened_blocks]
 
-    def _flatten_blocks(self, blocks: list[_NestedBlockList]) -> list[BlockCreatePayload]:
+    def _flatten_blocks(
+        self, blocks: list[_NestedBlockList]
+    ) -> list[BlockCreatePayload]:
         flattened: list[BlockCreatePayload] = []
 
         for item in blocks:
@@ -92,4 +94,8 @@ class RichTextLengthTruncationPostProcessor(PostProcessor, LoggingMixin):
         return content[:cutoff] + "..."
 
     def _is_text_type(self, rich_text: RichText) -> bool:
-        return rich_text.type == RichTextType.TEXT and rich_text.text and rich_text.text.content
+        return (
+            rich_text.type == RichTextType.TEXT
+            and rich_text.text
+            and rich_text.text.content
+        )

notionary/page/content/parser/post_processing/handlers/rich_text_length_truncation.py

@@ -27,7 +27,9 @@ class RichTextLengthTruncationPostProcessor(PostProcessor, LoggingMixin):
         flattened_blocks = self._flatten_blocks(blocks)
         return [self._process_block(block) for block in flattened_blocks]
 
-    def _flatten_blocks(self, blocks: list[_NestedBlockList]) -> list[BlockCreatePayload]:
+    def _flatten_blocks(
+        self, blocks: list[_NestedBlockList]
+    ) -> list[BlockCreatePayload]:
         flattened: list[BlockCreatePayload] = []
 
         for item in blocks:
@@ -111,4 +113,8 @@ class RichTextLengthTruncationPostProcessor(PostProcessor, LoggingMixin):
         return content[:cutoff] + self.ELLIPSIS
 
     def _is_text_type(self, rich_text: RichText) -> bool:
-        return rich_text.type == RichTextType.TEXT and rich_text.text is not None and rich_text.text.content
+        return (
+            rich_text.type == RichTextType.TEXT
+            and rich_text.text is not None
+            and rich_text.text.content
+        )

notionary/page/content/parser/post_processing/service.py

@@ -9,7 +9,9 @@ class BlockPostProcessor:
     def register(self, processor: PostProcessor) -> None:
         self._processors.append(processor)
 
-    def process(self, created_blocks: list[BlockCreatePayload]) -> list[BlockCreatePayload]:
+    def process(
+        self, created_blocks: list[BlockCreatePayload]
+    ) -> list[BlockCreatePayload]:
         result = created_blocks
         for processor in self._processors:
             result = processor.process(created_blocks)

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

@@ -1,9 +1,15 @@
 import re
 from typing import override
 
-from notionary.exceptions.block_parsing import InsufficientColumnsError, InvalidColumnRatioSumError
+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.page.content.syntax.definition import (
+    MarkdownGrammar,
+    SyntaxDefinitionRegistry,
+)
 from notionary.utils.decorators import time_execution_sync
 from notionary.utils.mixins.logging import LoggingMixin
 
@@ -13,15 +19,21 @@ class ColumnSyntaxPreProcessor(PreProcessor, LoggingMixin):
     _MINIMUM_COLUMNS = 2
 
     def __init__(
-        self, syntax_registry: SyntaxRegistry | None = None, markdown_grammar: MarkdownGrammar | None = None
+        self,
+        syntax_registry: SyntaxDefinitionRegistry | None = None,
+        markdown_grammar: MarkdownGrammar | None = None,
     ) -> None:
         super().__init__()
-        self._syntax_registry = syntax_registry or SyntaxRegistry()
+        self._syntax_registry = syntax_registry or SyntaxDefinitionRegistry()
         self._markdown_grammar = markdown_grammar or MarkdownGrammar()
 
         self._spaces_per_nesting_level = self._markdown_grammar.spaces_per_nesting_level
-        self._column_list_delimiter = self._syntax_registry.get_column_list_syntax().start_delimiter
-        self._column_delimiter = self._syntax_registry.get_column_syntax().start_delimiter
+        self._column_list_delimiter = (
+            self._syntax_registry.get_column_list_syntax().start_delimiter
+        )
+        self._column_delimiter = (
+            self._syntax_registry.get_column_syntax().start_delimiter
+        )
         self._column_pattern = self._syntax_registry.get_column_syntax().regex_pattern
 
     @override
@@ -124,7 +136,9 @@ 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 (±{self._RATIO_TOLERANCE}), but sum to {total_ratio:.4f}")
+            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:

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

@@ -2,21 +2,28 @@ import math
 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.page.content.syntax.definition import (
+    MarkdownGrammar,
+    SyntaxDefinitionRegistry,
+)
 from notionary.utils.decorators import time_execution_sync
 from notionary.utils.mixins.logging import LoggingMixin
 
 
 class IndentationNormalizer(PreProcessor, LoggingMixin):
     def __init__(
-        self, syntax_registry: SyntaxRegistry | None = None, markdown_grammar: MarkdownGrammar | None = None
+        self,
+        syntax_registry: SyntaxDefinitionRegistry | None = None,
+        markdown_grammar: MarkdownGrammar | None = None,
     ) -> None:
         super().__init__()
-        self._syntax_registry = syntax_registry or SyntaxRegistry()
+        self._syntax_registry = syntax_registry or SyntaxDefinitionRegistry()
         self._markdown_grammar = markdown_grammar or MarkdownGrammar()
 
         self._spaces_per_nesting_level = self._markdown_grammar.spaces_per_nesting_level
-        self._code_block_start_delimiter = self._syntax_registry.get_code_syntax().start_delimiter
+        self._code_block_start_delimiter = (
+            self._syntax_registry.get_code_syntax().start_delimiter
+        )
 
     @override
     @time_execution_sync()

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

@@ -5,18 +5,22 @@ 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.page.content.syntax.definition import SyntaxDefinitionRegistry
 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)
+    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:
+    def __init__(self, syntax_registry: SyntaxDefinitionRegistry | None = None) -> None:
         super().__init__()
-        self._syntax_registry = syntax_registry or SyntaxRegistry()
+        self._syntax_registry = syntax_registry or SyntaxDefinitionRegistry()
         self._video_syntax = self._syntax_registry.get_video_syntax()
 
     @override
@@ -53,7 +57,10 @@ class VideoFormatPreProcessor(PreProcessor, LoggingMixin):
         )
 
     def _is_youtube_video(self, url: str) -> bool:
-        return bool(self.YOUTUBE_WATCH_PATTERN.match(url) or self.YOUTUBE_EMBED_PATTERN.match(url))
+        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)

notionary/page/content/parser/service.py

@@ -11,7 +11,10 @@ from notionary.utils.mixins.logging import LoggingMixin
 
 class MarkdownToNotionConverter(LoggingMixin):
     def __init__(
-        self, line_parser: LineParser, pre_processor: MarkdownPreProcessor, post_processor: BlockPostProcessor
+        self,
+        line_parser: LineParser,
+        pre_processor: MarkdownPreProcessor,
+        post_processor: BlockPostProcessor,
     ) -> None:
         self._line_parser = line_parser
         self._pre_processor = pre_processor

notionary/page/content/renderer/context.py

@@ -1,7 +1,7 @@
 from collections.abc import Awaitable, Callable
 
 from notionary.blocks.schemas import Block
-from notionary.page.content.syntax.grammar import MarkdownGrammar
+from notionary.page.content.syntax.definition.grammar import MarkdownGrammar
 
 ConvertChildrenCallback = Callable[[list[Block], int], Awaitable[str]]
 
@@ -25,14 +25,20 @@ class MarkdownRenderingContext:
     async def render_children(self) -> str:
         return await self._convert_children_to_markdown(self.indent_level)
 
-    async def render_children_with_additional_indent(self, additional_indent: int) -> str:
-        return await self._convert_children_to_markdown(self.indent_level + additional_indent)
+    async def render_children_with_additional_indent(
+        self, additional_indent: int
+    ) -> str:
+        return await self._convert_children_to_markdown(
+            self.indent_level + additional_indent
+        )
 
     async def _convert_children_to_markdown(self, indent_level: int) -> str:
         if not self._has_children() or not self.convert_children_callback:
             return ""
 
-        return await self.convert_children_callback(self._get_children_blocks(), indent_level)
+        return await self.convert_children_callback(
+            self._get_children_blocks(), indent_level
+        )
 
     def _get_children_blocks(self) -> list[Block]:
         if self._has_children():
@@ -40,7 +46,11 @@ class MarkdownRenderingContext:
         return []
 
     def _has_children(self) -> bool:
-        return self.block.has_children and self.block.children and len(self.block.children) > 0
+        return (
+            self.block.has_children
+            and self.block.children
+            and len(self.block.children) > 0
+        )
 
     def indent_text(self, text: str) -> str:
         if not text:

notionary/page/content/renderer/factory.py

@@ -29,17 +29,19 @@ from notionary.page.content.renderer.renderers import (
     ToggleRenderer,
     VideoRenderer,
 )
-from notionary.page.content.syntax import SyntaxRegistry
+from notionary.page.content.syntax.definition import SyntaxDefinitionRegistry
 
 
 class RendererChainFactory:
     def __init__(
         self,
         rich_text_markdown_converter: RichTextToMarkdownConverter | None = None,
-        syntax_registry: SyntaxRegistry | None = None,
+        syntax_registry: SyntaxDefinitionRegistry | None = None,
     ) -> None:
-        self._rich_text_markdown_converter = rich_text_markdown_converter or RichTextToMarkdownConverter()
-        self._syntax_registry = syntax_registry or SyntaxRegistry()
+        self._rich_text_markdown_converter = (
+            rich_text_markdown_converter or RichTextToMarkdownConverter()
+        )
+        self._syntax_registry = syntax_registry or SyntaxDefinitionRegistry()
 
     def create(self) -> BlockRenderer:
         # Strukturelle Blocks
@@ -219,13 +221,17 @@ class RendererChainFactory:
         return BreadcrumbRenderer(syntax_registry=self._syntax_registry)
 
     def _create_table_renderer(self) -> TableRenderer:
-        return TableRenderer(rich_text_markdown_converter=self._rich_text_markdown_converter)
+        return TableRenderer(
+            rich_text_markdown_converter=self._rich_text_markdown_converter
+        )
 
     def _create_table_row_handler(self) -> TableRowHandler:
         return TableRowHandler()
 
     def _create_paragraph_renderer(self) -> ParagraphRenderer:
-        return ParagraphRenderer(rich_text_markdown_converter=self._rich_text_markdown_converter)
+        return ParagraphRenderer(
+            rich_text_markdown_converter=self._rich_text_markdown_converter
+        )
 
     def _create_fallback_renderer(self) -> FallbackRenderer:
         return FallbackRenderer()

notionary/page/content/renderer/post_processing/handlers/numbered_list.py

@@ -3,7 +3,7 @@ from enum import IntEnum
 from typing import override
 
 from notionary.page.content.renderer.post_processing.port import PostProcessor
-from notionary.page.content.syntax.grammar import MarkdownGrammar
+from notionary.page.content.syntax.definition.grammar import MarkdownGrammar
 
 
 class _NumberingStyle(IntEnum):
@@ -89,7 +89,9 @@ class NumberedListPlaceholderReplacerPostProcessor(PostProcessor):
     def __init__(self, markdown_grammar: MarkdownGrammar | None = None) -> None:
         self._markdown_grammar = markdown_grammar or MarkdownGrammar()
         self._spaces_per_nesting_level = self._markdown_grammar.spaces_per_nesting_level
-        self._numbered_list_placeholder = self._markdown_grammar.numbered_list_placeholder
+        self._numbered_list_placeholder = (
+            self._markdown_grammar.numbered_list_placeholder
+        )
 
     @override
     def process(self, markdown_text: str) -> str:
@@ -130,23 +132,31 @@ class NumberedListPlaceholderReplacerPostProcessor(PostProcessor):
         return match.group(1) if match else ""
 
     def _extract_content(self, line: str) -> str:
-        match = re.match(rf"^\s*{re.escape(self._numbered_list_placeholder)}\.\s*(.*)", line)
+        match = re.match(
+            rf"^\s*{re.escape(self._numbered_list_placeholder)}\.\s*(.*)", line
+        )
         return match.group(1) if match else ""
 
     def _is_placeholder_list_item(self, line: str) -> bool:
-        return bool(re.match(rf"^\s*{re.escape(self._numbered_list_placeholder)}\.", line))
+        return bool(
+            re.match(rf"^\s*{re.escape(self._numbered_list_placeholder)}\.", line)
+        )
 
-    def _is_blank_between_list_items(self, lines: list[str], current_index: int, processed_lines: list[str]) -> bool:
+    def _is_blank_between_list_items(
+        self, lines: list[str], current_index: int, processed_lines: list[str]
+    ) -> bool:
         if not self._is_blank(lines[current_index]):
             return False
 
-        previous_line_was_list_item = processed_lines and self._looks_like_numbered_list_item(processed_lines[-1])
+        previous_line_was_list_item = (
+            processed_lines and self._looks_like_numbered_list_item(processed_lines[-1])
+        )
         if not previous_line_was_list_item:
             return False
 
-        next_line_is_list_item = current_index + 1 < len(lines) and self._is_placeholder_list_item(
-            lines[current_index + 1]
-        )
+        next_line_is_list_item = current_index + 1 < len(
+            lines
+        ) and self._is_placeholder_list_item(lines[current_index + 1])
         return next_line_is_list_item
 
     def _is_blank(self, line: str) -> bool:

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

@@ -1,8 +1,15 @@
 from typing import override
 
-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
+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.definition import EnclosedSyntaxDefinition
 
 
 class AudioRenderer(FileLikeBlockRenderer):
@@ -11,9 +18,11 @@ class AudioRenderer(FileLikeBlockRenderer):
         return block.type == BlockType.AUDIO
 
     @override
-    def _get_syntax(self) -> SyntaxDefinition:
+    def _get_syntax(self) -> EnclosedSyntaxDefinition:
         return self._syntax_registry.get_audio_syntax()
 
     @override
-    def _get_file_data(self, block: Block) -> ExternalFileWithCaption | NotionHostedFileWithCaption | None:
+    def _get_file_data(
+        self, block: Block
+    ) -> ExternalFileWithCaption | NotionHostedFileWithCaption | None:
         return block.audio

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

@@ -4,12 +4,12 @@ from abc import ABC, abstractmethod
 
 from notionary.blocks.schemas import Block
 from notionary.page.content.renderer.context import MarkdownRenderingContext
-from notionary.page.content.syntax import SyntaxRegistry
+from notionary.page.content.syntax.definition import SyntaxDefinitionRegistry
 
 
 class BlockRenderer(ABC):
-    def __init__(self, syntax_registry: SyntaxRegistry | None = None) -> None:
-        self._syntax_registry = syntax_registry or SyntaxRegistry()
+    def __init__(self, syntax_registry: SyntaxDefinitionRegistry | None = None) -> None:
+        self._syntax_registry = syntax_registry or SyntaxDefinitionRegistry()
         self._next_handler: BlockRenderer | None = None
 
     def set_next(self, handler: BlockRenderer) -> BlockRenderer:

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

@@ -1,7 +1,9 @@
 from typing import override
 
 from notionary.blocks.schemas import Block, BlockType
-from notionary.page.content.renderer.renderers.captioned_block import CaptionedBlockRenderer
+from notionary.page.content.renderer.renderers.captioned_block import (
+    CaptionedBlockRenderer,
+)
 
 
 class BookmarkRenderer(CaptionedBlockRenderer):

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

@@ -1,20 +1,24 @@
 from typing import override
 
-from notionary.blocks.rich_text.rich_text_markdown_converter import RichTextToMarkdownConverter
+from notionary.blocks.rich_text.rich_text_markdown_converter import (
+    RichTextToMarkdownConverter,
+)
 from notionary.blocks.schemas import Block, BlockType
 from notionary.page.content.renderer.context import MarkdownRenderingContext
 from notionary.page.content.renderer.renderers.base import BlockRenderer
-from notionary.page.content.syntax import SyntaxRegistry
+from notionary.page.content.syntax.definition import SyntaxDefinitionRegistry
 
 
 class BulletedListRenderer(BlockRenderer):
     def __init__(
         self,
-        syntax_registry: SyntaxRegistry | None = None,
+        syntax_registry: SyntaxDefinitionRegistry | None = None,
         rich_text_markdown_converter: RichTextToMarkdownConverter | None = None,
     ) -> None:
         super().__init__(syntax_registry=syntax_registry)
-        self._rich_text_markdown_converter = rich_text_markdown_converter or RichTextToMarkdownConverter()
+        self._rich_text_markdown_converter = (
+            rich_text_markdown_converter or RichTextToMarkdownConverter()
+        )
 
     @override
     def _can_handle(self, block: Block) -> bool:
@@ -45,4 +49,6 @@ class BulletedListRenderer(BlockRenderer):
         if not block.bulleted_list_item or not block.bulleted_list_item.rich_text:
             return None
 
-        return await self._rich_text_markdown_converter.to_markdown(block.bulleted_list_item.rich_text)
+        return await self._rich_text_markdown_converter.to_markdown(
+            block.bulleted_list_item.rich_text
+        )

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

@@ -1,20 +1,24 @@
 from typing import override
 
-from notionary.blocks.rich_text.rich_text_markdown_converter import RichTextToMarkdownConverter
+from notionary.blocks.rich_text.rich_text_markdown_converter import (
+    RichTextToMarkdownConverter,
+)
 from notionary.blocks.schemas import Block, BlockType
 from notionary.page.content.renderer.context import MarkdownRenderingContext
 from notionary.page.content.renderer.renderers.base import BlockRenderer
-from notionary.page.content.syntax import SyntaxRegistry
+from notionary.page.content.syntax.definition import SyntaxDefinitionRegistry
 
 
 class CalloutRenderer(BlockRenderer):
     def __init__(
         self,
-        syntax_registry: SyntaxRegistry | None = None,
+        syntax_registry: SyntaxDefinitionRegistry | None = None,
         rich_text_markdown_converter: RichTextToMarkdownConverter | None = None,
     ) -> None:
         super().__init__(syntax_registry=syntax_registry)
-        self._rich_text_markdown_converter = rich_text_markdown_converter or RichTextToMarkdownConverter()
+        self._rich_text_markdown_converter = (
+            rich_text_markdown_converter or RichTextToMarkdownConverter()
+        )
 
     @override
     def _can_handle(self, block: Block) -> bool:
@@ -30,9 +34,15 @@ class CalloutRenderer(BlockRenderer):
 
         icon = await self._extract_callout_icon(context.block)
 
-        callout_start_delimiter = self._syntax_registry.get_callout_syntax().start_delimiter
+        callout_start_delimiter = (
+            self._syntax_registry.get_callout_syntax().start_delimiter
+        )
 
-        result = f'{callout_start_delimiter}({content} "{icon}")' if icon else f"{callout_start_delimiter}({content})"
+        result = (
+            f'{callout_start_delimiter}({content} "{icon}")'
+            if icon
+            else f"{callout_start_delimiter}({content})"
+        )
 
         if context.indent_level > 0:
             result = context.indent_text(result)
@@ -47,4 +57,6 @@ class CalloutRenderer(BlockRenderer):
     async def _extract_callout_content(self, block: Block) -> str:
         if not block.callout or not block.callout.rich_text:
             return ""
-        return await self._rich_text_markdown_converter.to_markdown(block.callout.rich_text)
+        return await self._rich_text_markdown_converter.to_markdown(
+            block.callout.rich_text
+        )

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

@@ -1,21 +1,25 @@
 from abc import abstractmethod
 from typing import override
 
-from notionary.blocks.rich_text.rich_text_markdown_converter import RichTextToMarkdownConverter
+from notionary.blocks.rich_text.rich_text_markdown_converter import (
+    RichTextToMarkdownConverter,
+)
 from notionary.blocks.schemas import Block
 from notionary.page.content.renderer.context import MarkdownRenderingContext
 from notionary.page.content.renderer.renderers.base import BlockRenderer
-from notionary.page.content.syntax import SyntaxRegistry
+from notionary.page.content.syntax.definition import SyntaxDefinitionRegistry
 
 
 class CaptionedBlockRenderer(BlockRenderer):
     def __init__(
         self,
-        syntax_registry: SyntaxRegistry | None = None,
+        syntax_registry: SyntaxDefinitionRegistry | None = None,
         rich_text_markdown_converter: RichTextToMarkdownConverter | None = None,
     ) -> None:
         super().__init__(syntax_registry=syntax_registry)
-        self._rich_text_markdown_converter = rich_text_markdown_converter or RichTextToMarkdownConverter()
+        self._rich_text_markdown_converter = (
+            rich_text_markdown_converter or RichTextToMarkdownConverter()
+        )
 
     @abstractmethod
     async def _render_main_content(self, block: Block) -> str:
@@ -53,6 +57,8 @@ class CaptionedBlockRenderer(BlockRenderer):
         if not caption_rich_text:
             return ""
 
-        caption_markdown = await self._rich_text_markdown_converter.to_markdown(caption_rich_text)
+        caption_markdown = await self._rich_text_markdown_converter.to_markdown(
+            caption_rich_text
+        )
 
         return f"\n[caption] {caption_markdown}"

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

@@ -2,7 +2,9 @@ from typing import override
 
 from notionary.blocks.enums import BlockType
 from notionary.blocks.schemas import Block
-from notionary.page.content.renderer.renderers.captioned_block import CaptionedBlockRenderer
+from notionary.page.content.renderer.renderers.captioned_block import (
+    CaptionedBlockRenderer,
+)
 
 
 class CodeRenderer(CaptionedBlockRenderer):
@@ -31,4 +33,6 @@ class CodeRenderer(CaptionedBlockRenderer):
     async def _extract_code_content(self, block: Block) -> str:
         if not block.code or not block.code.rich_text:
             return ""
-        return await self._rich_text_markdown_converter.to_markdown(block.code.rich_text)
+        return await self._rich_text_markdown_converter.to_markdown(
+            block.code.rich_text
+        )

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

@@ -42,7 +42,9 @@ class ColumnRenderer(BlockRenderer):
 
         return delimiter
 
-    async def _render_children_with_indentation(self, context: MarkdownRenderingContext) -> str:
+    async def _render_children_with_indentation(
+        self, context: MarkdownRenderingContext
+    ) -> str:
         original_indent = context.indent_level
         context.indent_level += 1
 

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

@@ -33,7 +33,9 @@ class ColumnListRenderer(BlockRenderer):
     def _get_column_list_delimiter(self) -> str:
         return self._syntax_registry.get_column_list_syntax().start_delimiter
 
-    async def _render_children_with_indentation(self, context: MarkdownRenderingContext) -> str:
+    async def _render_children_with_indentation(
+        self, context: MarkdownRenderingContext
+    ) -> str:
         original_indent = context.indent_level
         context.indent_level += 1
 

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

@@ -1,7 +1,9 @@
 from typing import override
 
 from notionary.blocks.schemas import Block, BlockType
-from notionary.page.content.renderer.renderers.captioned_block import CaptionedBlockRenderer
+from notionary.page.content.renderer.renderers.captioned_block import (
+    CaptionedBlockRenderer,
+)
 
 
 class EmbedRenderer(CaptionedBlockRenderer):

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

@@ -19,7 +19,9 @@ class EquationRenderer(BlockRenderer):
             return
 
         syntax = self._syntax_registry.get_equation_syntax()
-        equation_markdown = f"{syntax.start_delimiter}{expression}{syntax.end_delimiter}"
+        equation_markdown = (
+            f"{syntax.start_delimiter}{expression}{syntax.end_delimiter}"
+        )
 
         if context.indent_level > 0:
             equation_markdown = context.indent_text(equation_markdown)

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

@@ -1,8 +1,15 @@
 from typing import override
 
-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
+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.definition import EnclosedSyntaxDefinition
 
 
 class FileRenderer(FileLikeBlockRenderer):
@@ -11,11 +18,13 @@ class FileRenderer(FileLikeBlockRenderer):
         return block.type == BlockType.FILE
 
     @override
-    def _get_syntax(self) -> SyntaxDefinition:
+    def _get_syntax(self) -> EnclosedSyntaxDefinition:
         return self._syntax_registry.get_file_syntax()
 
     @override
-    def _get_file_data(self, block: Block) -> ExternalFileWithCaption | NotionHostedFileWithCaption | None:
+    def _get_file_data(
+        self, block: Block
+    ) -> ExternalFileWithCaption | NotionHostedFileWithCaption | None:
         return block.file
 
     def _extract_file_name(self, block: Block) -> str: