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

notionary/page/content/factory.py

@@ -0,0 +1,68 @@
+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, 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 NumberedListPlaceholderReplaceerPostProcessor
+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())
+        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(NumberedListPlaceholderReplaceerPostProcessor())
+        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,304 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Self
+
+from notionary.blocks.enums import CodeLanguage
+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,
+    ToggleableHeadingMarkdownNode,
+    ToggleMarkdownNode,
+    VideoMarkdownNode,
+)
+
+
+class MarkdownBuilder:
+    def __init__(self) -> None:
+        self.children: list[MarkdownNode] = []
+
+    def h1(self, text: str) -> Self:
+        self.children.append(HeadingMarkdownNode(text=text, level=1))
+        return self
+
+    def h2(self, text: str) -> Self:
+        self.children.append(HeadingMarkdownNode(text=text, level=2))
+        return self
+
+    def h3(self, text: str) -> Self:
+        self.children.append(HeadingMarkdownNode(text=text, level=3))
+        return self
+
+    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) -> Self:
+        self.children.append(QuoteMarkdownNode(text=text))
+        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 bulleted_list(self, items: list[str]) -> Self:
+        self.children.append(BulletedListMarkdownNode(texts=items))
+        return self
+
+    def todo(self, text: str, checked: bool = False) -> Self:
+        self.children.append(TodoMarkdownNode(text=text, checked=checked))
+        return self
+
+    def checked_todo(self, text: str) -> Self:
+        return self.todo(text, checked=True)
+
+    def unchecked_todo(self, text: str) -> Self:
+        return self.todo(text, checked=False)
+
+    def todo_list(self, items: list[str], completed: list[bool] | None = None) -> Self:
+        if completed is None:
+            completed = [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:
+        """
+        Add a callout block with children built using the builder API.
+
+        Args:
+            text: The callout text content
+            emoji: Optional emoji for the callout icon
+            builder_func: Optional function that receives a MarkdownBuilder and returns it configured
+
+        Example:
+            builder.callout_with_children("Important note", "⚠️", lambda c:
+                c.paragraph("Additional details here")
+                .bulleted_list(["Point 1", "Point 2"])
+            )
+        """
+        if builder_func is None:
+            self.children.append(CalloutMarkdownNode(text=text, emoji=emoji))
+            return self
+
+        callout_builder = MarkdownBuilder()
+        builder_func(callout_builder)
+        self.children.append(CalloutMarkdownNode(text=text, emoji=emoji, children=callout_builder.children))
+        return self
+
+    def toggle(self, title: str, builder_func: Callable[[MarkdownBuilder], MarkdownBuilder]) -> Self:
+        """
+        Add a toggle block with content built using the builder API.
+
+        Args:
+            title: The toggle title/header text
+            builder_func: Function that receives a MarkdownBuilder and returns it configured
+
+        Example:
+            builder.toggle("Advanced Settings", lambda t:
+                t.h3("Configuration")
+                .paragraph("Settings description")
+                .table(["Setting", "Value"], [["Debug", "True"]])
+                .callout("Important note", "⚠️")
+            )
+        """
+        toggle_builder = MarkdownBuilder()
+        builder_func(toggle_builder)
+        self.children.append(ToggleMarkdownNode(title=title, children=toggle_builder.children))
+        return self
+
+    def toggleable_heading(
+        self,
+        text: str,
+        level: int,
+        builder_func: Callable[[MarkdownBuilder], MarkdownBuilder],
+    ) -> Self:
+        """
+        Add a toggleable heading with content built using the builder API.
+
+        Args:
+            text: The heading text content
+            level: Heading level (1-3)
+            builder_func: Function that receives a MarkdownBuilder and returns it configured
+
+        Example:
+            builder.toggleable_heading("Advanced Section", 2, lambda t:
+                t.paragraph("Introduction to this section")
+                .numbered_list(["Step 1", "Step 2", "Step 3"])
+                .code("example_code()", "python")
+                .table(["Feature", "Status"], [["API", "Ready"]])
+            )
+        """
+        toggle_builder = MarkdownBuilder()
+        builder_func(toggle_builder)
+        self.children.append(ToggleableHeadingMarkdownNode(text=text, level=level, children=toggle_builder.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: CodeLanguage | 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=CodeLanguage.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 add_custom(self, node: MarkdownNode) -> Self:
+        self.children.append(node)
+        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:
+        """
+        Add multiple columns in a layout.
+
+        Args:
+            *builder_funcs: Multiple functions, each building one column
+            width_ratios: Optional list of width ratios (0.0 to 1.0).
+                        If None, columns have equal width.
+                        Length must match number of builder_funcs.
+
+        Examples:
+            # Equal width (original API unchanged):
+            builder.columns(
+                lambda col: col.h2("Left").paragraph("Left content"),
+                lambda col: col.h2("Right").paragraph("Right content")
+            )
+
+            # Custom ratios:
+            builder.columns(
+                lambda col: col.h2("Main").paragraph("70% width"),
+                lambda col: col.h2("Sidebar").paragraph("30% width"),
+                width_ratios=[0.7, 0.3]
+            )
+
+            # Three columns with custom ratios:
+            builder.columns(
+                lambda col: col.h3("Nav").paragraph("Navigation"),
+                lambda col: col.h2("Main").paragraph("Main content"),
+                lambda col: col.h3("Ads").paragraph("Advertisement"),
+                width_ratios=[0.2, 0.6, 0.2]
+            )
+        """
+        self._validate_columns_args(builder_funcs, width_ratios)
+
+        # Create all columns
+        columns = []
+        for i, builder_func in enumerate(builder_funcs):
+            width_ratio = width_ratios[i] if width_ratios else None
+
+            col_builder = MarkdownBuilder()
+            builder_func(col_builder)
+
+            column_node = ColumnMarkdownNode(children=col_builder.children, width_ratio=width_ratio)
+            columns.append(column_node)
+
+        self.children.append(ColumnListMarkdownNode(columns=columns))
+        return self
+
+    def _validate_columns_args(
+        self,
+        builder_funcs: tuple[Callable[[MarkdownBuilder], MarkdownBuilder], ...],
+        width_ratios: list[float] | None,
+    ) -> None:
+        if len(builder_funcs) < 2:
+            raise ValueError("Column layout requires at least 2 columns")
+
+        if width_ratios is not None:
+            if len(width_ratios) != len(builder_funcs):
+                raise ValueError(
+                    f"width_ratios length ({len(width_ratios)}) must match number of columns ({len(builder_funcs)})"
+                )
+
+            ratio_sum = sum(width_ratios)
+            if not (0.9 <= ratio_sum <= 1.1):  # Allow small floating point errors
+                raise ValueError(f"width_ratios should sum to 1.0, got {ratio_sum}")
+
+    def build(self) -> str:
+        return "\n\n".join(child.to_markdown() for child in self.children if child is not None)

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

@@ -0,0 +1,54 @@
+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 .toggleable_heading import ToggleableHeadingMarkdownNode
+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",
+    "ToggleableHeadingMarkdownNode",
+    "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.service 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.service 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.service 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.service 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,18 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.syntax.service import SyntaxRegistry
+
+
+class BulletedListMarkdownNode(MarkdownNode):
+    def __init__(self, texts: list[str], syntax_registry: SyntaxRegistry | None = None) -> None:
+        super().__init__(syntax_registry=syntax_registry)
+        self.texts = texts
+
+    @override
+    def to_markdown(self) -> str:
+        bulleted_list_syntax = self._syntax_registry.get_bulleted_list_syntax()
+        result = []
+        for text in self.texts:
+            result.append(f"{bulleted_list_syntax.start_delimiter} {text}")
+        return "\n".join(result)

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

@@ -0,0 +1,32 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.syntax.service import SyntaxRegistry
+
+
+class CalloutMarkdownNode(MarkdownNode):
+    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_syntax = self._syntax_registry.get_callout_syntax()
+        start_tag = f"{callout_syntax.start_delimiter} {self.emoji}" if self.emoji else callout_syntax.start_delimiter
+
+        if not self.children:
+            return f"{start_tag}\n{self.text}\n{callout_syntax.end_delimiter}"
+
+        # Convert children to markdown
+        content_parts = [self.text] + [child.to_markdown() for child in self.children]
+        content_text = "\n\n".join(content_parts)
+
+        return f"{start_tag}\n{content_text}\n{callout_syntax.end_delimiter}"

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

@@ -0,0 +1,30 @@
+from typing import override
+
+from notionary.blocks.enums import CodeLanguage
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.markdown.nodes.mixins.caption import CaptionMarkdownNodeMixin
+from notionary.page.content.syntax.service import SyntaxRegistry
+
+
+class CodeMarkdownNode(MarkdownNode, CaptionMarkdownNodeMixin):
+    """Code node for creating Notion-style code blocks."""
+
+    def __init__(
+        self,
+        code: str,
+        language: CodeLanguage | 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,51 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.syntax.service import SyntaxRegistry
+
+
+class ColumnMarkdownNode(MarkdownNode):
+    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:
+        column_syntax = self._syntax_registry.get_column_syntax()
+        start_tag = (
+            f"{column_syntax.start_delimiter} {self.width_ratio}"
+            if self.width_ratio is not None
+            else column_syntax.start_delimiter
+        )
+
+        if not self.children:
+            return f"{start_tag}\n{column_syntax.end_delimiter}"
+
+        # Convert children to markdown
+        content_parts = [child.to_markdown() for child in self.children]
+        content_text = "\n\n".join(content_parts)
+
+        return f"{start_tag}\n{content_text}\n{column_syntax.end_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:
+        column_list_syntax = self._syntax_registry.get_column_list_syntax()
+        if not self.columns:
+            return f"{column_list_syntax.start_delimiter}\n{column_list_syntax.end_delimiter}"
+
+        column_parts = [column.to_markdown() for column in self.columns]
+        columns_content = "\n\n".join(column_parts)
+
+        return f"{column_list_syntax.start_delimiter}\n{columns_content}\n{column_list_syntax.end_delimiter}"

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

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