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

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

@@ -1,16 +1,20 @@
 from typing import override
 
 from notionary.blocks.enums import BlockType
-from notionary.blocks.schemas import BlockCreatePayload, CreateColumnListBlock, CreateColumnListData
+from notionary.blocks.schemas import (
+    BlockCreatePayload,
+    CreateColumnListBlock,
+    CreateColumnListData,
+)
 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 ColumnListParser(LineParser):
-    def __init__(self, syntax_registry: SyntaxRegistry) -> None:
+    def __init__(self, syntax_registry: SyntaxDefinitionRegistry) -> None:
         super().__init__(syntax_registry)
         self._syntax = syntax_registry.get_column_list_syntax()
 
@@ -35,9 +39,13 @@ class ColumnListParser(LineParser):
         column_list_data = CreateColumnListData(children=[])
         return CreateColumnListBlock(column_list=column_list_data)
 
-    async def _populate_columns(self, block: CreateColumnListBlock, context: BlockParsingContext) -> None:
+    async def _populate_columns(
+        self, block: CreateColumnListBlock, context: BlockParsingContext
+    ) -> None:
         parent_indent_level = context.get_line_indentation_level()
-        child_lines = self._collect_children_allowing_empty_lines(context, parent_indent_level)
+        child_lines = self._collect_children_allowing_empty_lines(
+            context, parent_indent_level
+        )
 
         if not child_lines:
             return
@@ -46,7 +54,9 @@ class ColumnListParser(LineParser):
         block.column_list.children = column_blocks
         context.lines_consumed = len(child_lines)
 
-    async def _parse_column_children(self, child_lines: list[str], context: BlockParsingContext) -> list:
+    async def _parse_column_children(
+        self, child_lines: list[str], context: BlockParsingContext
+    ) -> list:
         stripped_lines = context.strip_indentation_level(child_lines, levels=1)
         child_markdown = "\n".join(stripped_lines)
         parsed_blocks = await context.parse_nested_markdown(child_markdown)
@@ -67,7 +77,9 @@ class ColumnListParser(LineParser):
 
         return child_lines
 
-    def _should_include_as_child(self, line: str, expected_indent: int, context: BlockParsingContext) -> bool:
+    def _should_include_as_child(
+        self, line: str, expected_indent: int, context: BlockParsingContext
+    ) -> bool:
         if not line.strip():
             return True
 

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

@@ -5,11 +5,11 @@ 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 DividerParser(LineParser):
-    def __init__(self, syntax_registry: SyntaxRegistry) -> None:
+    def __init__(self, syntax_registry: SyntaxDefinitionRegistry) -> None:
         super().__init__(syntax_registry)
         self._syntax = syntax_registry.get_divider_syntax()
 

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

@@ -1,14 +1,12 @@
-"""Parser for embed blocks."""
-
 from typing import override
 
 from notionary.blocks.schemas import CreateEmbedBlock, EmbedData
 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 EmbedParser(LineParser):
-    def __init__(self, syntax_registry: SyntaxRegistry) -> None:
+    def __init__(self, syntax_registry: SyntaxDefinitionRegistry) -> None:
         super().__init__(syntax_registry)
         self._syntax = syntax_registry.get_embed_syntax()
 

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

@@ -5,11 +5,11 @@ 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 EquationParser(LineParser):
-    def __init__(self, syntax_registry: SyntaxRegistry) -> None:
+    def __init__(self, syntax_registry: SyntaxDefinitionRegistry) -> None:
         super().__init__(syntax_registry)
         self._syntax = syntax_registry.get_equation_syntax()
 
@@ -24,7 +24,9 @@ class EquationParser(LineParser):
         equation_content = self._collect_equation_content(context)
         lines_consumed = self._count_lines_consumed(context)
 
-        block = self._create_equation_block(opening_line=context.line, equation_lines=equation_content)
+        block = self._create_equation_block(
+            opening_line=context.line, equation_lines=equation_content
+        )
 
         if block:
             context.lines_consumed = lines_consumed
@@ -50,7 +52,9 @@ class EquationParser(LineParser):
 
         return len(context.get_remaining_lines())
 
-    def _create_equation_block(self, opening_line: str, equation_lines: list[str]) -> CreateEquationBlock | None:
+    def _create_equation_block(
+        self, opening_line: str, equation_lines: list[str]
+    ) -> CreateEquationBlock | None:
         if opening_line.strip() != self._syntax.start_delimiter:
             return None
 

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

@@ -1,42 +1,20 @@
-"""Parser for file blocks."""
-
 from typing import override
 
-from notionary.blocks.schemas import (
-    CreateFileBlock,
-    ExternalFile,
-    FileData,
-    FileType,
+from notionary.blocks.schemas import CreateFileBlock, 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 FileParser(LineParser):
-    def __init__(self, syntax_registry: SyntaxRegistry) -> None:
-        super().__init__(syntax_registry)
-        self._syntax = syntax_registry.get_file_syntax()
 
+class FileParser(FileLikeBlockParser[CreateFileBlock]):
     @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_file_syntax()
 
     @override
-    async def _process(self, context: BlockParsingContext) -> None:
-        url = self._extract_url(context.line)
-        if not url:
-            return
-
-        file_data = FileData(
-            type=FileType.EXTERNAL,
-            external=ExternalFile(url=url),
-            caption=[],
-        )
-        block = CreateFileBlock(file=file_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) -> CreateFileBlock:
+        return CreateFileBlock(file=file_data)

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

@@ -0,0 +1,109 @@
+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.definition import SyntaxDefinitionRegistry
+from notionary.page.content.syntax.definition.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: SyntaxDefinitionRegistry,
+        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: SyntaxDefinitionRegistry
+    ) -> 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/heading.py

@@ -1,6 +1,8 @@
 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,
     BlockCreatePayload,
@@ -15,14 +17,18 @@ 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 HeadingParser(LineParser):
     MIN_HEADING_LEVEL = 1
     MAX_HEADING_LEVEL = 3
 
-    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_heading_syntax()
         self._rich_text_converter = rich_text_converter
@@ -42,7 +48,9 @@ class HeadingParser(LineParser):
         await self._process_nested_children(block, context)
         context.result_blocks.append(block)
 
-    async def _process_nested_children(self, block: CreateHeadingBlock, context: BlockParsingContext) -> None:
+    async def _process_nested_children(
+        self, block: CreateHeadingBlock, context: BlockParsingContext
+    ) -> None:
         parent_indent_level = context.get_line_indentation_level()
         child_lines = context.collect_indented_child_lines(parent_indent_level)
 
@@ -64,7 +72,9 @@ class HeadingParser(LineParser):
 
         context.lines_consumed = len(child_lines)
 
-    def _set_heading_toggleable(self, block: CreateHeadingBlock, is_toggleable: bool) -> None:
+    def _set_heading_toggleable(
+        self, block: CreateHeadingBlock, is_toggleable: bool
+    ) -> None:
         if block.type == BlockType.HEADING_1:
             block.heading_1.is_toggleable = is_toggleable
         elif block.type == BlockType.HEADING_2:
@@ -72,7 +82,9 @@ class HeadingParser(LineParser):
         elif block.type == BlockType.HEADING_3:
             block.heading_3.is_toggleable = is_toggleable
 
-    def _set_heading_children(self, block: CreateHeadingBlock, children: list[BlockCreatePayload]) -> None:
+    def _set_heading_children(
+        self, block: CreateHeadingBlock, children: list[BlockCreatePayload]
+    ) -> None:
         if block.type == BlockType.HEADING_1:
             block.heading_1.children = children
         elif block.type == BlockType.HEADING_2:
@@ -100,13 +112,22 @@ class HeadingParser(LineParser):
         return self._create_heading_block_by_level(level, heading_data)
 
     def _is_valid_heading(self, level: int, content: str) -> bool:
-        return self.MIN_HEADING_LEVEL <= level <= self.MAX_HEADING_LEVEL and bool(content)
+        return self.MIN_HEADING_LEVEL <= level <= self.MAX_HEADING_LEVEL and bool(
+            content
+        )
 
     async def _build_heading_data(self, content: str) -> CreateHeadingData:
         rich_text = await self._rich_text_converter.to_rich_text(content)
-        return CreateHeadingData(rich_text=rich_text, color=BlockColor.DEFAULT, is_toggleable=False, children=[])
-
-    def _create_heading_block_by_level(self, level: int, heading_data: CreateHeadingData) -> CreateHeadingBlock:
+        return CreateHeadingData(
+            rich_text=rich_text,
+            color=BlockColor.DEFAULT,
+            is_toggleable=False,
+            children=[],
+        )
+
+    def _create_heading_block_by_level(
+        self, level: int, heading_data: CreateHeadingData
+    ) -> CreateHeadingBlock:
         if level == 1:
             return CreateHeading1Block(heading_1=heading_data)
         elif level == 2:

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

@@ -1,42 +1,20 @@
-"""Parser for image blocks."""
-
 from typing import override
 
-from notionary.blocks.schemas import (
-    CreateImageBlock,
-    ExternalFile,
-    FileData,
-    FileType,
+from notionary.blocks.schemas import CreateImageBlock, 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 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: SyntaxDefinitionRegistry
+    ) -> 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/numbered_list.py

@@ -12,11 +12,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 NumberedListParser(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_numbered_list_syntax()
         self._rich_text_converter = rich_text_converter
@@ -39,7 +43,9 @@ class NumberedListParser(LineParser):
         await self._process_nested_children(block, context)
         context.result_blocks.append(block)
 
-    async def _process_nested_children(self, block: CreateNumberedListItemBlock, context: BlockParsingContext) -> None:
+    async def _process_nested_children(
+        self, block: CreateNumberedListItemBlock, context: BlockParsingContext
+    ) -> None:
         child_lines = self._collect_child_lines(context)
         if not child_lines:
             return
@@ -61,13 +67,17 @@ class NumberedListParser(LineParser):
         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:
         return "\n".join(lines)
 
-    async def _create_numbered_list_block(self, text: str) -> CreateNumberedListItemBlock | None:
+    async def _create_numbered_list_block(
+        self, text: str
+    ) -> CreateNumberedListItemBlock | None:
         content = self._extract_list_content(text)
         if content is None:
             return None
@@ -85,5 +95,7 @@ class NumberedListParser(LineParser):
         return await self._rich_text_converter.to_rich_text(content)
 
     def _build_block(self, rich_text) -> CreateNumberedListItemBlock:
-        numbered_list_content = CreateNumberedListItemData(rich_text=rich_text, color=BlockColor.DEFAULT)
+        numbered_list_content = CreateNumberedListItemData(
+            rich_text=rich_text, color=BlockColor.DEFAULT
+        )
         return CreateNumberedListItemBlock(numbered_list_item=numbered_list_content)

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

@@ -33,5 +33,7 @@ class ParagraphParser(LineParser):
             return None
 
         rich_text = await self._rich_text_converter.to_rich_text(text)
-        paragraph_content = CreateParagraphData(rich_text=rich_text, color=BlockColor.DEFAULT)
+        paragraph_content = CreateParagraphData(
+            rich_text=rich_text, color=BlockColor.DEFAULT
+        )
         return CreateParagraphBlock(paragraph=paragraph_content)

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

@@ -1,42 +1,20 @@
-"""Parser for PDF blocks."""
-
 from typing import override
 
-from notionary.blocks.schemas import (
-    CreatePdfBlock,
-    ExternalFile,
-    FileData,
-    FileType,
+from notionary.blocks.schemas import CreatePdfBlock, 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 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: SyntaxDefinitionRegistry
+    ) -> 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/quote.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, CreateQuoteBlock, CreateQuoteData
 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 QuoteParser(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_quote_syntax()
         self._rich_text_converter = rich_text_converter
@@ -47,11 +53,16 @@ class QuoteParser(LineParser):
         return quote_lines
 
     async def _process_nested_children(
-        self, block: CreateQuoteBlock, context: BlockParsingContext, quote_lines: list[str]
+        self,
+        block: CreateQuoteBlock,
+        context: BlockParsingContext,
+        quote_lines: list[str],
     ) -> None:
         # Calculate indent level after all quote lines
         last_quote_line_index = len(quote_lines) - 1
-        child_lines = self._collect_child_lines_after_quote(context, last_quote_line_index)
+        child_lines = self._collect_child_lines_after_quote(
+            context, last_quote_line_index
+        )
 
         if not child_lines:
             return
@@ -62,7 +73,9 @@ class QuoteParser(LineParser):
 
         context.lines_consumed += len(child_lines)
 
-    def _collect_child_lines_after_quote(self, context: BlockParsingContext, last_quote_index: int) -> list[str]:
+    def _collect_child_lines_after_quote(
+        self, context: BlockParsingContext, last_quote_index: int
+    ) -> list[str]:
         """Collect indented children after the quote block."""
         parent_indent_level = context.get_line_indentation_level()
         remaining_lines = context.get_remaining_lines()
@@ -86,18 +99,24 @@ class QuoteParser(LineParser):
 
         return child_lines
 
-    async def _parse_child_blocks(self, child_lines: list[str], context: BlockParsingContext) -> list[CreateQuoteBlock]:
+    async def _parse_child_blocks(
+        self, child_lines: list[str], context: BlockParsingContext
+    ) -> list[CreateQuoteBlock]:
         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:
         return "\n".join(lines)
 
-    async def _create_quote_block(self, quote_lines: list[str]) -> CreateQuoteBlock | None:
+    async def _create_quote_block(
+        self, quote_lines: list[str]
+    ) -> CreateQuoteBlock | None:
         contents = self._extract_quote_contents(quote_lines)
         if not contents:
             return None

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

@@ -6,11 +6,11 @@ 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 SpaceParser(LineParser):
-    def __init__(self, syntax_registry: SyntaxRegistry) -> None:
+    def __init__(self, syntax_registry: SyntaxDefinitionRegistry) -> None:
         super().__init__(syntax_registry)
         self._syntax = syntax_registry.get_space_syntax()