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

notionary/page/content/markdown/structured_output/service.py

@@ -0,0 +1,211 @@
+from __future__ import annotations
+
+from notionary.page.content.markdown.builder import MarkdownBuilder
+from notionary.page.content.markdown.structured_output.models import (
+    AudioSchema,
+    BookmarkSchema,
+    BreadcrumbSchema,
+    BulletedListItemSchema,
+    BulletedListSchema,
+    CalloutSchema,
+    CodeSchema,
+    ColumnsSchema,
+    EmbedSchema,
+    EquationSchema,
+    FileSchema,
+    Heading1Schema,
+    Heading2Schema,
+    Heading3Schema,
+    ImageSchema,
+    MarkdownDocumentSchema,
+    MarkdownNodeSchema,
+    MermaidSchema,
+    NumberedListItemSchema,
+    NumberedListSchema,
+    ParagraphSchema,
+    PdfSchema,
+    QuoteSchema,
+    TableOfContentsSchema,
+    TableSchema,
+    TodoListSchema,
+    TodoSchema,
+    ToggleSchema,
+    VideoSchema,
+)
+from notionary.utils.decorators import time_execution_sync
+from notionary.utils.mixins.logging import LoggingMixin
+
+
+class StructuredOutputMarkdownConverter(LoggingMixin):
+    def __init__(self, builder: MarkdownBuilder | None = None) -> None:
+        self.builder = builder or MarkdownBuilder()
+
+    @time_execution_sync()
+    def convert(self, schema: MarkdownDocumentSchema) -> str:
+        for node in schema.nodes:
+            self._process_node(node)
+        return self.builder.build()
+
+    def _process_node(self, node: MarkdownNodeSchema) -> None:
+        node.process_with(self)
+
+    def _process_heading_1(self, node: Heading1Schema) -> None:
+        builder_func = (
+            self._create_children_builder(node.children) if node.children else None
+        )
+        self.builder.h1(node.text, builder_func)
+
+    def _process_heading_2(self, node: Heading2Schema) -> None:
+        builder_func = (
+            self._create_children_builder(node.children) if node.children else None
+        )
+        self.builder.h2(node.text, builder_func)
+
+    def _process_heading_3(self, node: Heading3Schema) -> None:
+        builder_func = (
+            self._create_children_builder(node.children) if node.children else None
+        )
+        self.builder.h3(node.text, builder_func)
+
+    def _process_paragraph(self, node: ParagraphSchema) -> None:
+        self.builder.paragraph(node.text)
+
+    def _process_space(self) -> None:
+        self.builder.space()
+
+    def _process_divider(self) -> None:
+        self.builder.divider()
+
+    def _process_quote(self, node: QuoteSchema) -> None:
+        builder_func = (
+            self._create_children_builder(node.children) if node.children else None
+        )
+        self.builder.quote(node.text, builder_func)
+
+    def _process_bulleted_list(self, node: BulletedListSchema) -> None:
+        has_children = any(item.children for item in node.items)
+
+        if has_children:
+            for item in node.items:
+                self._process_bulleted_list_item(item)
+        else:
+            texts = [item.text for item in node.items]
+            self.builder.bulleted_list(texts)
+
+    def _process_bulleted_list_item(self, node: BulletedListItemSchema) -> None:
+        builder_func = (
+            self._create_children_builder(node.children) if node.children else None
+        )
+        self.builder.bulleted_list_item(node.text, builder_func)
+
+    def _process_numbered_list(self, node: NumberedListSchema) -> None:
+        has_children = any(item.children for item in node.items)
+
+        if has_children:
+            for item in node.items:
+                self._process_numbered_list_item(item)
+        else:
+            texts = [item.text for item in node.items]
+            self.builder.numbered_list(texts)
+
+    def _process_numbered_list_item(self, node: NumberedListItemSchema) -> None:
+        builder_func = (
+            self._create_children_builder(node.children) if node.children else None
+        )
+        self.builder.numbered_list_item(node.text, builder_func)
+
+    def _process_todo(self, node: TodoSchema) -> None:
+        builder_func = (
+            self._create_children_builder(node.children) if node.children else None
+        )
+        self.builder.todo(node.text, checked=node.checked, builder_func=builder_func)
+
+    def _process_todo_list(self, node: TodoListSchema) -> None:
+        has_children = any(item.children for item in node.items)
+
+        if has_children:
+            for todo_item in node.items:
+                self._process_todo(todo_item)
+        else:
+            texts = [item.text for item in node.items]
+            completed = [item.checked for item in node.items]
+            self.builder.todo_list(texts, completed)
+
+    def _process_callout(self, node: CalloutSchema) -> None:
+        if node.children:
+            builder_func = self._create_children_builder(node.children)
+            self.builder.callout_with_children(node.text, node.emoji, builder_func)
+        else:
+            self.builder.callout(node.text, node.emoji)
+
+    def _process_toggle(self, node: ToggleSchema) -> None:
+        builder_func = self._create_children_builder(node.children)
+        self.builder.toggle(node.title, builder_func)
+
+    def _process_image(self, node: ImageSchema) -> None:
+        self.builder.image(node.url, node.caption)
+
+    def _process_video(self, node: VideoSchema) -> None:
+        self.builder.video(node.url, node.caption)
+
+    def _process_audio(self, node: AudioSchema) -> None:
+        self.builder.audio(node.url, node.caption)
+
+    def _process_file(self, node: FileSchema) -> None:
+        self.builder.file(node.url, node.caption)
+
+    def _process_pdf(self, node: PdfSchema) -> None:
+        self.builder.pdf(node.url, node.caption)
+
+    def _process_bookmark(self, node: BookmarkSchema) -> None:
+        self.builder.bookmark(node.url, node.title, node.caption)
+
+    def _process_embed(self, node: EmbedSchema) -> None:
+        self.builder.embed(node.url, node.caption)
+
+    def _process_code(self, node: CodeSchema) -> None:
+        self.builder.code(node.code, node.language, node.caption)
+
+    def _process_mermaid(self, node: MermaidSchema) -> None:
+        self.builder.mermaid(node.diagram, node.caption)
+
+    def _process_table(self, node: TableSchema) -> None:
+        self.builder.table(node.headers, node.rows)
+
+    def _process_breadcrumb(self, node: BreadcrumbSchema) -> None:
+        self.builder.breadcrumb()
+
+    def _process_equation(self, node: EquationSchema) -> None:
+        self.builder.equation(node.expression)
+
+    def _process_table_of_contents(self, node: TableOfContentsSchema) -> None:
+        self.builder.table_of_contents()
+
+    def _process_columns(self, node: ColumnsSchema) -> None:
+        builder_funcs = []
+        width_ratios = []
+
+        for column in node.columns:
+            builder_func = self._create_children_builder(column.children)
+            builder_funcs.append(builder_func)
+            width_ratios.append(column.width_ratio)
+
+        if any(r is not None for r in width_ratios):
+            self.builder.columns(*builder_funcs, width_ratios=width_ratios)
+        else:
+            self.builder.columns(*builder_funcs)
+
+    def _create_children_builder(self, children: list[MarkdownNodeSchema] | None):
+        if not children:
+            return None
+
+        captured_children = children
+
+        def builder_func(builder: MarkdownBuilder) -> MarkdownBuilder:
+            converter = StructuredOutputMarkdownConverter()
+            converter.builder = builder
+            for child in captured_children:
+                converter._process_node(child)
+            return builder
+
+        return builder_func

notionary/page/content/parser/context.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from collections.abc import Awaitable, Callable
 
 from notionary.blocks.schemas import BlockCreatePayload
-from notionary.page.content.syntax.grammar import MarkdownGrammar
+from notionary.page.content.syntax.definition.grammar import MarkdownGrammar
 
 
 class ParentBlockContext:

notionary/page/content/parser/factory.py

@@ -1,6 +1,7 @@
 from notionary.blocks.rich_text.markdown_rich_text_converter import (
     MarkdownRichTextConverter,
 )
+from notionary.file_upload.service import NotionFileUpload
 from notionary.page.content.parser.parsers import (
     AudioParser,
     BookmarkParser,
@@ -29,17 +30,19 @@ from notionary.page.content.parser.parsers import (
     ToggleParser,
     VideoParser,
 )
-from notionary.page.content.syntax import SyntaxRegistry
+from notionary.page.content.syntax.definition import SyntaxDefinitionRegistry
 
 
 class ConverterChainFactory:
     def __init__(
         self,
         rich_text_converter: MarkdownRichTextConverter | None = None,
-        syntax_registry: SyntaxRegistry | None = None,
+        syntax_registry: SyntaxDefinitionRegistry | None = None,
+        file_upload_service: NotionFileUpload | None = None,
     ) -> None:
         self._rich_text_converter = rich_text_converter or MarkdownRichTextConverter()
-        self._syntax_registry = syntax_registry or SyntaxRegistry()
+        self._syntax_registry = syntax_registry or SyntaxDefinitionRegistry()
+        self._file_upload_service = file_upload_service
 
     def create(self) -> LineParser:
         # multi-line (structural) blocks
@@ -186,19 +189,34 @@ class ConverterChainFactory:
         return EmbedParser(syntax_registry=self._syntax_registry)
 
     def _create_image_parser(self) -> ImageParser:
-        return ImageParser(syntax_registry=self._syntax_registry)
+        return ImageParser(
+            syntax_registry=self._syntax_registry,
+            file_upload_service=self._file_upload_service,
+        )
 
     def _create_video_parser(self) -> VideoParser:
-        return VideoParser(syntax_registry=self._syntax_registry)
+        return VideoParser(
+            syntax_registry=self._syntax_registry,
+            file_upload_service=self._file_upload_service,
+        )
 
     def _create_audio_parser(self) -> AudioParser:
-        return AudioParser(syntax_registry=self._syntax_registry)
+        return AudioParser(
+            syntax_registry=self._syntax_registry,
+            file_upload_service=self._file_upload_service,
+        )
 
     def _create_file_parser(self) -> FileParser:
-        return FileParser(syntax_registry=self._syntax_registry)
+        return FileParser(
+            syntax_registry=self._syntax_registry,
+            file_upload_service=self._file_upload_service,
+        )
 
     def _create_pdf_parser(self) -> PdfParser:
-        return PdfParser(syntax_registry=self._syntax_registry)
+        return PdfParser(
+            syntax_registry=self._syntax_registry,
+            file_upload_service=self._file_upload_service,
+        )
 
     def _create_caption_parser(self) -> CaptionParser:
         return CaptionParser(

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

@@ -1,40 +1,20 @@
 from typing import override
 
-from notionary.blocks.schemas import (
-    CreateAudioBlock,
-    ExternalFile,
-    FileData,
-    FileType,
+from notionary.blocks.schemas import CreateAudioBlock, 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 AudioParser(LineParser):
-    def __init__(self, syntax_registry: SyntaxRegistry) -> None:
-        super().__init__(syntax_registry)
-        self._syntax = syntax_registry.get_audio_syntax()
-
+class AudioParser(FileLikeBlockParser[CreateAudioBlock]):
     @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_audio_syntax()
 
     @override
-    async def _process(self, context: BlockParsingContext) -> None:
-        url = self._extract_url(context.line)
-        if url is None:
-            return
-
-        audio_data = FileData(
-            type=FileType.EXTERNAL,
-            external=ExternalFile(url=url),
-            caption=[],
-        )
-        block = CreateAudioBlock(audio=audio_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) -> CreateAudioBlock:
+        return CreateAudioBlock(audio=file_data)

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

@@ -3,11 +3,11 @@ from __future__ import annotations
 from abc import ABC, abstractmethod
 
 from notionary.page.content.parser.context import BlockParsingContext
-from notionary.page.content.syntax import SyntaxRegistry
+from notionary.page.content.syntax.definition import SyntaxDefinitionRegistry
 
 
 class LineParser(ABC):
-    def __init__(self, syntax_registry: SyntaxRegistry | None = None) -> None:
+    def __init__(self, syntax_registry: SyntaxDefinitionRegistry | None = None) -> None:
         self._next_handler: LineParser | None = None
         self._syntax_registry = syntax_registry
 

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

@@ -4,11 +4,11 @@ from typing import override
 
 from notionary.blocks.schemas import BookmarkData, CreateBookmarkBlock
 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 BookmarkParser(LineParser):
-    def __init__(self, syntax_registry: SyntaxRegistry) -> None:
+    def __init__(self, syntax_registry: SyntaxDefinitionRegistry) -> None:
         super().__init__(syntax_registry)
         self._syntax = syntax_registry.get_bookmark_syntax()
 

notionary/page/content/parser/parsers/breadcrumb.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 BreadcrumbParser(LineParser):
-    def __init__(self, syntax_registry: SyntaxRegistry) -> None:
+    def __init__(self, syntax_registry: SyntaxDefinitionRegistry) -> None:
         super().__init__(syntax_registry)
         self._syntax = syntax_registry.get_breadcrumb_syntax()
 

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

@@ -3,16 +3,23 @@ from typing import override
 from notionary.blocks.rich_text.markdown_rich_text_converter import (
     MarkdownRichTextConverter,
 )
-from notionary.blocks.schemas import CreateBulletedListItemBlock, CreateBulletedListItemData
+from notionary.blocks.schemas import (
+    CreateBulletedListItemBlock,
+    CreateBulletedListItemData,
+)
 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 BulletedListParser(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_bulleted_list_syntax()
         self._rich_text_converter = rich_text_converter
@@ -35,7 +42,9 @@ class BulletedListParser(LineParser):
         await self._process_nested_children(block, context)
         context.result_blocks.append(block)
 
-    async def _process_nested_children(self, block: CreateBulletedListItemBlock, context: BlockParsingContext) -> None:
+    async def _process_nested_children(
+        self, block: CreateBulletedListItemBlock, context: BlockParsingContext
+    ) -> None:
         child_lines = self._collect_child_lines(context)
         if not child_lines:
             return
@@ -57,13 +66,17 @@ class BulletedListParser(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_bulleted_list_block(self, text: str) -> CreateBulletedListItemBlock | None:
+    async def _create_bulleted_list_block(
+        self, text: str
+    ) -> CreateBulletedListItemBlock | None:
         content = self._extract_list_content(text)
         if content is None:
             return None

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

@@ -1,20 +1,26 @@
 import re
 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 CreateCalloutBlock, CreateCalloutData
 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
 from notionary.shared.models.icon import EmojiIcon
 
 
 class CalloutParser(LineParser):
     DEFAULT_EMOJI = "💡"
 
-    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_callout_syntax()
         self._pattern = self._syntax.regex_pattern
@@ -37,7 +43,9 @@ class CalloutParser(LineParser):
         else:
             context.result_blocks.append(block)
 
-    async def _process_nested_children(self, block: CreateCalloutBlock, context: BlockParsingContext) -> None:
+    async def _process_nested_children(
+        self, block: CreateCalloutBlock, context: BlockParsingContext
+    ) -> None:
         child_lines = self._collect_child_lines(context)
         if not child_lines:
             return
@@ -59,7 +67,9 @@ class CalloutParser(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:

notionary/page/content/parser/parsers/caption.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 CaptionParser(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_caption_syntax()
         self._rich_text_converter = rich_text_converter
@@ -49,7 +53,9 @@ class CaptionParser(LineParser):
             return False
         return hasattr(block_data, "caption")
 
-    def _attach_caption_to_block(self, block: BlockCreatePayload, caption_rich_text: list) -> None:
+    def _attach_caption_to_block(
+        self, block: BlockCreatePayload, caption_rich_text: list
+    ) -> None:
         block_data = getattr(block, block.type.value)
         if hasattr(block_data, "caption"):
             block_data.caption = caption_rich_text

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

@@ -1,22 +1,30 @@
 import re
 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 CodeData, CodingLanguage, CreateCodeBlock
 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 CodeParser(LineParser):
     DEFAULT_LANGUAGE = CodingLanguage.PLAIN_TEXT
 
-    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_code_syntax()
         self._rich_text_converter = rich_text_converter
         self._code_start_pattern = self._syntax.regex_pattern
-        self._code_end_pattern = self._syntax.end_regex_pattern or re.compile(r"^```\s*$")
+        self._code_end_pattern = self._syntax.end_regex_pattern or re.compile(
+            r"^```\s*$"
+        )
 
     @override
     def _can_handle(self, context: BlockParsingContext) -> bool:
@@ -29,7 +37,9 @@ class CodeParser(LineParser):
         code_lines = self._collect_code_lines(context)
         lines_consumed = self._count_lines_consumed(context)
 
-        block = await self._create_code_block(opening_line=context.line, code_lines=code_lines)
+        block = await self._create_code_block(
+            opening_line=context.line, code_lines=code_lines
+        )
         if not block:
             return
 
@@ -56,7 +66,9 @@ class CodeParser(LineParser):
                 return line_index + 1
         return len(context.get_remaining_lines())
 
-    async def _create_code_block(self, opening_line: str, code_lines: list[str]) -> CreateCodeBlock | None:
+    async def _create_code_block(
+        self, opening_line: str, code_lines: list[str]
+    ) -> CreateCodeBlock | None:
         match = self._code_start_pattern.match(opening_line)
         if not match:
             return None
@@ -70,7 +82,9 @@ class CodeParser(LineParser):
     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]:
+    async def _create_rich_text_from_code(
+        self, code_lines: list[str]
+    ) -> list[RichText]:
         content = "\n".join(code_lines) if code_lines else ""
         return await self._rich_text_converter.to_rich_text(content)
 

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

@@ -5,14 +5,14 @@ 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 ColumnParser(LineParser):
     MIN_WIDTH_RATIO = 0
     MAX_WIDTH_RATIO = 1.0
 
-    def __init__(self, syntax_registry: SyntaxRegistry) -> None:
+    def __init__(self, syntax_registry: SyntaxDefinitionRegistry) -> None:
         super().__init__(syntax_registry)
         self._syntax = syntax_registry.get_column_syntax()
 
@@ -59,7 +59,9 @@ class ColumnParser(LineParser):
     def _is_valid_width_ratio(self, width_ratio: float) -> bool:
         return self.MIN_WIDTH_RATIO < width_ratio <= self.MAX_WIDTH_RATIO
 
-    async def _populate_children(self, block: CreateColumnBlock, context: BlockParsingContext) -> None:
+    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)
 
@@ -70,7 +72,9 @@ class ColumnParser(LineParser):
         block.column.children = child_blocks
         context.lines_consumed = len(child_lines)
 
-    async def _parse_indented_children(self, child_lines: list[str], context: BlockParsingContext) -> list:
+    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)