notionary 0.2.27__py3-none-any.whl → 0.3.0__py3-none-any.whl

notionary/page/content/factory.py

@@ -0,0 +1,73 @@
+from notionary.blocks.client import NotionBlockHttpClient
+from notionary.page.content.parser.factory import ConverterChainFactory
+from notionary.page.content.parser.post_processing.handlers import RichTextLengthTruncationPostProcessor
+from notionary.page.content.parser.post_processing.service import BlockPostProcessor
+from notionary.page.content.parser.pre_processsing.handlers import (
+    ColumnSyntaxPreProcessor,
+    IndentationNormalizer,
+    WhitespacePreProcessor,
+)
+from notionary.page.content.parser.pre_processsing.service import MarkdownPreProcessor
+from notionary.page.content.parser.service import MarkdownToNotionConverter
+from notionary.page.content.renderer.factory import RendererChainFactory
+from notionary.page.content.renderer.post_processing.handlers import NumberedListPlaceholderReplacerPostProcessor
+from notionary.page.content.renderer.post_processing.service import MarkdownRenderingPostProcessor
+from notionary.page.content.renderer.service import NotionToMarkdownConverter
+from notionary.page.content.service import PageContentService
+
+
+class PageContentServiceFactory:
+    def __init__(
+        self,
+        converter_chain_factory: ConverterChainFactory | None = None,
+        renderer_chain_factory: RendererChainFactory | None = None,
+    ) -> None:
+        self._converter_chain_factory = converter_chain_factory or ConverterChainFactory()
+        self._renderer_chain_factory = renderer_chain_factory or RendererChainFactory()
+
+    def create(self, page_id: str, block_client: NotionBlockHttpClient) -> PageContentService:
+        markdown_converter = self._create_markdown_to_notion_converter()
+        notion_to_markdown_converter = self._create_notion_to_markdown_converter()
+
+        return PageContentService(
+            page_id=page_id,
+            block_client=block_client,
+            markdown_converter=markdown_converter,
+            notion_to_markdown_converter=notion_to_markdown_converter,
+        )
+
+    def _create_markdown_to_notion_converter(self) -> MarkdownToNotionConverter:
+        line_parser = self._converter_chain_factory.create()
+        markdown_pre_processor = self._create_markdown_preprocessor()
+        block_post_processor = self._create_post_processor()
+
+        return MarkdownToNotionConverter(
+            line_parser=line_parser,
+            pre_processor=markdown_pre_processor,
+            post_processor=block_post_processor,
+        )
+
+    def _create_notion_to_markdown_converter(self) -> NotionToMarkdownConverter:
+        renderer_chain = self._renderer_chain_factory.create()
+        markdown_rendering_post_processor = self._create_markdown_rendering_post_processor()
+        return NotionToMarkdownConverter(
+            renderer_chain=renderer_chain,
+            post_processor=markdown_rendering_post_processor,
+        )
+
+    def _create_markdown_preprocessor(self) -> MarkdownPreProcessor:
+        pre_processor = MarkdownPreProcessor()
+        pre_processor.register(ColumnSyntaxPreProcessor())
+        pre_processor.register(WhitespacePreProcessor())
+        pre_processor.register(IndentationNormalizer())
+        return pre_processor
+
+    def _create_post_processor(self) -> BlockPostProcessor:
+        post_processor = BlockPostProcessor()
+        post_processor.register(RichTextLengthTruncationPostProcessor())
+        return post_processor
+
+    def _create_markdown_rendering_post_processor(self) -> MarkdownRenderingPostProcessor:
+        post_processor = MarkdownRenderingPostProcessor()
+        post_processor.register(NumberedListPlaceholderReplacerPostProcessor())
+        return post_processor

notionary/page/content/markdown/__init__.py

@@ -0,0 +1,5 @@
+from .builder import MarkdownBuilder
+
+__all__ = [
+    "MarkdownBuilder",
+]

notionary/page/content/markdown/builder.py

@@ -0,0 +1,226 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Self
+
+from notionary.blocks.enums import CodingLanguage
+from notionary.page.content.markdown.nodes import (
+    AudioMarkdownNode,
+    BookmarkMarkdownNode,
+    BreadcrumbMarkdownNode,
+    BulletedListMarkdownNode,
+    CalloutMarkdownNode,
+    CodeMarkdownNode,
+    ColumnListMarkdownNode,
+    ColumnMarkdownNode,
+    DividerMarkdownNode,
+    EmbedMarkdownNode,
+    EquationMarkdownNode,
+    FileMarkdownNode,
+    HeadingMarkdownNode,
+    ImageMarkdownNode,
+    MarkdownNode,
+    NumberedListMarkdownNode,
+    ParagraphMarkdownNode,
+    PdfMarkdownNode,
+    QuoteMarkdownNode,
+    SpaceMarkdownNode,
+    TableMarkdownNode,
+    TableOfContentsMarkdownNode,
+    TodoMarkdownNode,
+    ToggleMarkdownNode,
+    VideoMarkdownNode,
+)
+from notionary.page.content.markdown.nodes.container import flatten_children
+
+
+class MarkdownBuilder:
+    def __init__(self) -> None:
+        self.children: list[MarkdownNode] = []
+
+    def h1(self, text: str, builder_func: Callable[[MarkdownBuilder], MarkdownBuilder] | None = None) -> Self:
+        return self._add_heading(text, 1, builder_func)
+
+    def h2(self, text: str, builder_func: Callable[[MarkdownBuilder], MarkdownBuilder] | None = None) -> Self:
+        return self._add_heading(text, 2, builder_func)
+
+    def h3(self, text: str, builder_func: Callable[[MarkdownBuilder], MarkdownBuilder] | None = None) -> Self:
+        return self._add_heading(text, 3, builder_func)
+
+    def paragraph(self, text: str) -> Self:
+        self.children.append(ParagraphMarkdownNode(text=text))
+        return self
+
+    def space(self) -> Self:
+        self.children.append(SpaceMarkdownNode())
+        return self
+
+    def quote(self, text: str, builder_func: Callable[[MarkdownBuilder], MarkdownBuilder] | None = None) -> Self:
+        children = self._build_children(builder_func)
+        self.children.append(QuoteMarkdownNode(text=text, children=children))
+        return self
+
+    def divider(self) -> Self:
+        self.children.append(DividerMarkdownNode())
+        return self
+
+    def numbered_list(self, items: list[str]) -> Self:
+        self.children.append(NumberedListMarkdownNode(texts=items))
+        return self
+
+    def numbered_list_item(
+        self, text: str, builder_func: Callable[[MarkdownBuilder], MarkdownBuilder] | None = None
+    ) -> Self:
+        children = self._build_children(builder_func)
+        wrapped = flatten_children(children)
+        child_nodes = [wrapped] if wrapped else None
+        self.children.append(NumberedListMarkdownNode(texts=[text], children=child_nodes))
+        return self
+
+    def bulleted_list(self, items: list[str]) -> Self:
+        self.children.append(BulletedListMarkdownNode(texts=items))
+        return self
+
+    def bulleted_list_item(
+        self, text: str, builder_func: Callable[[MarkdownBuilder], MarkdownBuilder] | None = None
+    ) -> Self:
+        children = self._build_children(builder_func)
+        wrapped = flatten_children(children)
+        child_nodes = [wrapped] if wrapped else None
+        self.children.append(BulletedListMarkdownNode(texts=[text], children=child_nodes))
+        return self
+
+    def todo(
+        self,
+        text: str,
+        checked: bool = False,
+        builder_func: Callable[[MarkdownBuilder], MarkdownBuilder] | None = None,
+    ) -> Self:
+        children = self._build_children(builder_func)
+        self.children.append(TodoMarkdownNode(text=text, checked=checked, children=children))
+        return self
+
+    def checked_todo(self, text: str, builder_func: Callable[[MarkdownBuilder], MarkdownBuilder] | None = None) -> Self:
+        return self.todo(text, checked=True, builder_func=builder_func)
+
+    def unchecked_todo(
+        self, text: str, builder_func: Callable[[MarkdownBuilder], MarkdownBuilder] | None = None
+    ) -> Self:
+        return self.todo(text, checked=False, builder_func=builder_func)
+
+    def todo_list(self, items: list[str], completed: list[bool] | None = None) -> Self:
+        completed = completed or [False] * len(items)
+        for i, item in enumerate(items):
+            is_done = completed[i] if i < len(completed) else False
+            self.children.append(TodoMarkdownNode(text=item, checked=is_done))
+        return self
+
+    def callout(self, text: str, emoji: str | None = None) -> Self:
+        self.children.append(CalloutMarkdownNode(text=text, emoji=emoji))
+        return self
+
+    def callout_with_children(
+        self,
+        text: str,
+        emoji: str | None = None,
+        builder_func: Callable[[MarkdownBuilder], MarkdownBuilder] | None = None,
+    ) -> Self:
+        children = self._build_children(builder_func)
+        self.children.append(CalloutMarkdownNode(text=text, emoji=emoji, children=children))
+        return self
+
+    def toggle(self, title: str, builder_func: Callable[[MarkdownBuilder], MarkdownBuilder]) -> Self:
+        children = self._build_children(builder_func)
+        self.children.append(ToggleMarkdownNode(title=title, children=children))
+        return self
+
+    def image(self, url: str, caption: str | None = None) -> Self:
+        self.children.append(ImageMarkdownNode(url=url, caption=caption))
+        return self
+
+    def video(self, url: str, caption: str | None = None) -> Self:
+        self.children.append(VideoMarkdownNode(url=url, caption=caption))
+        return self
+
+    def audio(self, url: str, caption: str | None = None) -> Self:
+        self.children.append(AudioMarkdownNode(url=url, caption=caption))
+        return self
+
+    def file(self, url: str, caption: str | None = None) -> Self:
+        self.children.append(FileMarkdownNode(url=url, caption=caption))
+        return self
+
+    def pdf(self, url: str, caption: str | None = None) -> Self:
+        self.children.append(PdfMarkdownNode(url=url, caption=caption))
+        return self
+
+    def bookmark(self, url: str, title: str | None = None, caption: str | None = None) -> Self:
+        self.children.append(BookmarkMarkdownNode(url=url, title=title, caption=caption))
+        return self
+
+    def embed(self, url: str, caption: str | None = None) -> Self:
+        self.children.append(EmbedMarkdownNode(url=url, caption=caption))
+        return self
+
+    def code(self, code: str, language: CodingLanguage | None = None, caption: str | None = None) -> Self:
+        self.children.append(CodeMarkdownNode(code=code, language=language, caption=caption))
+        return self
+
+    def mermaid(self, diagram: str, caption: str | None = None) -> Self:
+        self.children.append(CodeMarkdownNode(code=diagram, language=CodingLanguage.MERMAID.value, caption=caption))
+        return self
+
+    def table(self, headers: list[str], rows: list[list[str]]) -> Self:
+        self.children.append(TableMarkdownNode(headers=headers, rows=rows))
+        return self
+
+    def breadcrumb(self) -> Self:
+        self.children.append(BreadcrumbMarkdownNode())
+        return self
+
+    def equation(self, expression: str) -> Self:
+        self.children.append(EquationMarkdownNode(expression=expression))
+        return self
+
+    def table_of_contents(self) -> Self:
+        self.children.append(TableOfContentsMarkdownNode())
+        return self
+
+    def columns(
+        self,
+        *builder_funcs: Callable[[MarkdownBuilder], MarkdownBuilder],
+        width_ratios: list[float] | None = None,
+    ) -> Self:
+        columns = self._build_columns(builder_funcs, width_ratios)
+        self.children.append(ColumnListMarkdownNode(columns=columns))
+        return self
+
+    def build(self) -> str:
+        return "\n\n".join(child.to_markdown() for child in self.children if child is not None)
+
+    def _add_heading(
+        self, text: str, level: int, builder_func: Callable[[MarkdownBuilder], MarkdownBuilder] | None
+    ) -> Self:
+        children = self._build_children(builder_func)
+        self.children.append(HeadingMarkdownNode(text=text, level=level, children=children))
+        return self
+
+    def _build_children(self, builder_func: Callable[[MarkdownBuilder], MarkdownBuilder] | None) -> list[MarkdownNode]:
+        if builder_func is None:
+            return []
+
+        builder = MarkdownBuilder()
+        builder_func(builder)
+        return builder.children
+
+    def _build_columns(
+        self,
+        builder_funcs: tuple[Callable[[MarkdownBuilder], MarkdownBuilder], ...],
+        width_ratios: list[float] | None,
+    ) -> list[ColumnMarkdownNode]:
+        columns = []
+        for i, builder_func in enumerate(builder_funcs):
+            width_ratio = width_ratios[i] if width_ratios else None
+            children = self._build_children(builder_func)
+            columns.append(ColumnMarkdownNode(children=children, width_ratio=width_ratio))
+        return columns

notionary/page/content/markdown/nodes/__init__.py

@@ -0,0 +1,52 @@
+from .audio import AudioMarkdownNode
+from .base import MarkdownNode
+from .bookmark import BookmarkMarkdownNode
+from .breadcrumb import BreadcrumbMarkdownNode
+from .bulleted_list import BulletedListMarkdownNode
+from .callout import CalloutMarkdownNode
+from .code import CodeMarkdownNode
+from .columns import ColumnListMarkdownNode, ColumnMarkdownNode
+from .divider import DividerMarkdownNode
+from .embed import EmbedMarkdownNode
+from .equation import EquationMarkdownNode
+from .file import FileMarkdownNode
+from .heading import HeadingMarkdownNode
+from .image import ImageMarkdownNode
+from .numbered_list import NumberedListMarkdownNode
+from .paragraph import ParagraphMarkdownNode
+from .pdf import PdfMarkdownNode
+from .quote import QuoteMarkdownNode
+from .space import SpaceMarkdownNode
+from .table import TableMarkdownNode
+from .table_of_contents import TableOfContentsMarkdownNode
+from .todo import TodoMarkdownNode
+from .toggle import ToggleMarkdownNode
+from .video import VideoMarkdownNode
+
+__all__ = [
+    "AudioMarkdownNode",
+    "BookmarkMarkdownNode",
+    "BreadcrumbMarkdownNode",
+    "BulletedListMarkdownNode",
+    "CalloutMarkdownNode",
+    "CodeMarkdownNode",
+    "ColumnListMarkdownNode",
+    "ColumnMarkdownNode",
+    "DividerMarkdownNode",
+    "EmbedMarkdownNode",
+    "EquationMarkdownNode",
+    "FileMarkdownNode",
+    "HeadingMarkdownNode",
+    "ImageMarkdownNode",
+    "MarkdownNode",
+    "NumberedListMarkdownNode",
+    "ParagraphMarkdownNode",
+    "PdfMarkdownNode",
+    "QuoteMarkdownNode",
+    "SpaceMarkdownNode",
+    "TableMarkdownNode",
+    "TableOfContentsMarkdownNode",
+    "TodoMarkdownNode",
+    "ToggleMarkdownNode",
+    "VideoMarkdownNode",
+]

notionary/page/content/markdown/nodes/audio.py

@@ -0,0 +1,23 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.markdown.nodes.mixins.caption import CaptionMarkdownNodeMixin
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class AudioMarkdownNode(MarkdownNode, CaptionMarkdownNodeMixin):
+    def __init__(
+        self,
+        url: str,
+        caption: str | None = None,
+        syntax_registry: SyntaxRegistry | None = None,
+    ) -> None:
+        super().__init__(syntax_registry=syntax_registry)
+        self.url = url
+        self.caption = caption
+
+    @override
+    def to_markdown(self) -> str:
+        audio_syntax = self._syntax_registry.get_audio_syntax()
+        base_markdown = f"{audio_syntax.start_delimiter}{self.url}{audio_syntax.end_delimiter}"
+        return self._append_caption_to_markdown(base_markdown, self.caption)

notionary/page/content/markdown/nodes/base.py

@@ -0,0 +1,12 @@
+from abc import ABC, abstractmethod
+
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class MarkdownNode(ABC):
+    def __init__(self, syntax_registry: SyntaxRegistry | None = None) -> None:
+        self._syntax_registry = syntax_registry or SyntaxRegistry()
+
+    @abstractmethod
+    def to_markdown(self) -> str:
+        pass

notionary/page/content/markdown/nodes/bookmark.py

@@ -0,0 +1,25 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.markdown.nodes.mixins.caption import CaptionMarkdownNodeMixin
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class BookmarkMarkdownNode(MarkdownNode, CaptionMarkdownNodeMixin):
+    def __init__(
+        self,
+        url: str,
+        title: str | None = None,
+        caption: str | None = None,
+        syntax_registry: SyntaxRegistry | None = None,
+    ) -> None:
+        super().__init__(syntax_registry=syntax_registry)
+        self.url = url
+        self.title = title
+        self.caption = caption
+
+    @override
+    def to_markdown(self) -> str:
+        bookmark_syntax = self._syntax_registry.get_bookmark_syntax()
+        base_markdown = f"{bookmark_syntax.start_delimiter}{self.url}{bookmark_syntax.end_delimiter}"
+        return self._append_caption_to_markdown(base_markdown, self.caption)

notionary/page/content/markdown/nodes/breadcrumb.py

@@ -0,0 +1,14 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class BreadcrumbMarkdownNode(MarkdownNode):
+    def __init__(self, syntax_registry: SyntaxRegistry | None = None) -> None:
+        super().__init__(syntax_registry=syntax_registry)
+
+    @override
+    def to_markdown(self) -> str:
+        breadcrumb_syntax = self._syntax_registry.get_breadcrumb_syntax()
+        return breadcrumb_syntax.start_delimiter

notionary/page/content/markdown/nodes/bulleted_list.py

@@ -0,0 +1,41 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.markdown.nodes.container import ContainerNode
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class BulletedListMarkdownNode(ContainerNode):
+    def __init__(
+        self,
+        texts: list[str],
+        children: list[MarkdownNode | None] | None = None,
+        syntax_registry: SyntaxRegistry | None = None,
+    ) -> None:
+        super().__init__(syntax_registry=syntax_registry)
+        self.texts = texts
+        self.children = children or []
+
+    @override
+    def to_markdown(self) -> str:
+        list_items = [self._render_list_item(index, text) for index, text in enumerate(self.texts)]
+        return "\n".join(list_items)
+
+    def _render_list_item(self, index: int, text: str) -> str:
+        delimiter = self._get_list_delimiter()
+        item_line = f"{delimiter}{text}"
+
+        child = self._get_child_for_item(index)
+        if child:
+            child_content = self.render_child(child)
+            return f"{item_line}\n{child_content}"
+
+        return item_line
+
+    def _get_list_delimiter(self) -> str:
+        return self._syntax_registry.get_bulleted_list_syntax().start_delimiter
+
+    def _get_child_for_item(self, index: int) -> MarkdownNode | None:
+        if not self.children or index >= len(self.children):
+            return None
+        return self.children[index]

notionary/page/content/markdown/nodes/callout.py

@@ -0,0 +1,34 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.markdown.nodes.container import ContainerNode
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class CalloutMarkdownNode(ContainerNode):
+    def __init__(
+        self,
+        text: str,
+        emoji: str | None = None,
+        children: list[MarkdownNode] | None = None,
+        syntax_registry: SyntaxRegistry | None = None,
+    ):
+        super().__init__(syntax_registry=syntax_registry)
+        self.text = text
+        self.emoji = emoji
+        self.children = children or []
+
+    @override
+    def to_markdown(self) -> str:
+        callout_content = self._format_callout_content()
+        start_delimiter = self._syntax_registry.get_callout_syntax().start_delimiter
+        result = f"{start_delimiter}({callout_content})"
+
+        result += self.render_children()
+
+        return result
+
+    def _format_callout_content(self) -> str:
+        if self.emoji:
+            return f'{self.text} "{self.emoji}"'
+        return self.text

notionary/page/content/markdown/nodes/code.py

@@ -0,0 +1,28 @@
+from typing import override
+
+from notionary.blocks.enums import CodingLanguage
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.markdown.nodes.mixins.caption import CaptionMarkdownNodeMixin
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class CodeMarkdownNode(MarkdownNode, CaptionMarkdownNodeMixin):
+    def __init__(
+        self,
+        code: str,
+        language: CodingLanguage | None = None,
+        caption: str | None = None,
+        syntax_registry: SyntaxRegistry | None = None,
+    ) -> None:
+        super().__init__(syntax_registry=syntax_registry)
+        self.code = code
+        self.language = language
+        self.caption = caption
+
+    @override
+    def to_markdown(self) -> str:
+        code_syntax = self._syntax_registry.get_code_syntax()
+        lang = self.language or ""
+
+        base_markdown = f"{code_syntax.start_delimiter}{lang}\n{self.code}\n{code_syntax.end_delimiter}"
+        return self._append_caption_to_markdown(base_markdown, self.caption)

notionary/page/content/markdown/nodes/columns.py

@@ -0,0 +1,69 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.markdown.nodes.container import ContainerNode
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class ColumnMarkdownNode(ContainerNode):
+    def __init__(
+        self,
+        children: list[MarkdownNode] | None = None,
+        width_ratio: float | None = None,
+        syntax_registry: SyntaxRegistry | None = None,
+    ):
+        super().__init__(syntax_registry=syntax_registry)
+        self.children = children or []
+        self.width_ratio = width_ratio
+
+    @override
+    def to_markdown(self) -> str:
+        start_tag = self._format_column_start_tag()
+        result = start_tag + self.render_children()
+        return result
+
+    def _format_column_start_tag(self) -> str:
+        delimiter = self._syntax_registry.get_column_syntax().start_delimiter
+
+        if self.width_ratio is not None:
+            return f"{delimiter} {self.width_ratio}"
+        return delimiter
+
+
+class ColumnListMarkdownNode(MarkdownNode):
+    def __init__(
+        self,
+        columns: list[ColumnMarkdownNode] | None = None,
+        syntax_registry: SyntaxRegistry | None = None,
+    ):
+        super().__init__(syntax_registry=syntax_registry)
+        self.columns = columns or []
+
+    @override
+    def to_markdown(self) -> str:
+        start_delimiter = self._get_column_list_delimiter()
+
+        if not self.columns:
+            return start_delimiter
+
+        result = start_delimiter + self._render_columns()
+        return result
+
+    def _get_column_list_delimiter(self) -> str:
+        return self._syntax_registry.get_column_list_syntax().start_delimiter
+
+    def _render_columns(self) -> str:
+        rendered_columns = []
+
+        for column in self.columns:
+            column_markdown = column.to_markdown()
+            if column_markdown:
+                indented = self._indent_column(column_markdown)
+                rendered_columns.append(indented)
+
+        return "\n" + "\n".join(rendered_columns) if rendered_columns else ""
+
+    @staticmethod
+    def _indent_column(text: str, indent: str = "    ") -> str:
+        lines = text.split("\n")
+        return "\n".join(f"{indent}{line}" if line.strip() else line for line in lines)

notionary/page/content/markdown/nodes/container.py

@@ -0,0 +1,64 @@
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.syntax import SyntaxRegistry
+from notionary.page.content.syntax.grammar import MarkdownGrammar
+
+
+def flatten_children(children: list[MarkdownNode]) -> MarkdownNode | None:
+    """Convert a list of child nodes to a single node for container compatibility."""
+    if not children:
+        return None
+    if len(children) == 1:
+        return children[0]
+    return _MultiChildWrapper(children)
+
+
+class _MultiChildWrapper(MarkdownNode):
+    def __init__(self, children: list[MarkdownNode]) -> None:
+        super().__init__()
+        self.children = children
+
+    def to_markdown(self) -> str:
+        return "\n".join(child.to_markdown() for child in self.children if child)
+
+
+class ContainerNode(MarkdownNode):
+    children: list[MarkdownNode]
+
+    def __init__(self, syntax_registry: SyntaxRegistry | None = None) -> None:
+        super().__init__(syntax_registry=syntax_registry)
+        grammar = self._get_grammar(syntax_registry)
+        self._spaces_per_nesting_level = grammar.spaces_per_nesting_level
+
+    def render_children(self, indent_level: int = 1) -> str:
+        if not self.children:
+            return ""
+
+        indent = self._calculate_indent(indent_level)
+        rendered = [self._indent_child(child, indent) for child in self.children]
+        rendered = [text for text in rendered if text]
+
+        return f"\n{'\n'.join(rendered)}" if rendered else ""
+
+    def render_child(self, child: MarkdownNode, indent_level: int = 1) -> str:
+        child_markdown = child.to_markdown()
+        if not child_markdown:
+            return ""
+
+        indent = self._calculate_indent(indent_level)
+        return self._indent_text(child_markdown, indent)
+
+    def _calculate_indent(self, level: int) -> str:
+        return " " * (self._spaces_per_nesting_level * level)
+
+    def _indent_child(self, child: MarkdownNode, indent: str) -> str:
+        child_markdown = child.to_markdown()
+        return self._indent_text(child_markdown, indent) if child_markdown else ""
+
+    @staticmethod
+    def _indent_text(text: str, indent: str) -> str:
+        lines = text.split("\n")
+        return "\n".join(f"{indent}{line}" if line.strip() else line for line in lines)
+
+    @staticmethod
+    def _get_grammar(syntax_registry: SyntaxRegistry | None) -> MarkdownGrammar:
+        return syntax_registry._markdown_grammar if syntax_registry else MarkdownGrammar()