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

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

@@ -2,11 +2,11 @@ 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

@@ -2,12 +2,17 @@ from typing import override
 
 from notionary.blocks.schemas import CreateFileBlock, ExternalFileWithCaption
 from notionary.page.content.parser.parsers.file_like_block import FileLikeBlockParser
-from notionary.page.content.syntax import SyntaxDefinition, SyntaxRegistry
+from notionary.page.content.syntax.definition import (
+    SyntaxDefinition,
+    SyntaxDefinitionRegistry,
+)
 
 
 class FileParser(FileLikeBlockParser[CreateFileBlock]):
     @override
-    def _get_syntax(self, syntax_registry: SyntaxRegistry) -> SyntaxDefinition:
+    def _get_syntax(
+        self, syntax_registry: SyntaxDefinitionRegistry
+    ) -> SyntaxDefinition:
         return syntax_registry.get_file_syntax()
 
     @override

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

@@ -10,8 +10,8 @@ from notionary.blocks.schemas import (
 from notionary.exceptions.file_upload import UploadFailedError, UploadTimeoutError
 from notionary.file_upload.service import NotionFileUpload
 from notionary.page.content.parser.parsers.base import BlockParsingContext, LineParser
-from notionary.page.content.syntax import SyntaxRegistry
-from notionary.page.content.syntax.models import SyntaxDefinition
+from notionary.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
 
@@ -19,13 +19,19 @@ _TBlock = TypeVar("_TBlock")
 
 
 class FileLikeBlockParser(LineParser, LoggingMixin, Generic[_TBlock]):
-    def __init__(self, syntax_registry: SyntaxRegistry, file_upload_service: NotionFileUpload | None = None) -> None:
+    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: SyntaxRegistry) -> SyntaxDefinition:
+    def _get_syntax(
+        self, syntax_registry: SyntaxDefinitionRegistry
+    ) -> SyntaxDefinition:
         pass
 
     @abstractmethod
@@ -46,7 +52,9 @@ class FileLikeBlockParser(LineParser, LoggingMixin, Generic[_TBlock]):
 
         try:
             if self._is_external_url(path_or_url):
-                file_data = ExternalFileWithCaption(external=ExternalFileData(url=path_or_url))
+                file_data = ExternalFileWithCaption(
+                    external=ExternalFileData(url=path_or_url)
+                )
             else:
                 file_data = await self._upload_local_file(path_or_url)
 
@@ -56,15 +64,27 @@ class FileLikeBlockParser(LineParser, LoggingMixin, Generic[_TBlock]):
         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)
+            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)
+            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)
+            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)
+            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)
+            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)

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

@@ -2,12 +2,17 @@ from typing import override
 
 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
+from notionary.page.content.syntax.definition import (
+    SyntaxDefinition,
+    SyntaxDefinitionRegistry,
+)
 
 
 class ImageParser(FileLikeBlockParser[CreateImageBlock]):
     @override
-    def _get_syntax(self, syntax_registry: SyntaxRegistry) -> SyntaxDefinition:
+    def _get_syntax(
+        self, syntax_registry: SyntaxDefinitionRegistry
+    ) -> SyntaxDefinition:
         return syntax_registry.get_image_syntax()
 
     @override

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

@@ -2,12 +2,17 @@ from typing import override
 
 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
+from notionary.page.content.syntax.definition import (
+    SyntaxDefinition,
+    SyntaxDefinitionRegistry,
+)
 
 
 class PdfParser(FileLikeBlockParser[CreatePdfBlock]):
     @override
-    def _get_syntax(self, syntax_registry: SyntaxRegistry) -> SyntaxDefinition:
+    def _get_syntax(
+        self, syntax_registry: SyntaxDefinitionRegistry
+    ) -> SyntaxDefinition:
         return syntax_registry.get_pdf_syntax()
 
     @override

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()
 

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

@@ -2,12 +2,17 @@ from typing import override
 
 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
+from notionary.page.content.syntax.definition import (
+    SyntaxDefinition,
+    SyntaxDefinitionRegistry,
+)
 
 
 class VideoParser(FileLikeBlockParser[CreateVideoBlock]):
     @override
-    def _get_syntax(self, syntax_registry: SyntaxRegistry) -> SyntaxDefinition:
+    def _get_syntax(
+        self, syntax_registry: SyntaxDefinitionRegistry
+    ) -> SyntaxDefinition:
         return syntax_registry.get_video_syntax()
 
     @override