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

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

@@ -0,0 +1,62 @@
+import re
+from typing import override
+
+from notionary.page.content.renderer.post_processing.port import PostProcessor
+
+
+class NumberedListPlaceholderReplaceerPostProcessor(PostProcessor):
+    """
+    Handles post processing of numbered lists in markdown text.
+    Would otherwise require complex state management during initial rendering.
+    """
+
+    NUMBERED_LIST_PLACEHOLDER = "__NUM__"
+    LIST_ITEM_PATTERN = rf"^\s*{re.escape(NUMBERED_LIST_PLACEHOLDER)}\.\s*(.*)"
+    NUMBERED_ITEM_PATTERN = r"^\d+\.\s+"
+
+    @override
+    def process(self, markdown_text: str) -> str:
+        lines = markdown_text.splitlines()
+        processed_lines = []
+        list_counter = 1
+
+        for line_index, line in enumerate(lines):
+            if self._is_custom_list_item(line):
+                content = self._extract_list_content(line)
+                processed_lines.append(f"{list_counter}. {content}")
+                list_counter += 1
+            elif self._should_skip_blank_line(lines, line_index, processed_lines):
+                continue
+            else:
+                list_counter = 1
+                processed_lines.append(line)
+
+        return "\n".join(processed_lines)
+
+    def _is_custom_list_item(self, line: str) -> bool:
+        return bool(re.match(self.LIST_ITEM_PATTERN, line.strip()))
+
+    def _extract_list_content(self, line: str) -> str:
+        match = re.match(self.LIST_ITEM_PATTERN, line.strip())
+        return match.group(1) if match else ""
+
+    def _is_numbered_list_item(self, line: str) -> bool:
+        return bool(re.match(self.NUMBERED_ITEM_PATTERN, line))
+
+    def _is_blank_line(self, line: str) -> bool:
+        return not line.strip()
+
+    def _should_skip_blank_line(self, lines: list[str], current_index: int, processed_lines: list[str]) -> bool:
+        if not self._is_blank_line(lines[current_index]):
+            return False
+
+        previous_is_list_item = processed_lines and self._is_numbered_list_item(processed_lines[-1])
+        if not previous_is_list_item:
+            return False
+
+        next_index = current_index + 1
+        if next_index >= len(lines):
+            return False
+
+        next_is_list_item = self._is_custom_list_item(lines[next_index])
+        return next_is_list_item

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,57 @@
+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 .toggleable_heading import ToggleableHeadingRenderer
+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",
+    "ToggleableHeadingRenderer",
+    "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.service 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.service 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)

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

@@ -0,0 +1,65 @@
+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.service import SyntaxRegistry
+
+
+class CalloutRenderer(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.CALLOUT
+
+    @override
+    async def _process(self, context: MarkdownRenderingContext) -> None:
+        icon = await self._extract_callout_icon(context.block)
+        content = await self._extract_callout_content(context.block)
+
+        if not content:
+            context.markdown_result = ""
+            return
+
+        syntax = self._syntax_registry.get_callout_syntax()
+
+        # Build callout structure
+        # Extract just the base part before the regex pattern
+        callout_type = syntax.start_delimiter.split()[1]  # Gets "callout" from "::: callout"
+        callout_header = f"{self._syntax_registry.MULTI_LINE_BLOCK_DELIMITER} {callout_type}"
+        if icon:
+            callout_header = f"{self._syntax_registry.MULTI_LINE_BLOCK_DELIMITER} {callout_type} {icon}"
+
+        if context.indent_level > 0:
+            callout_header = context.indent_text(callout_header)
+
+        # Process children if they exist
+        children_markdown = await context.render_children()
+
+        callout_end = syntax.end_delimiter
+        if context.indent_level > 0:
+            callout_end = context.indent_text(callout_end)
+
+        # Combine content
+        if children_markdown:
+            context.markdown_result = f"{callout_header}\n{content}\n{children_markdown}\n{callout_end}"
+        else:
+            context.markdown_result = f"{callout_header}\n{content}\n{callout_end}"
+
+    async def _extract_callout_icon(self, block: Block) -> str:
+        if not block.callout or not block.callout.icon:
+            return ""
+        return block.callout.icon.emoji or ""
+
+    async def _extract_callout_content(self, block: Block) -> str:
+        if not block.callout or not block.callout.rich_text:
+            return ""
+        return await self._rich_text_markdown_converter.to_markdown(block.callout.rich_text)

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

@@ -0,0 +1,58 @@
+from abc import abstractmethod
+from typing import override
+
+from notionary.blocks.rich_text.rich_text_markdown_converter import RichTextToMarkdownConverter
+from notionary.blocks.schemas import Block
+from notionary.page.content.renderer.context import MarkdownRenderingContext
+from notionary.page.content.renderer.renderers.base import BlockRenderer
+from notionary.page.content.syntax.service import SyntaxRegistry
+
+
+class CaptionedBlockRenderer(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()
+
+    @abstractmethod
+    async def _render_main_content(self, block: Block) -> str:
+        raise NotImplementedError
+
+    @override
+    async def _process(self, context: MarkdownRenderingContext) -> None:
+        main_content = await self._render_main_content(context.block)
+
+        if not main_content:
+            context.markdown_result = ""
+            return
+
+        caption_markdown = await self._render_caption(context.block)
+
+        final_markdown = f"{main_content}{caption_markdown}"
+
+        if context.indent_level > 0:
+            final_markdown = context.indent_text(final_markdown)
+
+        children_markdown = await context.render_children_with_additional_indent(1)
+
+        if children_markdown:
+            context.markdown_result = f"{final_markdown}\n{children_markdown}"
+        else:
+            context.markdown_result = final_markdown
+
+    async def _render_caption(self, block: Block) -> str:
+        block_data_object = getattr(block, block.type.value, None)
+
+        if not block_data_object or not hasattr(block_data_object, "caption"):
+            return ""
+
+        caption_rich_text = getattr(block_data_object, "caption", [])
+        if not caption_rich_text:
+            return ""
+
+        caption_markdown = await self._rich_text_markdown_converter.to_markdown(caption_rich_text)
+
+        return f"\n[caption] {caption_markdown}"

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

@@ -0,0 +1,34 @@
+from typing import override
+
+from notionary.blocks.enums import BlockType
+from notionary.blocks.schemas import Block
+from notionary.page.content.renderer.renderers.captioned_block import CaptionedBlockRenderer
+
+
+class CodeRenderer(CaptionedBlockRenderer):
+    @override
+    def _can_handle(self, block: Block) -> bool:
+        return block.type == BlockType.CODE
+
+    @override
+    async def _render_main_content(self, block: Block) -> str:
+        language = self._extract_code_language(block)
+        code_content = await self._extract_code_content(block)
+
+        if not code_content:
+            return ""
+
+        syntax = self._syntax_registry.get_code_syntax()
+        code_start = f"{syntax.start_delimiter}{language}"
+        code_end = syntax.end_delimiter
+        return f"{code_start}\n{code_content}\n{code_end}"
+
+    def _extract_code_language(self, block: Block) -> str:
+        if not block.code or not block.code.language:
+            return ""
+        return block.code.language.value
+
+    async def _extract_code_content(self, block: Block) -> str:
+        if not block.code or not block.code.rich_text:
+            return ""
+        return await self._rich_text_markdown_converter.to_markdown(block.code.rich_text)

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

@@ -0,0 +1,44 @@
+from typing import override
+
+from notionary.blocks.enums import BlockType
+from notionary.blocks.schemas import Block
+from notionary.page.content.renderer.context import MarkdownRenderingContext
+from notionary.page.content.renderer.renderers.base import BlockRenderer
+
+
+class ColumnRenderer(BlockRenderer):
+    @override
+    def _can_handle(self, block: Block) -> bool:
+        return block.type == BlockType.COLUMN
+
+    @override
+    async def _process(self, context: MarkdownRenderingContext) -> None:
+        column_start = self._extract_column_start(context.block)
+
+        if context.indent_level > 0:
+            column_start = context.indent_text(column_start)
+
+        children_markdown = await context.render_children()
+
+        syntax = self._syntax_registry.get_column_syntax()
+        column_end = syntax.end_delimiter
+        if context.indent_level > 0:
+            column_end = context.indent_text(column_end, spaces=context.indent_level * 4)
+
+        if children_markdown:
+            context.markdown_result = f"{column_start}\n{children_markdown}\n{column_end}"
+        else:
+            context.markdown_result = f"{column_start}\n{column_end}"
+
+    def _extract_column_start(self, block: Block) -> str:
+        syntax = self._syntax_registry.get_column_syntax()
+        base_start = syntax.start_delimiter
+
+        if not block.column:
+            return base_start
+
+        width_ratio = block.column.width_ratio
+        if width_ratio:
+            return f"{base_start} {width_ratio}"
+        else:
+            return base_start

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

@@ -0,0 +1,31 @@
+from typing import override
+
+from notionary.blocks.enums import BlockType
+from notionary.blocks.schemas import Block
+from notionary.page.content.renderer.context import MarkdownRenderingContext
+from notionary.page.content.renderer.renderers.base import BlockRenderer
+
+
+class ColumnListRenderer(BlockRenderer):
+    @override
+    def _can_handle(self, block: Block) -> bool:
+        return block.type == BlockType.COLUMN_LIST
+
+    @override
+    async def _process(self, context: MarkdownRenderingContext) -> None:
+        syntax = self._syntax_registry.get_column_list_syntax()
+        column_list_start = syntax.start_delimiter
+
+        if context.indent_level > 0:
+            column_list_start = context.indent_text(column_list_start)
+
+        children_markdown = await context.render_children()
+
+        column_list_end = syntax.end_delimiter
+        if context.indent_level > 0:
+            column_list_end = context.indent_text(column_list_end)
+
+        if children_markdown:
+            context.markdown_result = f"{column_list_start}\n{children_markdown}\n{column_list_end}"
+        else:
+            context.markdown_result = f"{column_list_start}\n{column_list_end}"

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

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

notionary/page/content/renderer/renderers/embed.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 EmbedRenderer(CaptionedBlockRenderer):
+    @override
+    def _can_handle(self, block: Block) -> bool:
+        return block.type == BlockType.EMBED
+
+    @override
+    async def _render_main_content(self, block: Block) -> str:
+        url = self._extract_embed_url(block)
+
+        if not url:
+            return ""
+
+        syntax = self._syntax_registry.get_embed_syntax()
+        return f"{syntax.start_delimiter}{url}{syntax.end_delimiter}"
+
+    def _extract_embed_url(self, block: Block) -> str:
+        if not block.embed:
+            return ""
+        return block.embed.url or ""

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

@@ -0,0 +1,37 @@
+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 EquationRenderer(BlockRenderer):
+    @override
+    def _can_handle(self, block: Block) -> bool:
+        return block.type == BlockType.EQUATION
+
+    @override
+    async def _process(self, context: MarkdownRenderingContext) -> None:
+        expression = self._extract_equation_expression(context.block)
+
+        if not expression:
+            context.markdown_result = ""
+            return
+
+        syntax = self._syntax_registry.get_equation_syntax()
+        equation_markdown = f"{syntax.start_delimiter}{expression}{syntax.end_delimiter}"
+
+        if context.indent_level > 0:
+            equation_markdown = context.indent_text(equation_markdown)
+
+        children_markdown = await context.render_children_with_additional_indent(1)
+
+        if children_markdown:
+            context.markdown_result = f"{equation_markdown}\n{children_markdown}"
+        else:
+            context.markdown_result = equation_markdown
+
+    def _extract_equation_expression(self, block: Block) -> str:
+        if not block.equation:
+            return ""
+        return block.equation.expression or ""

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

@@ -0,0 +1,24 @@
+from typing import override
+
+from notionary.blocks.schemas import Block
+from notionary.page.content.renderer.context import MarkdownRenderingContext
+from notionary.page.content.renderer.renderers.base import BlockRenderer
+from notionary.utils.mixins.logging import LoggingMixin
+
+
+class FallbackRenderer(BlockRenderer, LoggingMixin):
+    @override
+    def _can_handle(self, block: Block) -> bool:
+        return True
+
+    @override
+    async def _process(self, context: MarkdownRenderingContext) -> None:
+        block_type = context.block.type.value if context.block.type else "unknown"
+        self.logger.warning(f"No handler found for block type: {block_type}")
+
+        fallback_message = f"[Unsupported block type: {block_type}]"
+
+        if context.indent_level > 0:
+            fallback_message = context.indent_text(fallback_message)
+
+        context.markdown_result = fallback_message