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

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

@@ -1,13 +1,13 @@
+import re
 from typing import override
 
 from notionary.blocks.rich_text.markdown_rich_text_converter import MarkdownRichTextConverter
 from notionary.blocks.schemas import CreateCalloutBlock, CreateCalloutData
-from notionary.page.content.parser.context import ParentBlockContext
 from notionary.page.content.parser.parsers.base import (
     BlockParsingContext,
     LineParser,
 )
-from notionary.page.content.syntax.service import SyntaxRegistry
+from notionary.page.content.syntax import SyntaxRegistry
 from notionary.shared.models.icon import EmojiIcon
 
 
@@ -17,113 +17,84 @@ class CalloutParser(LineParser):
     def __init__(self, syntax_registry: SyntaxRegistry, rich_text_converter: MarkdownRichTextConverter) -> None:
         super().__init__(syntax_registry)
         self._syntax = syntax_registry.get_callout_syntax()
-        self._start_pattern = self._syntax.regex_pattern
-        self._end_pattern = self._syntax.end_regex_pattern
+        self._pattern = self._syntax.regex_pattern
         self._rich_text_converter = rich_text_converter
 
     @override
     def _can_handle(self, context: BlockParsingContext) -> bool:
-        return self._is_callout_start(context) or self._is_callout_end(context) or self._is_callout_content(context)
+        return self._pattern.search(context.line) is not None
 
     @override
     async def _process(self, context: BlockParsingContext) -> None:
-        if self._is_callout_start(context):
-            await self._start_callout(context)
+        block = await self._create_callout_block(context.line)
+        if not block:
+            return
 
-        if self._is_callout_end(context):
-            await self._finalize_callout(context)
+        await self._process_nested_children(block, context)
 
-        if self._is_callout_content(context):
-            self._add_callout_content(context)
+        if self._is_nested_in_parent_context(context):
+            context.parent_stack[-1].add_child_block(block)
+        else:
+            context.result_blocks.append(block)
 
-    def _is_callout_start(self, context: BlockParsingContext) -> bool:
-        return self._start_pattern.match(context.line) is not None
+    async def _process_nested_children(self, block: CreateCalloutBlock, context: BlockParsingContext) -> None:
+        child_lines = self._collect_child_lines(context)
+        if not child_lines:
+            return
 
-    def _is_callout_end(self, context: BlockParsingContext) -> bool:
-        if not self._end_pattern.match(context.line):
-            return False
+        child_blocks = await self._parse_child_blocks(child_lines, context)
+        if child_blocks:
+            block.callout.children = child_blocks
 
-        if not context.parent_stack:
-            return False
+        context.lines_consumed = len(child_lines)
 
-        current_parent = context.parent_stack[-1]
-        return isinstance(current_parent.block, CreateCalloutBlock)
+    def _collect_child_lines(self, context: BlockParsingContext) -> list[str]:
+        parent_indent_level = context.get_line_indentation_level()
+        return context.collect_indented_child_lines(parent_indent_level)
 
-    async def _start_callout(self, context: BlockParsingContext) -> None:
-        block = await self._create_callout_block(context.line)
-        if not block:
-            return
+    async def _parse_child_blocks(
+        self, child_lines: list[str], context: BlockParsingContext
+    ) -> list[CreateCalloutBlock]:
+        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)
 
-        parent_context = ParentBlockContext(
-            block=block,
-            child_lines=[],
-        )
-        context.parent_stack.append(parent_context)
+    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_callout_block(self, line: str) -> CreateCalloutBlock | None:
-        match = self._start_pattern.match(line)
+        match = self._pattern.search(line)
         if not match:
             return None
 
-        emoji_part = match.group(1)
-        emoji = emoji_part.strip() if emoji_part else self.DEFAULT_EMOJI
+        content, emoji = self._extract_content_and_emoji(match)
+        rich_text = await self._convert_to_rich_text(content)
+        return self._build_block(rich_text, emoji)
+
+    def _extract_content_and_emoji(self, match: re.Match[str]) -> tuple[str, str]:
+        inline_content = match.group(1)
+        if inline_content:
+            return inline_content.strip(), match.group(2) or self.DEFAULT_EMOJI
+
+        block_content = match.group(3)
+        if block_content:
+            return block_content.strip(), match.group(4) or self.DEFAULT_EMOJI
+
+        return "", self.DEFAULT_EMOJI
+
+    async def _convert_to_rich_text(self, content: str):
+        return await self._rich_text_converter.to_rich_text(content)
 
-        # Create callout with empty rich_text initially
-        # The actual content will be added as children
+    def _build_block(self, rich_text, emoji: str) -> CreateCalloutBlock:
         callout_data = CreateCalloutData(
-            rich_text=[],
+            rich_text=rich_text,
             icon=EmojiIcon(emoji=emoji),
             children=[],
         )
         return CreateCalloutBlock(callout=callout_data)
 
-    async def _finalize_callout(self, context: BlockParsingContext) -> None:
-        callout_context = context.parent_stack.pop()
-        await self._assign_callout_children_if_any(callout_context, context)
-
-        if self._is_nested_in_other_parent_context(context):
-            self._assign_to_parent_context(context, callout_context)
-        else:
-            context.result_blocks.append(callout_context.block)
-
-    def _is_nested_in_other_parent_context(self, context: BlockParsingContext) -> bool:
+    def _is_nested_in_parent_context(self, context: BlockParsingContext) -> bool:
         return bool(context.parent_stack)
-
-    def _assign_to_parent_context(self, context: BlockParsingContext, callout_context: ParentBlockContext) -> None:
-        parent_context = context.parent_stack[-1]
-        parent_context.add_child_block(callout_context.block)
-
-    async def _assign_callout_children_if_any(
-        self, callout_context: ParentBlockContext, context: BlockParsingContext
-    ) -> None:
-        all_children = []
-
-        if callout_context.child_lines:
-            children_text = "\n".join(callout_context.child_lines)
-            text_blocks = await self._parse_nested_content(children_text, context)
-            all_children.extend(text_blocks)
-
-        # Add any child blocks
-        if callout_context.child_blocks:
-            all_children.extend(callout_context.child_blocks)
-
-        callout_context.block.callout.children = all_children
-
-    def _is_callout_content(self, context: BlockParsingContext) -> bool:
-        if not context.parent_stack:
-            return False
-
-        current_parent = context.parent_stack[-1]
-        if not isinstance(current_parent.block, CreateCalloutBlock):
-            return False
-
-        return not (self._start_pattern.match(context.line) or self._end_pattern.match(context.line))
-
-    def _add_callout_content(self, context: BlockParsingContext) -> None:
-        context.parent_stack[-1].add_child_line(context.line)
-
-    async def _parse_nested_content(self, text: str, context: BlockParsingContext) -> list:
-        if not text.strip():
-            return []
-
-        return await context.parse_nested_content(text)

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

@@ -8,7 +8,7 @@ from notionary.page.content.parser.parsers.base import (
     BlockParsingContext,
     LineParser,
 )
-from notionary.page.content.syntax.service import SyntaxRegistry
+from notionary.page.content.syntax import SyntaxRegistry
 
 
 class CaptionParser(LineParser):

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

@@ -3,13 +3,13 @@ from typing import override
 
 from notionary.blocks.rich_text.markdown_rich_text_converter import MarkdownRichTextConverter
 from notionary.blocks.rich_text.models import RichText
-from notionary.blocks.schemas import CodeData, CodeLanguage, CreateCodeBlock
+from notionary.blocks.schemas import CodeData, CodingLanguage, CreateCodeBlock
 from notionary.page.content.parser.parsers.base import BlockParsingContext, LineParser
-from notionary.page.content.syntax.service import SyntaxRegistry
+from notionary.page.content.syntax import SyntaxRegistry
 
 
 class CodeParser(LineParser):
-    DEFAULT_LANGUAGE = CodeLanguage.PLAIN_TEXT
+    DEFAULT_LANGUAGE = CodingLanguage.PLAIN_TEXT
 
     def __init__(self, syntax_registry: SyntaxRegistry, rich_text_converter: MarkdownRichTextConverter) -> None:
         super().__init__(syntax_registry)
@@ -67,8 +67,8 @@ class CodeParser(LineParser):
         code_data = CodeData(rich_text=rich_text, language=language, caption=[])
         return CreateCodeBlock(code=code_data)
 
-    def _parse_language(self, language_str: str | None) -> CodeLanguage:
-        return CodeLanguage.from_string(language_str, default=self.DEFAULT_LANGUAGE)
+    def _parse_language(self, language_str: str | None) -> CodingLanguage:
+        return CodingLanguage.from_string(language_str, default=self.DEFAULT_LANGUAGE)
 
     async def _create_rich_text_from_code(self, code_lines: list[str]) -> list[RichText]:
         content = "\n".join(code_lines) if code_lines else ""

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

@@ -1,12 +1,11 @@
 from typing import override
 
-from notionary.blocks.schemas import CreateColumnBlock, CreateColumnData, CreateColumnListBlock
-from notionary.page.content.parser.context import ParentBlockContext
+from notionary.blocks.schemas import CreateColumnBlock, CreateColumnData
 from notionary.page.content.parser.parsers.base import (
     BlockParsingContext,
     LineParser,
 )
-from notionary.page.content.syntax.service import SyntaxRegistry
+from notionary.page.content.syntax import SyntaxRegistry
 
 
 class ColumnParser(LineParser):
@@ -19,54 +18,23 @@ class ColumnParser(LineParser):
 
     @override
     def _can_handle(self, context: BlockParsingContext) -> bool:
-        return self._is_column_start(context) or self._is_column_end(context) or self._is_column_content(context)
+        return self._is_column_start(context)
 
     @override
     async def _process(self, context: BlockParsingContext) -> None:
         if self._is_column_start(context):
-            await self._start_column(context)
-        elif self._is_column_end(context):
-            await self._finalize_column(context)
-        elif self._is_column_content(context):
-            await self._add_column_content(context)
+            await self._process_column(context)
 
     def _is_column_start(self, context: BlockParsingContext) -> bool:
         return self._syntax.regex_pattern.match(context.line) is not None
 
-    def _is_column_end(self, context: BlockParsingContext) -> bool:
-        if not self._syntax.end_regex_pattern.match(context.line):
-            return False
-
-        if not context.parent_stack:
-            return False
-
-        current_parent = context.parent_stack[-1]
-        return isinstance(current_parent.block, CreateColumnBlock)
-
-    def _is_column_content(self, context: BlockParsingContext) -> bool:
-        if not context.parent_stack:
-            return False
-
-        current_parent = context.parent_stack[-1]
-        if not isinstance(current_parent.block, CreateColumnBlock):
-            return False
-
-        line = context.line.strip()
-        return not (self._syntax.regex_pattern.match(line) or self._syntax.end_regex_pattern.match(line))
-
-    async def _add_column_content(self, context: BlockParsingContext) -> None:
-        context.parent_stack[-1].add_child_line(context.line)
-
-    async def _start_column(self, context: BlockParsingContext) -> None:
+    async def _process_column(self, context: BlockParsingContext) -> None:
         block = self._create_column_block(context.line)
         if not block:
             return
 
-        parent_context = ParentBlockContext(
-            block=block,
-            child_lines=[],
-        )
-        context.parent_stack.append(parent_context)
+        await self._populate_children(block, context)
+        context.result_blocks.append(block)
 
     def _create_column_block(self, line: str) -> CreateColumnBlock | None:
         match = self._syntax.regex_pattern.match(line)
@@ -74,7 +42,7 @@ class ColumnParser(LineParser):
             return None
 
         width_ratio = self._parse_width_ratio(match.group(1))
-        column_data = CreateColumnData(width_ratio=width_ratio)
+        column_data = CreateColumnData(width_ratio=width_ratio, children=[])
 
         return CreateColumnBlock(column=column_data)
 
@@ -84,34 +52,25 @@ class ColumnParser(LineParser):
 
         try:
             width_ratio = float(ratio_str)
-            return width_ratio if self.MIN_WIDTH_RATIO < width_ratio <= self.MAX_WIDTH_RATIO else None
+            return width_ratio if self._is_valid_width_ratio(width_ratio) else None
         except ValueError:
             return None
 
-    async def _finalize_column(self, context: BlockParsingContext) -> None:
-        column_context = context.parent_stack.pop()
-        await self._assign_column_children(column_context, context)
-
-        if self._has_column_list_parent(context):
-            parent = context.parent_stack[-1]
-            parent.add_child_block(column_context.block)
-        else:
-            context.result_blocks.append(column_context.block)
+    def _is_valid_width_ratio(self, width_ratio: float) -> bool:
+        return self.MIN_WIDTH_RATIO < width_ratio <= self.MAX_WIDTH_RATIO
 
-    def _has_column_list_parent(self, context: BlockParsingContext) -> bool:
-        if not context.parent_stack:
-            return False
-        return isinstance(context.parent_stack[-1].block, CreateColumnListBlock)
+    async def _populate_children(self, block: CreateColumnBlock, context: BlockParsingContext) -> None:
+        parent_indent_level = context.get_line_indentation_level()
+        child_lines = context.collect_indented_child_lines(parent_indent_level)
 
-    async def _assign_column_children(self, column_context: ParentBlockContext, context: BlockParsingContext) -> None:
-        all_children = []
-
-        if column_context.child_lines:
-            children_text = "\n".join(column_context.child_lines)
-            text_blocks = await context.parse_nested_content(children_text)
-            all_children.extend(text_blocks)
+        if not child_lines:
+            return
 
-        if column_context.child_blocks:
-            all_children.extend(column_context.child_blocks)
+        child_blocks = await self._parse_indented_children(child_lines, context)
+        block.column.children = child_blocks
+        context.lines_consumed = len(child_lines)
 
-        column_context.block.column.children = all_children
+    async def _parse_indented_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)
+        return await context.parse_nested_markdown(child_markdown)

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

@@ -2,12 +2,11 @@ from typing import override
 
 from notionary.blocks.enums import BlockType
 from notionary.blocks.schemas import BlockCreatePayload, CreateColumnListBlock, CreateColumnListData
-from notionary.page.content.parser.context import ParentBlockContext
 from notionary.page.content.parser.parsers.base import (
     BlockParsingContext,
     LineParser,
 )
-from notionary.page.content.syntax.service import SyntaxRegistry
+from notionary.page.content.syntax import SyntaxRegistry
 
 
 class ColumnListParser(LineParser):
@@ -17,65 +16,66 @@ class ColumnListParser(LineParser):
 
     @override
     def _can_handle(self, context: BlockParsingContext) -> bool:
-        return self._is_column_list_start(context) or self._is_column_list_end(context)
+        return self._is_column_list_start(context)
 
     @override
     async def _process(self, context: BlockParsingContext) -> None:
         if self._is_column_list_start(context):
-            await self._start_column_list(context)
-        elif self._is_column_list_end(context):
-            await self._finalize_column_list(context)
+            await self._process_column_list(context)
 
     def _is_column_list_start(self, context: BlockParsingContext) -> bool:
         return self._syntax.regex_pattern.match(context.line) is not None
 
-    def _is_column_list_end(self, context: BlockParsingContext) -> bool:
-        if not self._syntax.end_regex_pattern.match(context.line):
-            return False
+    async def _process_column_list(self, context: BlockParsingContext) -> None:
+        block = self._create_column_list_block()
+        await self._populate_columns(block, context)
+        context.result_blocks.append(block)
 
-        if not context.parent_stack:
-            return False
+    def _create_column_list_block(self) -> CreateColumnListBlock:
+        column_list_data = CreateColumnListData(children=[])
+        return CreateColumnListBlock(column_list=column_list_data)
 
-        current_parent = context.parent_stack[-1]
-        return isinstance(current_parent.block, CreateColumnListBlock)
+    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)
 
-    async def _start_column_list(self, context: BlockParsingContext) -> None:
-        column_list_data = CreateColumnListData()
-        block = CreateColumnListBlock(column_list=column_list_data)
+        if not child_lines:
+            return
 
-        parent_context = ParentBlockContext(
-            block=block,
-            child_lines=[],
-        )
-        context.parent_stack.append(parent_context)
+        column_blocks = await self._parse_column_children(child_lines, context)
+        block.column_list.children = column_blocks
+        context.lines_consumed = len(child_lines)
 
-    async def _finalize_column_list(self, context: BlockParsingContext) -> None:
-        column_list_context = context.parent_stack.pop()
-        await self._assign_column_list_children(column_list_context, context)
+    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)
+        return self._extract_column_blocks(parsed_blocks)
 
-        if context.parent_stack:
-            parent_context = context.parent_stack[-1]
-            parent_context.add_child_block(column_list_context.block)
-        else:
-            context.result_blocks.append(column_list_context.block)
+    def _collect_children_allowing_empty_lines(
+        self, context: BlockParsingContext, parent_indent_level: int
+    ) -> list[str]:
+        child_lines = []
+        expected_child_indent = parent_indent_level + 1
+        remaining_lines = context.get_remaining_lines()
 
-    async def _assign_column_list_children(
-        self, column_list_context: ParentBlockContext, context: BlockParsingContext
-    ) -> None:
-        all_children = []
+        for line in remaining_lines:
+            if self._should_include_as_child(line, expected_child_indent, context):
+                child_lines.append(line)
+            else:
+                break
 
-        if column_list_context.child_lines:
-            children_text = "\n".join(column_list_context.child_lines)
-            text_blocks = await context.parse_nested_content(children_text)
-            all_children.extend(text_blocks)
+        return child_lines
 
-        if column_list_context.child_blocks:
-            all_children.extend(column_list_context.child_blocks)
+    def _should_include_as_child(self, line: str, expected_indent: int, context: BlockParsingContext) -> bool:
+        if not line.strip():
+            return True
 
-        column_children = self._filter_column_blocks(all_children)
-        column_list_context.block.column_list.children = column_children
+        line_indent = context.get_line_indentation_level(line)
+        return line_indent >= expected_indent
 
-    def _filter_column_blocks(self, blocks: list[BlockCreatePayload]) -> list:
-        return [
-            block for block in blocks if block.type == BlockType.COLUMN and hasattr(block, "column") and block.column
-        ]
+    def _extract_column_blocks(self, blocks: list[BlockCreatePayload]) -> list:
+        return [block for block in blocks if self._is_valid_column_block(block)]
+
+    def _is_valid_column_block(self, block: BlockCreatePayload) -> bool:
+        return block.type == BlockType.COLUMN and block.column is not None

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

@@ -5,7 +5,7 @@ from notionary.page.content.parser.parsers.base import (
     BlockParsingContext,
     LineParser,
 )
-from notionary.page.content.syntax.service import SyntaxRegistry
+from notionary.page.content.syntax import SyntaxRegistry
 
 
 class DividerParser(LineParser):

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

@@ -4,7 +4,7 @@ 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.service import SyntaxRegistry
+from notionary.page.content.syntax import SyntaxRegistry
 
 
 class EmbedParser(LineParser):

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

@@ -5,7 +5,7 @@ from notionary.page.content.parser.parsers.base import (
     BlockParsingContext,
     LineParser,
 )
-from notionary.page.content.syntax.service import SyntaxRegistry
+from notionary.page.content.syntax import SyntaxRegistry
 
 
 class EquationParser(LineParser):

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

@@ -9,7 +9,7 @@ from notionary.blocks.schemas import (
     FileType,
 )
 from notionary.page.content.parser.parsers.base import BlockParsingContext, LineParser
-from notionary.page.content.syntax.service import SyntaxRegistry
+from notionary.page.content.syntax import SyntaxRegistry
 
 
 class FileParser(LineParser):

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

@@ -3,6 +3,8 @@ from typing import override
 from notionary.blocks.rich_text.markdown_rich_text_converter import MarkdownRichTextConverter
 from notionary.blocks.schemas import (
     BlockColor,
+    BlockCreatePayload,
+    BlockType,
     CreateHeading1Block,
     CreateHeading2Block,
     CreateHeading3Block,
@@ -13,10 +15,13 @@ from notionary.page.content.parser.parsers.base import (
     BlockParsingContext,
     LineParser,
 )
-from notionary.page.content.syntax.service import SyntaxRegistry
+from notionary.page.content.syntax import SyntaxRegistry
 
 
 class HeadingParser(LineParser):
+    MIN_HEADING_LEVEL = 1
+    MAX_HEADING_LEVEL = 3
+
     def __init__(self, syntax_registry: SyntaxRegistry, rich_text_converter: MarkdownRichTextConverter) -> None:
         super().__init__(syntax_registry)
         self._syntax = syntax_registry.get_heading_syntax()
@@ -31,8 +36,54 @@ class HeadingParser(LineParser):
     @override
     async def _process(self, context: BlockParsingContext) -> None:
         block = await self._create_heading_block(context.line)
-        if block:
-            context.result_blocks.append(block)
+        if not block:
+            return
+
+        await self._process_nested_children(block, context)
+        context.result_blocks.append(block)
+
+    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)
+
+        if not child_lines:
+            return
+
+        child_lines = self._remove_trailing_empty_lines(child_lines)
+
+        if not child_lines:
+            return
+
+        self._set_heading_toggleable(block, True)
+
+        stripped_lines = context.strip_indentation_level(child_lines, levels=1)
+        child_markdown = "\n".join(stripped_lines)
+
+        child_blocks = await context.parse_nested_markdown(child_markdown)
+        self._set_heading_children(block, child_blocks)
+
+        context.lines_consumed = len(child_lines)
+
+    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:
+            block.heading_2.is_toggleable = is_toggleable
+        elif block.type == BlockType.HEADING_3:
+            block.heading_3.is_toggleable = is_toggleable
+
+    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:
+            block.heading_2.children = children
+        elif block.type == BlockType.HEADING_3:
+            block.heading_3.children = children
+
+    def _remove_trailing_empty_lines(self, lines: list[str]) -> list[str]:
+        while lines and not lines[-1].strip():
+            lines.pop()
+        return lines
 
     async def _create_heading_block(self, line: str) -> CreateHeadingBlock | None:
         match = self._syntax.regex_pattern.match(line)
@@ -40,16 +91,22 @@ class HeadingParser(LineParser):
             return None
 
         level = len(match.group(1))
-        if level < 1 or level > 3:
-            return None
-
         content = match.group(2).strip()
-        if not content:
+
+        if not self._is_valid_heading(level, content):
             return None
 
+        heading_data = await self._build_heading_data(content)
+        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)
+
+    async def _build_heading_data(self, content: str) -> CreateHeadingData:
         rich_text = await self._rich_text_converter.to_rich_text(content)
-        heading_data = CreateHeadingData(rich_text=rich_text, color=BlockColor.DEFAULT, is_toggleable=False)
+        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

@@ -9,7 +9,7 @@ from notionary.blocks.schemas import (
     FileType,
 )
 from notionary.page.content.parser.parsers.base import BlockParsingContext, LineParser
-from notionary.page.content.syntax.service import SyntaxRegistry
+from notionary.page.content.syntax import SyntaxRegistry
 
 
 class ImageParser(LineParser):