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

notionary/page/content/renderer/context.py

@@ -0,0 +1,51 @@
+from collections.abc import Awaitable, Callable
+
+from notionary.blocks.schemas import Block
+from notionary.page.content.syntax.grammar import MarkdownGrammar
+
+ConvertChildrenCallback = Callable[[list[Block], int], Awaitable[str]]
+
+
+class MarkdownRenderingContext:
+    def __init__(
+        self,
+        block: Block,
+        indent_level: int,
+        convert_children_callback: ConvertChildrenCallback | None = None,
+        markdown_grammar: MarkdownGrammar | None = None,
+    ) -> None:
+        self.block = block
+        self.indent_level = indent_level
+        self.convert_children_callback = convert_children_callback
+        markdown_grammar = markdown_grammar or MarkdownGrammar()
+        self._spaces_per_nesting_level = markdown_grammar.spaces_per_nesting_level
+
+        self.markdown_result: str | None = None
+
+    async def render_children(self) -> str:
+        return await self._convert_children_to_markdown(self.indent_level)
+
+    async def render_children_with_additional_indent(self, additional_indent: int) -> str:
+        return await self._convert_children_to_markdown(self.indent_level + additional_indent)
+
+    async def _convert_children_to_markdown(self, indent_level: int) -> str:
+        if not self._has_children() or not self.convert_children_callback:
+            return ""
+
+        return await self.convert_children_callback(self._get_children_blocks(), indent_level)
+
+    def _get_children_blocks(self) -> list[Block]:
+        if self._has_children():
+            return self.block.children
+        return []
+
+    def _has_children(self) -> bool:
+        return self.block.has_children and self.block.children and len(self.block.children) > 0
+
+    def indent_text(self, text: str) -> str:
+        if not text:
+            return text
+
+        spaces = " " * self._spaces_per_nesting_level * self.indent_level
+        lines = text.split("\n")
+        return "\n".join(f"{spaces}{line}" if line.strip() else line for line in lines)

notionary/page/content/renderer/factory.py

@@ -0,0 +1,231 @@
+from notionary.blocks.rich_text.rich_text_markdown_converter import (
+    RichTextToMarkdownConverter,
+)
+from notionary.page.content.renderer.renderers import (
+    AudioRenderer,
+    BlockRenderer,
+    BookmarkRenderer,
+    BreadcrumbRenderer,
+    BulletedListRenderer,
+    CalloutRenderer,
+    CodeRenderer,
+    ColumnListRenderer,
+    ColumnRenderer,
+    DividerRenderer,
+    EmbedRenderer,
+    EquationRenderer,
+    FallbackRenderer,
+    FileRenderer,
+    HeadingRenderer,
+    ImageRenderer,
+    NumberedListRenderer,
+    ParagraphRenderer,
+    PdfRenderer,
+    QuoteRenderer,
+    TableOfContentsRenderer,
+    TableRenderer,
+    TableRowHandler,
+    TodoRenderer,
+    ToggleRenderer,
+    VideoRenderer,
+)
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class RendererChainFactory:
+    def __init__(
+        self,
+        rich_text_markdown_converter: RichTextToMarkdownConverter | None = None,
+        syntax_registry: SyntaxRegistry | None = None,
+    ) -> None:
+        self._rich_text_markdown_converter = rich_text_markdown_converter or RichTextToMarkdownConverter()
+        self._syntax_registry = syntax_registry or SyntaxRegistry()
+
+    def create(self) -> BlockRenderer:
+        # Strukturelle Blocks
+        toggle_handler = self._create_toggle_renderer()
+        heading_handler = self._create_heading_renderer()
+
+        # Content Blocks
+        callout_handler = self._create_callout_renderer()
+        code_handler = self._create_code_renderer()
+        quote_handler = self._create_quote_renderer()
+        todo_handler = self._create_todo_renderer()
+        bulleted_list_handler = self._create_bulleted_list_renderer()
+
+        # Layout Blocks
+        divider_handler = self._create_divider_renderer()
+        column_list_handler = self._create_column_list_renderer()
+        column_handler = self._create_column_renderer()
+        numbered_list_handler = self._create_numbered_list_renderer()
+
+        # Media Blocks
+        bookmark_handler = self._create_bookmark_renderer()
+        image_handler = self._create_image_renderer()
+        video_handler = self._create_video_renderer()
+        audio_handler = self._create_audio_renderer()
+        file_handler = self._create_file_renderer()
+        pdf_handler = self._create_pdf_renderer()
+        embed_handler = self._create_embed_renderer()
+
+        # Special Blocks
+        equation_handler = self._create_equation_renderer()
+        table_of_contents_handler = self._create_table_of_contents_renderer()
+        breadcrumb_handler = self._create_breadcrumb_renderer()
+        table_handler = self._create_table_renderer()
+        table_row_handler = self._create_table_row_handler()
+
+        # Standard & Fallback
+        paragraph_handler = self._create_paragraph_renderer()
+        fallback_handler = self._create_fallback_renderer()
+
+        # Chain verketten - most specific first, fallback last
+        (
+            toggle_handler.set_next(heading_handler)
+            .set_next(callout_handler)
+            .set_next(code_handler)
+            .set_next(quote_handler)
+            .set_next(todo_handler)
+            .set_next(bulleted_list_handler)
+            .set_next(divider_handler)
+            .set_next(column_list_handler)
+            .set_next(column_handler)
+            .set_next(numbered_list_handler)
+            .set_next(bookmark_handler)
+            .set_next(image_handler)
+            .set_next(video_handler)
+            .set_next(audio_handler)
+            .set_next(file_handler)
+            .set_next(pdf_handler)
+            .set_next(embed_handler)
+            .set_next(equation_handler)
+            .set_next(table_of_contents_handler)
+            .set_next(breadcrumb_handler)
+            .set_next(table_handler)
+            .set_next(table_row_handler)
+            .set_next(paragraph_handler)
+            .set_next(fallback_handler)
+        )
+
+        return toggle_handler
+
+    # Renderer Creation Methods
+    def _create_toggle_renderer(self) -> ToggleRenderer:
+        return ToggleRenderer(
+            syntax_registry=self._syntax_registry,
+            rich_text_markdown_converter=self._rich_text_markdown_converter,
+        )
+
+    def _create_heading_renderer(self) -> HeadingRenderer:
+        return HeadingRenderer(
+            syntax_registry=self._syntax_registry,
+            rich_text_markdown_converter=self._rich_text_markdown_converter,
+        )
+
+    def _create_callout_renderer(self) -> CalloutRenderer:
+        return CalloutRenderer(
+            syntax_registry=self._syntax_registry,
+            rich_text_markdown_converter=self._rich_text_markdown_converter,
+        )
+
+    def _create_code_renderer(self) -> CodeRenderer:
+        return CodeRenderer(
+            syntax_registry=self._syntax_registry,
+            rich_text_markdown_converter=self._rich_text_markdown_converter,
+        )
+
+    def _create_quote_renderer(self) -> QuoteRenderer:
+        return QuoteRenderer(
+            syntax_registry=self._syntax_registry,
+            rich_text_markdown_converter=self._rich_text_markdown_converter,
+        )
+
+    def _create_todo_renderer(self) -> TodoRenderer:
+        return TodoRenderer(
+            syntax_registry=self._syntax_registry,
+            rich_text_markdown_converter=self._rich_text_markdown_converter,
+        )
+
+    def _create_bulleted_list_renderer(self) -> BulletedListRenderer:
+        return BulletedListRenderer(
+            syntax_registry=self._syntax_registry,
+            rich_text_markdown_converter=self._rich_text_markdown_converter,
+        )
+
+    def _create_divider_renderer(self) -> DividerRenderer:
+        return DividerRenderer(syntax_registry=self._syntax_registry)
+
+    def _create_column_list_renderer(self) -> ColumnListRenderer:
+        return ColumnListRenderer(syntax_registry=self._syntax_registry)
+
+    def _create_column_renderer(self) -> ColumnRenderer:
+        return ColumnRenderer(syntax_registry=self._syntax_registry)
+
+    def _create_numbered_list_renderer(self) -> NumberedListRenderer:
+        return NumberedListRenderer(
+            syntax_registry=self._syntax_registry,
+            rich_text_markdown_converter=self._rich_text_markdown_converter,
+        )
+
+    def _create_bookmark_renderer(self) -> BookmarkRenderer:
+        return BookmarkRenderer(
+            syntax_registry=self._syntax_registry,
+            rich_text_markdown_converter=self._rich_text_markdown_converter,
+        )
+
+    def _create_image_renderer(self) -> ImageRenderer:
+        return ImageRenderer(
+            syntax_registry=self._syntax_registry,
+            rich_text_markdown_converter=self._rich_text_markdown_converter,
+        )
+
+    def _create_video_renderer(self) -> VideoRenderer:
+        return VideoRenderer(
+            syntax_registry=self._syntax_registry,
+            rich_text_markdown_converter=self._rich_text_markdown_converter,
+        )
+
+    def _create_audio_renderer(self) -> AudioRenderer:
+        return AudioRenderer(
+            syntax_registry=self._syntax_registry,
+            rich_text_markdown_converter=self._rich_text_markdown_converter,
+        )
+
+    def _create_file_renderer(self) -> FileRenderer:
+        return FileRenderer(
+            syntax_registry=self._syntax_registry,
+            rich_text_markdown_converter=self._rich_text_markdown_converter,
+        )
+
+    def _create_pdf_renderer(self) -> PdfRenderer:
+        return PdfRenderer(
+            syntax_registry=self._syntax_registry,
+            rich_text_markdown_converter=self._rich_text_markdown_converter,
+        )
+
+    def _create_embed_renderer(self) -> EmbedRenderer:
+        return EmbedRenderer(
+            syntax_registry=self._syntax_registry,
+            rich_text_markdown_converter=self._rich_text_markdown_converter,
+        )
+
+    def _create_equation_renderer(self) -> EquationRenderer:
+        return EquationRenderer(syntax_registry=self._syntax_registry)
+
+    def _create_table_of_contents_renderer(self) -> TableOfContentsRenderer:
+        return TableOfContentsRenderer(syntax_registry=self._syntax_registry)
+
+    def _create_breadcrumb_renderer(self) -> BreadcrumbRenderer:
+        return BreadcrumbRenderer(syntax_registry=self._syntax_registry)
+
+    def _create_table_renderer(self) -> TableRenderer:
+        return TableRenderer(rich_text_markdown_converter=self._rich_text_markdown_converter)
+
+    def _create_table_row_handler(self) -> TableRowHandler:
+        return TableRowHandler()
+
+    def _create_paragraph_renderer(self) -> ParagraphRenderer:
+        return ParagraphRenderer(rich_text_markdown_converter=self._rich_text_markdown_converter)
+
+    def _create_fallback_renderer(self) -> FallbackRenderer:
+        return FallbackRenderer()

notionary/page/content/renderer/post_processing/handlers/__init__.py

@@ -0,0 +1,5 @@
+from .numbered_list import NumberedListPlaceholderReplacerPostProcessor
+
+__all__ = [
+    "NumberedListPlaceholderReplacerPostProcessor",
+]

notionary/page/content/renderer/post_processing/handlers/numbered_list.py

@@ -0,0 +1,156 @@
+import re
+from enum import IntEnum
+from typing import override
+
+from notionary.page.content.renderer.post_processing.port import PostProcessor
+from notionary.page.content.syntax.grammar import MarkdownGrammar
+
+
+class _NumberingStyle(IntEnum):
+    NUMERIC = 0
+    ALPHABETIC = 1
+    ROMAN = 2
+
+
+class _ListNumberingState:
+    def __init__(self):
+        self._counters_by_level: dict[int, int] = {}
+        self._current_level = -1
+
+    def advance_to_level(self, new_level: int) -> None:
+        self._forget_deeper_levels_than(new_level)
+        self._increment_counter_at_level(new_level)
+        self._current_level = new_level
+
+    def get_number_for_current_level(self) -> str:
+        counter = self._counters_by_level[self._current_level]
+        style = self._determine_numbering_style(self._current_level)
+        return self._format_number(counter, style)
+
+    def reset(self) -> None:
+        self._counters_by_level.clear()
+        self._current_level = -1
+
+    def _forget_deeper_levels_than(self, level: int) -> None:
+        self._counters_by_level = {
+            existing_level: count
+            for existing_level, count in self._counters_by_level.items()
+            if existing_level <= level
+        }
+
+    def _increment_counter_at_level(self, level: int) -> None:
+        self._counters_by_level[level] = self._counters_by_level.get(level, 0) + 1
+
+    def _determine_numbering_style(self, nesting_level: int) -> _NumberingStyle:
+        return _NumberingStyle(nesting_level % 3)
+
+    def _format_number(self, counter: int, style: _NumberingStyle) -> str:
+        if style == _NumberingStyle.NUMERIC:
+            return str(counter)
+        elif style == _NumberingStyle.ALPHABETIC:
+            return self._to_alphabetic(counter)
+        else:
+            return self._to_roman(counter)
+
+    def _to_alphabetic(self, number: int) -> str:
+        result = ""
+        number -= 1
+        while number >= 0:
+            result = chr(ord("a") + (number % 26)) + result
+            number = number // 26 - 1
+        return result
+
+    def _to_roman(self, number: int) -> str:
+        conversions = [
+            (1000, "m"),
+            (900, "cm"),
+            (500, "d"),
+            (400, "cd"),
+            (100, "c"),
+            (90, "xc"),
+            (50, "l"),
+            (40, "xl"),
+            (10, "x"),
+            (9, "ix"),
+            (5, "v"),
+            (4, "iv"),
+            (1, "i"),
+        ]
+
+        result = ""
+        for arabic, roman in conversions:
+            while number >= arabic:
+                result += roman
+                number -= arabic
+        return result
+
+
+class NumberedListPlaceholderReplacerPostProcessor(PostProcessor):
+    def __init__(self, markdown_grammar: MarkdownGrammar | None = None) -> None:
+        self._markdown_grammar = markdown_grammar or MarkdownGrammar()
+        self._spaces_per_nesting_level = self._markdown_grammar.spaces_per_nesting_level
+        self._numbered_list_placeholder = self._markdown_grammar.numbered_list_placeholder
+
+    @override
+    def process(self, markdown_text: str) -> str:
+        lines = markdown_text.splitlines()
+        return self._convert_placeholder_lists_to_numbered_lists(lines)
+
+    def _convert_placeholder_lists_to_numbered_lists(self, lines: list[str]) -> str:
+        result = []
+        list_state = _ListNumberingState()
+
+        for line_index, line in enumerate(lines):
+            if self._is_placeholder_list_item(line):
+                numbered_line = self._convert_to_numbered_item(line, list_state)
+                result.append(numbered_line)
+            elif self._is_blank_between_list_items(lines, line_index, result):
+                continue
+            else:
+                list_state.reset()
+                result.append(line)
+
+        return "\n".join(result)
+
+    def _convert_to_numbered_item(self, line: str, state: _ListNumberingState) -> str:
+        indentation = self._extract_indentation(line)
+        content = self._extract_content(line)
+        nesting_level = self._calculate_nesting_level(indentation)
+
+        state.advance_to_level(nesting_level)
+        number = state.get_number_for_current_level()
+
+        return f"{indentation}{number}. {content}"
+
+    def _calculate_nesting_level(self, indentation: str) -> int:
+        return len(indentation) // self._spaces_per_nesting_level
+
+    def _extract_indentation(self, line: str) -> str:
+        match = re.match(rf"^(\s*){re.escape(self._numbered_list_placeholder)}\.", line)
+        return match.group(1) if match else ""
+
+    def _extract_content(self, line: str) -> str:
+        match = re.match(rf"^\s*{re.escape(self._numbered_list_placeholder)}\.\s*(.*)", line)
+        return match.group(1) if match else ""
+
+    def _is_placeholder_list_item(self, line: str) -> bool:
+        return bool(re.match(rf"^\s*{re.escape(self._numbered_list_placeholder)}\.", line))
+
+    def _is_blank_between_list_items(self, lines: list[str], current_index: int, processed_lines: list[str]) -> bool:
+        if not self._is_blank(lines[current_index]):
+            return False
+
+        previous_line_was_list_item = processed_lines and self._looks_like_numbered_list_item(processed_lines[-1])
+        if not previous_line_was_list_item:
+            return False
+
+        next_line_is_list_item = current_index + 1 < len(lines) and self._is_placeholder_list_item(
+            lines[current_index + 1]
+        )
+        return next_line_is_list_item
+
+    def _is_blank(self, line: str) -> bool:
+        return not line.strip()
+
+    def _looks_like_numbered_list_item(self, line: str) -> bool:
+        return bool(re.match(r"^\s*(\d+|[a-z]+|[ivxlcdm]+)\.\s+", line))

notionary/page/content/renderer/post_processing/port.py

@@ -0,0 +1,7 @@
+from abc import ABC, abstractmethod
+
+
+class PostProcessor(ABC):
+    @abstractmethod
+    def process(self, markdown_text: str) -> str:
+        pass

notionary/page/content/renderer/post_processing/service.py

@@ -0,0 +1,15 @@
+from notionary.page.content.parser.post_processing.port import PostProcessor
+
+
+class MarkdownRenderingPostProcessor:
+    def __init__(self) -> None:
+        self._processors: list[PostProcessor] = []
+
+    def register(self, processor: PostProcessor) -> None:
+        self._processors.append(processor)
+
+    def process(self, markdown_text: str) -> str:
+        result = markdown_text
+        for processor in self._processors:
+            result = processor.process(result)
+        return result

notionary/page/content/renderer/renderers/__init__.py

@@ -0,0 +1,55 @@
+from .audio import AudioRenderer
+from .base import BlockRenderer
+from .bookmark import BookmarkRenderer
+from .breadcrumb import BreadcrumbRenderer
+from .bulleted_list import BulletedListRenderer
+from .callout import CalloutRenderer
+from .code import CodeRenderer
+from .column import ColumnRenderer
+from .column_list import ColumnListRenderer
+from .divider import DividerRenderer
+from .embed import EmbedRenderer
+from .equation import EquationRenderer
+from .fallback import FallbackRenderer
+from .file import FileRenderer
+from .heading import HeadingRenderer
+from .image import ImageRenderer
+from .numbered_list import NumberedListRenderer
+from .paragraph import ParagraphRenderer
+from .pdf import PdfRenderer
+from .quote import QuoteRenderer
+from .table import TableRenderer
+from .table_of_contents import TableOfContentsRenderer
+from .table_row import TableRowHandler
+from .todo import TodoRenderer
+from .toggle import ToggleRenderer
+from .video import VideoRenderer
+
+__all__ = [
+    "AudioRenderer",
+    "BlockRenderer",
+    "BookmarkRenderer",
+    "BreadcrumbRenderer",
+    "BulletedListRenderer",
+    "CalloutRenderer",
+    "CodeRenderer",
+    "ColumnListRenderer",
+    "ColumnRenderer",
+    "DividerRenderer",
+    "EmbedRenderer",
+    "EquationRenderer",
+    "FallbackRenderer",
+    "FileRenderer",
+    "HeadingRenderer",
+    "ImageRenderer",
+    "NumberedListRenderer",
+    "ParagraphRenderer",
+    "PdfRenderer",
+    "QuoteRenderer",
+    "TableOfContentsRenderer",
+    "TableRenderer",
+    "TableRowHandler",
+    "TodoRenderer",
+    "ToggleRenderer",
+    "VideoRenderer",
+]

notionary/page/content/renderer/renderers/audio.py

@@ -0,0 +1,31 @@
+from typing import override
+
+from notionary.blocks.schemas import Block, BlockType
+from notionary.page.content.renderer.renderers.captioned_block import CaptionedBlockRenderer
+
+
+class AudioRenderer(CaptionedBlockRenderer):
+    @override
+    def _can_handle(self, block: Block) -> bool:
+        return block.type == BlockType.AUDIO
+
+    @override
+    async def _render_main_content(self, block: Block) -> str:
+        url = self._extract_audio_url(block)
+
+        if not url:
+            return ""
+
+        syntax = self._syntax_registry.get_audio_syntax()
+        return f"{syntax.start_delimiter}{url}{syntax.end_delimiter}"
+
+    def _extract_audio_url(self, block: Block) -> str:
+        if not block.audio:
+            return ""
+
+        if block.audio.external:
+            return block.audio.external.url or ""
+        elif block.audio.file:
+            return block.audio.file.url or ""
+
+        return ""

notionary/page/content/renderer/renderers/base.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+
+from notionary.blocks.schemas import Block
+from notionary.page.content.renderer.context import MarkdownRenderingContext
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class BlockRenderer(ABC):
+    def __init__(self, syntax_registry: SyntaxRegistry | None = None) -> None:
+        self._syntax_registry = syntax_registry or SyntaxRegistry()
+        self._next_handler: BlockRenderer | None = None
+
+    def set_next(self, handler: BlockRenderer) -> BlockRenderer:
+        self._next_handler = handler
+        return handler
+
+    async def handle(self, context: MarkdownRenderingContext) -> None:
+        if self._can_handle(context.block):
+            await self._process(context)
+        elif self._next_handler:
+            await self._next_handler.handle(context)
+
+    @abstractmethod
+    def _can_handle(self, block: Block) -> bool:
+        pass
+
+    @abstractmethod
+    async def _process(self, context: MarkdownRenderingContext) -> None:
+        pass

notionary/page/content/renderer/renderers/bookmark.py

@@ -0,0 +1,25 @@
+from typing import override
+
+from notionary.blocks.schemas import Block, BlockType
+from notionary.page.content.renderer.renderers.captioned_block import CaptionedBlockRenderer
+
+
+class BookmarkRenderer(CaptionedBlockRenderer):
+    @override
+    def _can_handle(self, block: Block) -> bool:
+        return block.type == BlockType.BOOKMARK
+
+    @override
+    async def _render_main_content(self, block: Block) -> str:
+        url = self._extract_bookmark_url(block)
+
+        if not url:
+            return ""
+
+        syntax = self._syntax_registry.get_bookmark_syntax()
+        return f"{syntax.start_delimiter}{url}{syntax.end_delimiter}"
+
+    def _extract_bookmark_url(self, block: Block) -> str:
+        if not block.bookmark:
+            return ""
+        return block.bookmark.url or ""

notionary/page/content/renderer/renderers/breadcrumb.py

@@ -0,0 +1,21 @@
+from typing import override
+
+from notionary.blocks.schemas import Block, BlockType
+from notionary.page.content.renderer.context import MarkdownRenderingContext
+from notionary.page.content.renderer.renderers.base import BlockRenderer
+
+
+class BreadcrumbRenderer(BlockRenderer):
+    @override
+    def _can_handle(self, block: Block) -> bool:
+        return block.type == BlockType.BREADCRUMB
+
+    @override
+    async def _process(self, context: MarkdownRenderingContext) -> None:
+        syntax = self._syntax_registry.get_breadcrumb_syntax()
+        breadcrumb_markdown = syntax.start_delimiter
+
+        if context.indent_level > 0:
+            breadcrumb_markdown = context.indent_text(breadcrumb_markdown)
+
+        context.markdown_result = breadcrumb_markdown

notionary/page/content/renderer/renderers/bulleted_list.py

@@ -0,0 +1,48 @@
+from typing import override
+
+from notionary.blocks.rich_text.rich_text_markdown_converter import RichTextToMarkdownConverter
+from notionary.blocks.schemas import Block, BlockType
+from notionary.page.content.renderer.context import MarkdownRenderingContext
+from notionary.page.content.renderer.renderers.base import BlockRenderer
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class BulletedListRenderer(BlockRenderer):
+    def __init__(
+        self,
+        syntax_registry: SyntaxRegistry | None = None,
+        rich_text_markdown_converter: RichTextToMarkdownConverter | None = None,
+    ) -> None:
+        super().__init__(syntax_registry=syntax_registry)
+        self._rich_text_markdown_converter = rich_text_markdown_converter or RichTextToMarkdownConverter()
+
+    @override
+    def _can_handle(self, block: Block) -> bool:
+        return block.type == BlockType.BULLETED_LIST_ITEM
+
+    @override
+    async def _process(self, context: MarkdownRenderingContext) -> None:
+        markdown = await self._convert_bulleted_list_to_markdown(context.block)
+
+        if not markdown:
+            context.markdown_result = ""
+            return
+
+        syntax = self._syntax_registry.get_bulleted_list_syntax()
+        list_item_markdown = f"{syntax.start_delimiter}{markdown}"
+
+        if context.indent_level > 0:
+            list_item_markdown = context.indent_text(list_item_markdown)
+
+        children_markdown = await context.render_children_with_additional_indent(1)
+
+        if children_markdown:
+            context.markdown_result = f"{list_item_markdown}\n{children_markdown}"
+        else:
+            context.markdown_result = list_item_markdown
+
+    async def _convert_bulleted_list_to_markdown(self, block: Block) -> str | None:
+        if not block.bulleted_list_item or not block.bulleted_list_item.rich_text:
+            return None
+
+        return await self._rich_text_markdown_converter.to_markdown(block.bulleted_list_item.rich_text)