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

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

@@ -0,0 +1,50 @@
+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 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:
+        content = await self._extract_callout_content(context.block)
+
+        if not content:
+            context.markdown_result = ""
+            return
+
+        icon = await self._extract_callout_icon(context.block)
+
+        callout_start_delimiter = self._syntax_registry.get_callout_syntax().start_delimiter
+
+        result = f'{callout_start_delimiter}({content} "{icon}")' if icon else f"{callout_start_delimiter}({content})"
+
+        if context.indent_level > 0:
+            result = context.indent_text(result)
+
+        context.markdown_result = result
+
+    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 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,53 @@
+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._format_column_start(context.block, context.indent_level)
+        children_markdown = await self._render_children_with_indentation(context)
+
+        if children_markdown:
+            context.markdown_result = f"{column_start}\n{children_markdown}"
+        else:
+            context.markdown_result = column_start
+
+    def _format_column_start(self, block: Block, indent_level: int) -> str:
+        column_start = self._build_column_start_tag(block)
+
+        if indent_level > 0:
+            indent = "    " * indent_level
+            column_start = f"{indent}{column_start}"
+
+        return column_start
+
+    def _build_column_start_tag(self, block: Block) -> str:
+        delimiter = self._syntax_registry.get_column_syntax().start_delimiter
+
+        if not block.column:
+            return delimiter
+
+        width_ratio = block.column.width_ratio
+        if width_ratio:
+            return f"{delimiter} {width_ratio}"
+
+        return delimiter
+
+    async def _render_children_with_indentation(self, context: MarkdownRenderingContext) -> str:
+        original_indent = context.indent_level
+        context.indent_level += 1
+
+        children_markdown = await context.render_children()
+
+        context.indent_level = original_indent
+
+        return children_markdown

notionary/page/content/renderer/renderers/column_list.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 ColumnListRenderer(BlockRenderer):
+    @override
+    def _can_handle(self, block: Block) -> bool:
+        return block.type == BlockType.COLUMN_LIST
+
+    @override
+    async def _process(self, context: MarkdownRenderingContext) -> None:
+        column_list_start = self._format_column_list_start(context.indent_level)
+        children_markdown = await self._render_children_with_indentation(context)
+
+        if children_markdown:
+            context.markdown_result = f"{column_list_start}\n{children_markdown}"
+        else:
+            context.markdown_result = column_list_start
+
+    def _format_column_list_start(self, indent_level: int) -> str:
+        delimiter = self._get_column_list_delimiter()
+
+        if indent_level > 0:
+            indent = "    " * indent_level
+            return f"{indent}{delimiter}"
+
+        return delimiter
+
+    def _get_column_list_delimiter(self) -> str:
+        return self._syntax_registry.get_column_list_syntax().start_delimiter
+
+    async def _render_children_with_indentation(self, context: MarkdownRenderingContext) -> str:
+        original_indent = context.indent_level
+        context.indent_level += 1
+
+        children_markdown = await context.render_children()
+
+        context.indent_level = original_indent
+
+        return children_markdown

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

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

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

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

@@ -0,0 +1,95 @@
+from typing import override
+
+from notionary.blocks.rich_text.rich_text_markdown_converter import RichTextToMarkdownConverter
+from notionary.blocks.schemas import Block, BlockType, HeadingData
+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 HeadingRenderer(BlockRenderer):
+    MIN_HEADING_LEVEL = 1
+    MAX_HEADING_LEVEL = 3
+
+    def __init__(
+        self,
+        syntax_registry: SyntaxRegistry | None = None,
+        rich_text_markdown_converter: RichTextToMarkdownConverter | None = None,
+    ) -> None:
+        super().__init__(syntax_registry=syntax_registry)
+        self._syntax = self._syntax_registry.get_heading_syntax()
+        self._rich_text_markdown_converter = rich_text_markdown_converter or RichTextToMarkdownConverter()
+
+    @override
+    def _can_handle(self, block: Block) -> bool:
+        return block.type in (BlockType.HEADING_1, BlockType.HEADING_2, BlockType.HEADING_3)
+
+    @override
+    async def _process(self, context: MarkdownRenderingContext) -> None:
+        level = self._get_heading_level(context.block)
+        title = await self._get_heading_title(context.block)
+
+        if not self._is_valid_heading(level, title):
+            return
+
+        heading_markdown = self._format_heading(level, title, context.indent_level)
+
+        if self._is_toggleable(context.block):
+            context.markdown_result = await self._render_toggleable_heading(heading_markdown, context)
+        else:
+            context.markdown_result = heading_markdown
+
+    def _is_valid_heading(self, level: int, title: str) -> bool:
+        return self.MIN_HEADING_LEVEL <= level <= self.MAX_HEADING_LEVEL and bool(title)
+
+    def _format_heading(self, level: int, title: str, indent_level: int) -> str:
+        heading_prefix = self._syntax.start_delimiter * level
+        heading_markdown = f"{heading_prefix} {title}"
+
+        if indent_level > 0:
+            indent = "    " * indent_level
+            heading_markdown = f"{indent}{heading_markdown}"
+
+        return heading_markdown
+
+    async def _render_toggleable_heading(self, heading_markdown: str, context: MarkdownRenderingContext) -> str:
+        original_indent = context.indent_level
+        context.indent_level += 1
+
+        children_markdown = await context.render_children()
+
+        context.indent_level = original_indent
+
+        if children_markdown:
+            return f"{heading_markdown}\n{children_markdown}"
+        return heading_markdown
+
+    def _get_heading_level(self, block: Block) -> int:
+        if block.type == BlockType.HEADING_1:
+            return 1
+        elif block.type == BlockType.HEADING_2:
+            return 2
+        elif block.type == BlockType.HEADING_3:
+            return 3
+        return 0
+
+    def _is_toggleable(self, block: Block) -> bool:
+        heading_data = self._get_heading_data(block)
+        return heading_data.is_toggleable if heading_data else False
+
+    async def _get_heading_title(self, block: Block) -> str:
+        heading_data = self._get_heading_data(block)
+
+        if not heading_data or not heading_data.rich_text:
+            return ""
+
+        return await self._rich_text_markdown_converter.to_markdown(heading_data.rich_text)
+
+    def _get_heading_data(self, block: Block) -> HeadingData | None:
+        if block.type == BlockType.HEADING_1:
+            return block.heading_1
+        elif block.type == BlockType.HEADING_2:
+            return block.heading_2
+        elif block.type == BlockType.HEADING_3:
+            return block.heading_3
+        return None

notionary/page/content/renderer/renderers/image.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 ImageRenderer(CaptionedBlockRenderer):
+    @override
+    def _can_handle(self, block: Block) -> bool:
+        return block.type == BlockType.IMAGE
+
+    @override
+    async def _render_main_content(self, block: Block) -> str:
+        url = self._extract_image_url(block)
+
+        if not url:
+            return ""
+
+        syntax = self._syntax_registry.get_image_syntax()
+        return f"{syntax.start_delimiter}{url}{syntax.end_delimiter}"
+
+    def _extract_image_url(self, block: Block) -> str:
+        if not block.image:
+            return ""
+
+        if block.image.external:
+            return block.image.external.url or ""
+        elif block.image.file:
+            return block.image.file.url or ""
+
+        return ""

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

@@ -0,0 +1,42 @@
+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 MarkdownGrammar, SyntaxRegistry
+
+
+class NumberedListRenderer(BlockRenderer):
+    def __init__(
+        self,
+        syntax_registry: SyntaxRegistry | None = None,
+        rich_text_markdown_converter: RichTextToMarkdownConverter | None = None,
+        markdown_grammar: MarkdownGrammar | None = None,
+    ) -> None:
+        super().__init__(syntax_registry=syntax_registry)
+        self._rich_text_markdown_converter = rich_text_markdown_converter or RichTextToMarkdownConverter()
+
+        markdown_grammar = markdown_grammar or MarkdownGrammar()
+        self._numbered_list_placeholder = markdown_grammar.numbered_list_placeholder
+
+    @override
+    def _can_handle(self, block: Block) -> bool:
+        return block.type == BlockType.NUMBERED_LIST_ITEM
+
+    @override
+    async def _process(self, context: MarkdownRenderingContext) -> None:
+        list_item_data = context.block.numbered_list_item
+        rich_text = list_item_data.rich_text if list_item_data else []
+        content = await self._rich_text_markdown_converter.to_markdown(rich_text)
+
+        item_line = context.indent_text(f"{self._numbered_list_placeholder}. {content}")
+
+        children_markdown = await context.render_children_with_additional_indent(1)
+
+        if children_markdown:
+            context.markdown_result = f"{item_line}\n{children_markdown}"
+        else:
+            context.markdown_result = item_line

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

@@ -0,0 +1,40 @@
+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
+
+
+class ParagraphRenderer(BlockRenderer):
+    def __init__(self, rich_text_markdown_converter: RichTextToMarkdownConverter | None = None) -> None:
+        super().__init__()
+        self._rich_text_markdown_converter = rich_text_markdown_converter or RichTextToMarkdownConverter()
+
+    @override
+    def _can_handle(self, block: Block) -> bool:
+        return block.type == BlockType.PARAGRAPH
+
+    @override
+    async def _process(self, context: MarkdownRenderingContext) -> None:
+        markdown = await self._convert_paragraph_to_markdown(context.block)
+
+        if not markdown:
+            context.markdown_result = ""
+            return
+
+        if context.indent_level > 0:
+            markdown = context.indent_text(markdown)
+
+        children_markdown = await context.render_children_with_additional_indent(1)
+
+        if children_markdown:
+            context.markdown_result = f"{markdown}\n{children_markdown}"
+        else:
+            context.markdown_result = markdown
+
+    async def _convert_paragraph_to_markdown(self, block: Block) -> str | None:
+        if not block.paragraph or not block.paragraph.rich_text:
+            return None
+
+        return await self._rich_text_markdown_converter.to_markdown(block.paragraph.rich_text)

notionary/page/content/renderer/renderers/pdf.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 PdfRenderer(CaptionedBlockRenderer):
+    @override
+    def _can_handle(self, block: Block) -> bool:
+        return block.type == BlockType.PDF
+
+    @override
+    async def _render_main_content(self, block: Block) -> str:
+        url = self._extract_pdf_url(block)
+
+        if not url:
+            return ""
+
+        syntax = self._syntax_registry.get_pdf_syntax()
+        return f"{syntax.start_delimiter}{url}{syntax.end_delimiter}"
+
+    def _extract_pdf_url(self, block: Block) -> str:
+        if not block.pdf:
+            return ""
+
+        if block.pdf.external:
+            return block.pdf.external.url or ""
+        elif block.pdf.file:
+            return block.pdf.file.url or ""
+
+        return ""