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

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,69 @@
+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 HeadingRenderer(BlockRenderer):
+    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:
+        if block.type == BlockType.HEADING_1:
+            return not block.heading_1.is_toggleable
+        if block.type == BlockType.HEADING_2:
+            return not block.heading_2.is_toggleable
+        if block.type == BlockType.HEADING_3:
+            return not block.heading_3.is_toggleable
+
+        return False
+
+    @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 title or level == 0:
+            return
+
+        heading_markdown = f"{self._syntax.start_delimiter * level} {title}"
+
+        if context.indent_level > 0:
+            heading_markdown = context.indent_text(heading_markdown)
+
+        context.markdown_result = 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
+        else:
+            return 0
+
+    async def _get_heading_title(self, block: Block) -> str:
+        if block.type == BlockType.HEADING_1:
+            heading_content = block.heading_1
+        elif block.type == BlockType.HEADING_2:
+            heading_content = block.heading_2
+        elif block.type == BlockType.HEADING_3:
+            heading_content = block.heading_3
+        else:
+            return ""
+
+        if not heading_content or not heading_content.rich_text:
+            return ""
+
+        return await self._rich_text_markdown_converter.to_markdown(heading_content.rich_text)

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,41 @@
+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 NumberedListRenderer(BlockRenderer):
+    # Placeholder for numbered list fixer (post processing)
+    NUMBERED_LIST_PLACEHOLDER = "__NUM__"
+
+    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.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 ""

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

@@ -0,0 +1,49 @@
+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 QuoteRenderer(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.QUOTE
+
+    @override
+    async def _process(self, context: MarkdownRenderingContext) -> None:
+        markdown = await self._convert_quote_to_markdown(context.block)
+
+        if not markdown:
+            context.markdown_result = ""
+            return
+
+        syntax = self._syntax_registry.get_quote_syntax()
+        quote_lines = markdown.split("\n")
+        quote_markdown = "\n".join(f"{syntax.start_delimiter}{line}" for line in quote_lines)
+
+        if context.indent_level > 0:
+            quote_markdown = context.indent_text(quote_markdown)
+
+        children_markdown = await context.render_children_with_additional_indent(1)
+
+        if children_markdown:
+            context.markdown_result = f"{quote_markdown}\n{children_markdown}"
+        else:
+            context.markdown_result = quote_markdown
+
+    async def _convert_quote_to_markdown(self, block: Block) -> str | None:
+        if not block.quote or not block.quote.rich_text:
+            return None
+
+        return await self._rich_text_markdown_converter.to_markdown(block.quote.rich_text)

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

@@ -0,0 +1,115 @@
+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 TableRenderer(BlockRenderer):
+    MINIMUM_COLUMN_WIDTH = 3
+
+    def __init__(self, rich_text_markdown_converter: RichTextToMarkdownConverter | None = None) -> None:
+        super().__init__()
+        self._rich_text_markdown_converter = rich_text_markdown_converter or RichTextToMarkdownConverter()
+        self._table_syntax = self._syntax_registry.get_table_syntax()
+
+    @override
+    def _can_handle(self, block: Block) -> bool:
+        return block.type == BlockType.TABLE
+
+    @override
+    async def _process(self, context: MarkdownRenderingContext) -> None:
+        table_markdown = await self._build_table_markdown(context.block)
+
+        if not table_markdown:
+            context.markdown_result = ""
+            return
+
+        if context.indent_level > 0:
+            table_markdown = context.indent_text(table_markdown)
+
+        children_markdown = await context.render_children_with_additional_indent(1)
+
+        if children_markdown:
+            context.markdown_result = f"{table_markdown}\n{children_markdown}"
+        else:
+            context.markdown_result = table_markdown
+
+    async def _build_table_markdown(self, block: Block) -> str:
+        if not block.table or not block.has_children or not block.children:
+            return ""
+
+        rows = []
+        for row_block in block.children:
+            if row_block.type != BlockType.TABLE_ROW or not row_block.table_row:
+                continue
+
+            row_cells = await self._extract_row_cells(row_block)
+            rows.append(row_cells)
+
+        if not rows:
+            return ""
+
+        max_columns = max(len(row) for row in rows)
+        normalized_rows = self._normalize_row_lengths(rows, max_columns)
+        column_widths = self._calculate_column_widths(normalized_rows, max_columns)
+
+        markdown_lines = []
+
+        first_row = normalized_rows[0]
+        formatted_first_row = self._format_row(first_row, column_widths)
+        markdown_lines.append(formatted_first_row)
+
+        separator_line = self._create_separator_line(column_widths)
+        markdown_lines.append(separator_line)
+
+        remaining_rows = normalized_rows[1:]
+        for row in remaining_rows:
+            formatted_row = self._format_row(row, column_widths)
+            markdown_lines.append(formatted_row)
+
+        return "\n".join(markdown_lines)
+
+    def _normalize_row_lengths(self, rows: list[list[str]], target_length: int) -> list[list[str]]:
+        return [row + [""] * (target_length - len(row)) for row in rows]
+
+    def _calculate_column_widths(self, rows: list[list[str]], num_columns: int) -> list[int]:
+        widths = [max(len(row[i]) for row in rows) for i in range(num_columns)]
+        return [max(width, self.MINIMUM_COLUMN_WIDTH) for width in widths]
+
+    def _format_row(self, cells: list[str], column_widths: list[int]) -> str:
+        centered_cells = [cell.center(column_widths[i]) for i, cell in enumerate(cells)]
+        delimiter = self._table_syntax.start_delimiter
+        return f"{delimiter} {f' {delimiter} '.join(centered_cells)} {delimiter}"
+
+    def _create_separator_line(self, column_widths: list[int]) -> str:
+        separators = ["-" * width for width in column_widths]
+        delimiter = self._table_syntax.start_delimiter
+        return f"{delimiter} {f' {delimiter} '.join(separators)} {delimiter}"
+
+    def _has_column_header(self, block: Block) -> bool:
+        if not block.table:
+            return False
+        return block.table.has_column_header or False
+
+    def _has_row_header(self, block: Block) -> bool:
+        if not block.table:
+            return False
+        return block.table.has_row_header or False
+
+    def _get_table_width(self, block: Block) -> int:
+        if not block.table:
+            return 0
+        return block.table.table_width or 0
+
+    async def _extract_row_cells(self, row_block: Block) -> list[str]:
+        if not row_block.table_row or not row_block.table_row.cells:
+            return []
+
+        cells = []
+        for cell in row_block.table_row.cells:
+            cell_text = await self._rich_text_markdown_converter.to_markdown(cell)
+            cells.append(cell_text or "")
+
+        return cells

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

@@ -0,0 +1,26 @@
+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 TableOfContentsRenderer(BlockRenderer):
+    @override
+    def _can_handle(self, block: Block) -> bool:
+        return block.type == BlockType.TABLE_OF_CONTENTS
+
+    @override
+    async def _process(self, context: MarkdownRenderingContext) -> None:
+        syntax = self._syntax_registry.get_table_of_contents_syntax()
+        toc_markdown = syntax.start_delimiter
+
+        if context.indent_level > 0:
+            toc_markdown = context.indent_text(toc_markdown)
+
+        children_markdown = await context.render_children_with_additional_indent(1)
+
+        if children_markdown:
+            context.markdown_result = f"{toc_markdown}\n{children_markdown}"
+        else:
+            context.markdown_result = toc_markdown

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

@@ -0,0 +1,17 @@
+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 TableRowHandler(BlockRenderer):
+    @override
+    def _can_handle(self, block: Block) -> bool:
+        return block.type == BlockType.TABLE_ROW
+
+    @override
+    async def _process(self, context: MarkdownRenderingContext) -> None:
+        """Table rows are internally handled by table as the structure supports it"""
+        pass

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

@@ -0,0 +1,56 @@
+from typing import override
+
+from notionary.blocks.enums import BlockType
+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 TodoRenderer(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.TO_DO
+
+    @override
+    async def _process(self, context: MarkdownRenderingContext) -> None:
+        is_checked, content = await self._extract_todo_info(context.block)
+
+        if not content:
+            context.markdown_result = ""
+            return
+
+        syntax = self._syntax_registry.get_todo_done_syntax() if is_checked else self._syntax_registry.get_todo_syntax()
+
+        todo_markdown = f"{syntax.start_delimiter} {content}"
+
+        if context.indent_level > 0:
+            todo_markdown = context.indent_text(todo_markdown)
+
+        children_markdown = await context.render_children_with_additional_indent(1)
+
+        if children_markdown:
+            context.markdown_result = f"{todo_markdown}\n{children_markdown}"
+        else:
+            context.markdown_result = todo_markdown
+
+    async def _extract_todo_info(self, block: Block) -> tuple[bool, str]:
+        if not block.to_do:
+            return False, ""
+
+        is_checked = block.to_do.checked or False
+
+        content = ""
+        if block.to_do.rich_text:
+            content = await self._rich_text_markdown_converter.to_markdown(block.to_do.rich_text)
+
+        return is_checked, content

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

@@ -0,0 +1,53 @@
+from typing import override
+
+from notionary.blocks.enums import BlockType
+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 ToggleRenderer(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.TOGGLE
+
+    @override
+    async def _process(self, context: MarkdownRenderingContext) -> None:
+        toggle_title = await self._extract_toggle_title(context.block)
+
+        if not toggle_title:
+            return
+
+        syntax = self._syntax_registry.get_toggle_syntax()
+        toggle_start = f"{syntax.start_delimiter} {toggle_title}"
+
+        if context.indent_level > 0:
+            toggle_start = context.indent_text(toggle_start)
+
+        children_markdown = await context.render_children()
+
+        toggle_end = syntax.end_delimiter
+        if context.indent_level > 0:
+            toggle_end = context.indent_text(toggle_end)
+
+        if children_markdown:
+            context.markdown_result = f"{toggle_start}\n{children_markdown}\n{toggle_end}"
+        else:
+            context.markdown_result = f"{toggle_start}\n{toggle_end}"
+
+    async def _extract_toggle_title(self, block: Block) -> str:
+        if not block.toggle or not block.toggle.rich_text:
+            return ""
+
+        rich_text_title = block.toggle.rich_text
+        return await self._rich_text_markdown_converter.to_markdown(rich_text_title)

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

@@ -0,0 +1,78 @@
+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 ToggleableHeadingRenderer(BlockRenderer):
+    def __init__(
+        self,
+        syntax_registry: SyntaxRegistry | None = None,
+        rich_text_markdown_converter: RichTextToMarkdownConverter | None = None,
+    ) -> None:
+        super().__init__(syntax_registry=syntax_registry)
+        self._heading_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:
+        if block.type == BlockType.HEADING_1:
+            return block.heading_1.is_toggleable
+        if block.type == BlockType.HEADING_2:
+            return block.heading_2.is_toggleable
+        if block.type == BlockType.HEADING_3:
+            return block.heading_3.is_toggleable
+
+    @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 title or level == 0:
+            return
+
+        syntax = self._syntax_registry.get_toggleable_heading_syntax()
+        prefix = self._syntax_registry.TOGGLE_DELIMITER + " " + (self._heading_syntax.start_delimiter * level)
+        heading_start = f"{prefix} {title}"
+
+        if context.indent_level > 0:
+            heading_start = context.indent_text(heading_start)
+
+        children_markdown = await context.render_children()
+
+        heading_end = syntax.end_delimiter
+        if context.indent_level > 0:
+            heading_end = context.indent_text(heading_end)
+
+        if children_markdown:
+            context.markdown_result = f"{heading_start}\n{children_markdown}\n{heading_end}"
+        else:
+            context.markdown_result = f"{heading_start}\n{heading_end}"
+
+    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
+        else:
+            return 0
+
+    async def _get_heading_title(self, block: Block) -> str:
+        if block.type == BlockType.HEADING_1:
+            heading_content = block.heading_1
+        elif block.type == BlockType.HEADING_2:
+            heading_content = block.heading_2
+        elif block.type == BlockType.HEADING_3:
+            heading_content = block.heading_3
+        else:
+            return ""
+
+        if not heading_content or not heading_content.rich_text:
+            return ""
+
+        return await self._rich_text_markdown_converter.to_markdown(heading_content.rich_text)