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

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 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 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,52 @@
+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 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)
+
+        original_indent = context.indent_level
+        context.indent_level += 1
+        children_markdown = await context.render_children()
+        context.indent_level = original_indent
+
+        if children_markdown:
+            context.markdown_result = f"{toggle_start}\n{children_markdown}"
+        else:
+            context.markdown_result = toggle_start
+
+    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/video.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 VideoRenderer(CaptionedBlockRenderer):
+    @override
+    def _can_handle(self, block: Block) -> bool:
+        return block.type == BlockType.VIDEO
+
+    @override
+    async def _render_main_content(self, block: Block) -> str:
+        url = self._extract_video_url(block)
+
+        if not url:
+            return ""
+
+        syntax = self._syntax_registry.get_video_syntax()
+        return f"{syntax.start_delimiter}{url}{syntax.end_delimiter}"
+
+    def _extract_video_url(self, block: Block) -> str:
+        if not block.video:
+            return ""
+
+        if block.video.external:
+            return block.video.external.url or ""
+        elif block.video.file:
+            return block.video.file.url or ""
+
+        return ""

notionary/page/content/renderer/service.py

@@ -0,0 +1,50 @@
+from notionary.blocks.schemas import Block
+from notionary.page.content.renderer.context import MarkdownRenderingContext
+from notionary.page.content.renderer.post_processing.service import MarkdownRenderingPostProcessor
+from notionary.page.content.renderer.renderers import BlockRenderer
+from notionary.utils.mixins.logging import LoggingMixin
+
+
+class NotionToMarkdownConverter(LoggingMixin):
+    def __init__(
+        self,
+        renderer_chain: BlockRenderer,
+        post_processor: MarkdownRenderingPostProcessor,
+    ) -> None:
+        self._renderer_chain = renderer_chain
+        self._post_processor = post_processor
+
+    async def convert(self, blocks: list[Block], indent_level: int = 0) -> str:
+        if not blocks:
+            return ""
+
+        rendered_block_parts = []
+        current_block_index = 0
+
+        while current_block_index < len(blocks):
+            context = self._create_rendering_context(blocks, current_block_index, indent_level)
+            await self._renderer_chain.handle(context)
+
+            if context.markdown_result:
+                rendered_block_parts.append(context.markdown_result)
+
+            current_block_index += 1
+
+        result = self._join_rendered_blocks(rendered_block_parts, indent_level)
+        result = self._post_processor.process(result)
+
+        return result
+
+    def _create_rendering_context(
+        self, blocks: list[Block], block_index: int, indent_level: int
+    ) -> MarkdownRenderingContext:
+        block = blocks[block_index]
+        return MarkdownRenderingContext(
+            block=block,
+            indent_level=indent_level,
+            convert_children_callback=self.convert,
+        )
+
+    def _join_rendered_blocks(self, rendered_parts: list[str], indent_level: int) -> str:
+        separator = "\n\n" if indent_level == 0 else "\n"
+        return separator.join(rendered_parts)

notionary/page/content/service.py

@@ -0,0 +1,68 @@
+import asyncio
+from collections.abc import Callable
+
+from notionary.blocks.client import NotionBlockHttpClient
+from notionary.blocks.schemas import Block
+from notionary.page.content.markdown.builder import MarkdownBuilder
+from notionary.page.content.parser.service import MarkdownToNotionConverter
+from notionary.page.content.renderer.service import NotionToMarkdownConverter
+from notionary.utils.decorators import async_retry, time_execution_async
+from notionary.utils.mixins.logging import LoggingMixin
+
+
+class PageContentService(LoggingMixin):
+    def __init__(
+        self,
+        page_id: str,
+        block_client: NotionBlockHttpClient,
+        markdown_converter: MarkdownToNotionConverter,
+        notion_to_markdown_converter: NotionToMarkdownConverter,
+    ) -> None:
+        self._page_id = page_id
+        self._block_client = block_client
+        self._markdown_converter = markdown_converter
+        self._notion_to_markdown_converter = notion_to_markdown_converter
+
+    @time_execution_async()
+    async def get_as_markdown(self) -> str:
+        blocks = await self._block_client.get_block_tree(parent_block_id=self._page_id)
+        return await self._notion_to_markdown_converter.convert(blocks=blocks)
+
+    @time_execution_async()
+    async def clear(self) -> None:
+        children_response = await self._block_client.get_block_children(block_id=self._page_id)
+
+        if not children_response or not children_response.results:
+            self.logger.debug("No blocks to delete for page: %s", self._page_id)
+            return
+
+        await asyncio.gather(*[self._delete_single_block(block) for block in children_response.results])
+
+    @async_retry(max_retries=10, initial_delay=0.2, backoff_factor=1.5)
+    async def _delete_single_block(self, block: Block) -> None:
+        self.logger.debug("Deleting block: %s", block.id)
+        await self._block_client.delete_block(block.id)
+
+    @time_execution_async()
+    async def append_markdown(self, content: str | Callable[[MarkdownBuilder], MarkdownBuilder]) -> None:
+        markdown = self._extract_markdown(content)
+        if not markdown:
+            self.logger.debug("No markdown content to append for page: %s", self._page_id)
+            return
+
+        blocks = await self._markdown_converter.convert(markdown)
+        await self._append_blocks(blocks)
+
+    def _extract_markdown(self, content: str | Callable[[MarkdownBuilder], MarkdownBuilder]) -> str:
+        if isinstance(content, str):
+            return content
+
+        if callable(content):
+            builder = MarkdownBuilder()
+            content(builder)
+            return builder.build()
+
+        raise ValueError("content must be either a string or a callable that takes a MarkdownBuilder")
+
+    async def _append_blocks(self, blocks: list[Block]) -> None:
+        await self._block_client.append_block_children(block_id=self._page_id, children=blocks)

notionary/page/content/syntax/__init__.py

@@ -0,0 +1,4 @@
+from .grammar import MarkdownGrammar
+from .registry import SyntaxRegistry
+
+__all__ = ["MarkdownGrammar", "SyntaxRegistry"]

notionary/page/content/syntax/grammar.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class MarkdownGrammar:
+    spaces_per_nesting_level = 4
+    numbered_list_placeholder = "__NUM__"
+    column_delimiter = ":::"
+    toggle_delimiter = "+++"
+    table_delimiter = "|"

notionary/page/content/syntax/models.py

@@ -0,0 +1,66 @@
+import re
+from dataclasses import dataclass
+from enum import StrEnum
+
+
+class SyntaxRegistryKey(StrEnum):
+    AUDIO = "audio"
+    BOOKMARK = "bookmark"
+    IMAGE = "image"
+    VIDEO = "video"
+    FILE = "file"
+    PDF = "pdf"
+
+    # List blocks
+    BULLETED_LIST = "bulleted_list"
+    NUMBERED_LIST = "numbered_list"
+    TO_DO = "todo"
+    TO_DO_DONE = "todo_done"
+
+    TOGGLE = "toggle"
+    TOGGLEABLE_HEADING = "toggleable_heading"
+    CALLOUT = "callout"
+    QUOTE = "quote"
+    CODE = "code"
+
+    COLUMN_LIST = "column_list"
+    COLUMN = "column"
+
+    # Heading blocks
+    HEADING_1 = "heading_1"
+    HEADING_2 = "heading_2"
+    HEADING_3 = "heading_3"
+    HEADING = "heading"  # Shared pattern for regular headings
+
+    DIVIDER = "divider"
+    BREADCRUMB = "breadcrumb"
+    TABLE_OF_CONTENTS = "table_of_contents"
+    EQUATION = "equation"
+    EMBED = "embed"
+    TABLE = "table"
+    TABLE_ROW = "table_row"
+
+    CAPTION = "caption"
+    SPACE = "space"
+
+
+# some elemente need closing delimiters, others not
+# either use union type or validate config in service
+@dataclass(frozen=True)
+class SyntaxDefinition:
+    """
+    Defines the syntax pattern for a block type.
+
+    Attributes:
+        start_delimiter: The opening delimiter (e.g., "```", "+++", ">")
+        end_delimiter: The optional closing delimiter (empty string if none)
+        regex_pattern: The compiled regex pattern to match this syntax
+        end_regex_pattern: Optional compiled regex pattern for end delimiter
+        is_multiline_block: Whether this block can contain child blocks
+        is_inline: Whether this is an inline syntax (like [audio](url))
+    """
+
+    start_delimiter: str
+    end_delimiter: str
+    regex_pattern: re.Pattern
+    end_regex_pattern: re.Pattern | None = None