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

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

@@ -1,14 +1,25 @@
 from typing import override
 
-from notionary.blocks.rich_text.markdown_rich_text_converter import MarkdownRichTextConverter
+from notionary.blocks.rich_text.markdown_rich_text_converter import (
+    MarkdownRichTextConverter,
+)
 from notionary.blocks.rich_text.models import RichText
-from notionary.blocks.schemas import CreateTableBlock, CreateTableData, CreateTableRowBlock, TableRowData
+from notionary.blocks.schemas import (
+    CreateTableBlock,
+    CreateTableData,
+    CreateTableRowBlock,
+    TableRowData,
+)
 from notionary.page.content.parser.parsers import BlockParsingContext, LineParser
-from notionary.page.content.syntax import SyntaxRegistry
+from notionary.page.content.syntax.definition import SyntaxDefinitionRegistry
 
 
 class TableParser(LineParser):
-    def __init__(self, syntax_registry: SyntaxRegistry, rich_text_converter: MarkdownRichTextConverter) -> None:
+    def __init__(
+        self,
+        syntax_registry: SyntaxDefinitionRegistry,
+        rich_text_converter: MarkdownRichTextConverter,
+    ) -> None:
         super().__init__(syntax_registry)
         self._syntax = syntax_registry.get_table_syntax()
         self._separator_syntax = syntax_registry.get_table_row_syntax()
@@ -41,7 +52,9 @@ class TableParser(LineParser):
             context.lines_consumed = lines_consumed
             context.result_blocks.append(block)
 
-    def _collect_table_lines(self, table_lines: list[str], remaining_lines: list[str]) -> int:
+    def _collect_table_lines(
+        self, table_lines: list[str], remaining_lines: list[str]
+    ) -> int:
         lines_consumed = 0
 
         for index, line in enumerate(remaining_lines):
@@ -62,9 +75,13 @@ class TableParser(LineParser):
         return lines_consumed
 
     def _is_table_line(self, line: str) -> bool:
-        return self._syntax.regex_pattern.match(line) or self._separator_syntax.regex_pattern.match(line)
+        return self._syntax.regex_pattern.match(
+            line
+        ) or self._separator_syntax.regex_pattern.match(line)
 
-    async def _create_table_block(self, table_lines: list[str]) -> CreateTableBlock | None:
+    async def _create_table_block(
+        self, table_lines: list[str]
+    ) -> CreateTableBlock | None:
         if not table_lines:
             return None
 
@@ -93,7 +110,9 @@ class TableParser(LineParser):
                 return line_stripped
         return None
 
-    async def _process_table_rows(self, table_lines: list[str]) -> tuple[list[CreateTableRowBlock], bool]:
+    async def _process_table_rows(
+        self, table_lines: list[str]
+    ) -> tuple[list[CreateTableRowBlock], bool]:
         table_rows = []
         has_separator = False
 
@@ -122,7 +141,9 @@ class TableParser(LineParser):
         table_row_data = TableRowData(cells=rich_text_cells)
         return CreateTableRowBlock(table_row=table_row_data)
 
-    async def _convert_cells_to_rich_text(self, cells: list[str]) -> list[list[RichText]]:
+    async def _convert_cells_to_rich_text(
+        self, cells: list[str]
+    ) -> list[list[RichText]]:
         rich_text_cells = []
 
         for cell in cells:
@@ -132,7 +153,7 @@ class TableParser(LineParser):
         return rich_text_cells
 
     def _parse_table_row(self, row_text: str) -> list[str]:
-        """Parse a table row by splitting on the table delimiter from SyntaxRegistry."""
+        """Parse a table row by splitting on the table delimiter from SyntaxDefinitionRegistry."""
         row_content = row_text.strip()
         delimiter = self._syntax.start_delimiter
 

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

@@ -1,15 +1,19 @@
 from typing import override
 
-from notionary.blocks.schemas import BlockColor, CreateTableOfContentsBlock, TableOfContentsData
+from notionary.blocks.schemas import (
+    BlockColor,
+    CreateTableOfContentsBlock,
+    TableOfContentsData,
+)
 from notionary.page.content.parser.parsers.base import (
     BlockParsingContext,
     LineParser,
 )
-from notionary.page.content.syntax import SyntaxRegistry
+from notionary.page.content.syntax.definition import SyntaxDefinitionRegistry
 
 
 class TableOfContentsParser(LineParser):
-    def __init__(self, syntax_registry: SyntaxRegistry) -> None:
+    def __init__(self, syntax_registry: SyntaxDefinitionRegistry) -> None:
         super().__init__(syntax_registry)
         self._syntax = syntax_registry.get_table_of_contents_syntax()
 

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

@@ -8,11 +8,15 @@ from notionary.page.content.parser.parsers.base import (
     BlockParsingContext,
     LineParser,
 )
-from notionary.page.content.syntax import SyntaxRegistry
+from notionary.page.content.syntax.definition import SyntaxDefinitionRegistry
 
 
 class TodoParser(LineParser):
-    def __init__(self, syntax_registry: SyntaxRegistry, rich_text_converter: MarkdownRichTextConverter) -> None:
+    def __init__(
+        self,
+        syntax_registry: SyntaxDefinitionRegistry,
+        rich_text_converter: MarkdownRichTextConverter,
+    ) -> None:
         super().__init__(syntax_registry)
         self._syntax = syntax_registry.get_todo_syntax()
         self._syntax_done = syntax_registry.get_todo_done_syntax()
@@ -39,7 +43,9 @@ class TodoParser(LineParser):
         await self._process_nested_children(block, context)
         context.result_blocks.append(block)
 
-    async def _process_nested_children(self, block: CreateToDoBlock, context: BlockParsingContext) -> None:
+    async def _process_nested_children(
+        self, block: CreateToDoBlock, context: BlockParsingContext
+    ) -> None:
         child_lines = self._collect_child_lines(context)
         if not child_lines:
             return
@@ -54,12 +60,16 @@ class TodoParser(LineParser):
         parent_indent_level = context.get_line_indentation_level()
         return context.collect_indented_child_lines(parent_indent_level)
 
-    async def _parse_child_blocks(self, child_lines: list[str], context: BlockParsingContext) -> list[CreateToDoBlock]:
+    async def _parse_child_blocks(
+        self, child_lines: list[str], context: BlockParsingContext
+    ) -> list[CreateToDoBlock]:
         stripped_lines = self._remove_parent_indentation(child_lines, context)
         children_text = self._convert_lines_to_text(stripped_lines)
         return await context.parse_nested_markdown(children_text)
 
-    def _remove_parent_indentation(self, lines: list[str], context: BlockParsingContext) -> list[str]:
+    def _remove_parent_indentation(
+        self, lines: list[str], context: BlockParsingContext
+    ) -> list[str]:
         return context.strip_indentation_level(lines, levels=1)
 
     def _convert_lines_to_text(self, lines: list[str]) -> str:

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

@@ -1,16 +1,22 @@
 from typing import override
 
-from notionary.blocks.rich_text.markdown_rich_text_converter import MarkdownRichTextConverter
+from notionary.blocks.rich_text.markdown_rich_text_converter import (
+    MarkdownRichTextConverter,
+)
 from notionary.blocks.schemas import BlockColor, CreateToggleBlock, CreateToggleData
 from notionary.page.content.parser.parsers import (
     BlockParsingContext,
     LineParser,
 )
-from notionary.page.content.syntax import SyntaxRegistry
+from notionary.page.content.syntax.definition import SyntaxDefinitionRegistry
 
 
 class ToggleParser(LineParser):
-    def __init__(self, syntax_registry: SyntaxRegistry, rich_text_converter: MarkdownRichTextConverter) -> None:
+    def __init__(
+        self,
+        syntax_registry: SyntaxDefinitionRegistry,
+        rich_text_converter: MarkdownRichTextConverter,
+    ) -> None:
         super().__init__(syntax_registry)
         self._syntax = syntax_registry.get_toggle_syntax()
         self._heading_syntax = syntax_registry.get_toggleable_heading_syntax()
@@ -51,10 +57,14 @@ class ToggleParser(LineParser):
         title = match.group(1).strip()
         rich_text = await self._rich_text_converter.to_rich_text(title)
 
-        toggle_content = CreateToggleData(rich_text=rich_text, color=BlockColor.DEFAULT, children=[])
+        toggle_content = CreateToggleData(
+            rich_text=rich_text, color=BlockColor.DEFAULT, children=[]
+        )
         return CreateToggleBlock(toggle=toggle_content)
 
-    async def _process_nested_children(self, block: CreateToggleBlock, context: BlockParsingContext) -> None:
+    async def _process_nested_children(
+        self, block: CreateToggleBlock, context: BlockParsingContext
+    ) -> None:
         parent_indent_level = context.get_line_indentation_level()
         child_lines = context.collect_indented_child_lines(parent_indent_level)
 

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

@@ -1,42 +1,20 @@
-"""Parser for video blocks."""
-
 from typing import override
 
-from notionary.blocks.schemas import (
-    CreateVideoBlock,
-    ExternalFile,
-    FileData,
-    FileType,
+from notionary.blocks.schemas import CreateVideoBlock, ExternalFileWithCaption
+from notionary.page.content.parser.parsers.file_like_block import FileLikeBlockParser
+from notionary.page.content.syntax.definition import (
+    SyntaxDefinition,
+    SyntaxDefinitionRegistry,
 )
-from notionary.page.content.parser.parsers.base import BlockParsingContext, LineParser
-from notionary.page.content.syntax import 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: SyntaxDefinitionRegistry
+    ) -> 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/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,31 +1,28 @@
 from typing import override
 
-from notionary.blocks.schemas import Block, BlockType
-from notionary.page.content.renderer.renderers.captioned_block import CaptionedBlockRenderer
-
-
-class AudioRenderer(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.definition import EnclosedSyntaxDefinition
+
+
+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)
-
-        if not url:
-            return ""
-
-        syntax = self._syntax_registry.get_audio_syntax()
-        return f"{syntax.start_delimiter}{url}{syntax.end_delimiter}"
+    def _get_syntax(self) -> EnclosedSyntaxDefinition:
+        return self._syntax_registry.get_audio_syntax()
 
-    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