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

notionary/page/content/parser/post_processing/handlers/rich_text_length_truncation.py

@@ -0,0 +1,93 @@
+"""
+Handles request limits for rich texts (see https://developers.notion.com/reference/request-limits)
+"""
+
+from typing import Any, override
+
+from notionary.blocks.rich_text.models import RichText, RichTextType
+from notionary.blocks.schemas import BlockCreatePayload
+from notionary.page.content.parser.post_processing.port import PostProcessor
+from notionary.utils.mixins.logging import LoggingMixin
+
+type _NestedBlockList = BlockCreatePayload | list["_NestedBlockList"]
+
+
+class RichTextLengthTruncationPostProcessor(PostProcessor, LoggingMixin):
+    NOTION_MAX_LENGTH = 2000
+
+    def __init__(self, max_text_length: int = NOTION_MAX_LENGTH) -> None:
+        self.max_text_length = max_text_length
+
+    @override
+    def process(self, blocks: list[BlockCreatePayload]) -> list[BlockCreatePayload]:
+        if not blocks:
+            return blocks
+
+        flattened_blocks = self._flatten_blocks(blocks)
+        return [self._process_block(block) for block in flattened_blocks]
+
+    def _flatten_blocks(self, blocks: list[_NestedBlockList]) -> list[BlockCreatePayload]:
+        flattened: list[BlockCreatePayload] = []
+
+        for item in blocks:
+            if isinstance(item, list):
+                flattened.extend(self._flatten_blocks(item))
+            else:
+                flattened.append(item)
+
+        return flattened
+
+    def _process_block(self, block: BlockCreatePayload) -> BlockCreatePayload:
+        block_copy = block.model_copy(deep=True)
+        content = self._get_block_content(block_copy)
+
+        if content is not None:
+            self._truncate_content(content)
+
+        return block_copy
+
+    def _get_block_content(self, block: BlockCreatePayload) -> Any | None:
+        content = getattr(block, block.type.value, None)
+
+        if content is None:
+            return None
+
+        if hasattr(content, "rich_text") or hasattr(content, "children"):
+            return content
+
+        return None
+
+    def _truncate_content(self, content: object) -> None:
+        if hasattr(content, "rich_text"):
+            self._truncate_rich_text_list(content.rich_text)
+
+        if hasattr(content, "caption"):
+            self._truncate_rich_text_list(content.caption)
+
+        if hasattr(content, "children"):
+            for child in content.children:
+                child_content = self._get_block_content(child)
+                if child_content:
+                    self._truncate_content(child_content)
+
+    def _truncate_rich_text_list(self, rich_text_list: list[RichText]) -> None:
+        for rich_text in rich_text_list:
+            if not self._is_text_type(rich_text):
+                continue
+
+            content = rich_text.text.content
+            if len(content) > self.max_text_length:
+                self.logger.warning(
+                    "Truncating text content from %d to %d characters",
+                    len(content),
+                    self.max_text_length,
+                )
+                truncated_content = self._create_truncated_text_with_ellipsis(content)
+                rich_text.text.content = truncated_content
+
+    def _create_truncated_text_with_ellipsis(self, content: str) -> str:
+        cutoff = self.max_text_length - 3
+        return content[:cutoff] + "..."
+
+    def _is_text_type(self, rich_text: RichText) -> bool:
+        return rich_text.type == RichTextType.TEXT and rich_text.text and rich_text.text.content

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

@@ -0,0 +1,9 @@
+from abc import ABC, abstractmethod
+
+from notionary.blocks.schemas import BlockCreatePayload
+
+
+class PostProcessor(ABC):
+    @abstractmethod
+    def process(self, blocks: list[BlockCreatePayload]) -> list[BlockCreatePayload]:
+        pass

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

@@ -0,0 +1,16 @@
+from notionary.blocks.schemas import BlockCreatePayload
+from notionary.page.content.parser.post_processing.port import PostProcessor
+
+
+class BlockPostProcessor:
+    def __init__(self) -> None:
+        self._processors: list[PostProcessor] = []
+
+    def register(self, processor: PostProcessor) -> None:
+        self._processors.append(processor)
+
+    def process(self, created_blocks: list[BlockCreatePayload]) -> list[BlockCreatePayload]:
+        result = created_blocks
+        for processor in self._processors:
+            result = processor.process(created_blocks)
+        return result

notionary/page/content/parser/pre_processsing/handlers/__init__.py

@@ -0,0 +1,9 @@
+from .column_syntax import ColumnSyntaxPreProcessor
+from .port import PreProcessor
+from .whitespace import WhitespacePreProcessor
+
+__all__ = [
+    "ColumnSyntaxPreProcessor",
+    "PreProcessor",
+    "WhitespacePreProcessor",
+]

notionary/page/content/parser/pre_processsing/handlers/column_syntax.py

@@ -0,0 +1,80 @@
+import re
+from typing import override
+
+from notionary.exceptions.block_parsing import InsufficientColumnsError, InvalidColumnRatioSumError
+from notionary.page.content.parser.pre_processsing.handlers.port import PreProcessor
+from notionary.page.content.syntax.service import SyntaxRegistry
+
+RATIO_TOLERANCE = 0.0001
+
+
+class ColumnSyntaxPreProcessor(PreProcessor):
+    def __init__(self, syntax_registry: SyntaxRegistry | None = None) -> None:
+        self._syntax_registry = syntax_registry or SyntaxRegistry()
+        self._column_list_syntax = self._syntax_registry.get_column_list_syntax()
+        self._column_syntax = self._syntax_registry.get_column_syntax()
+
+    @override
+    def process(self, markdown_text: str) -> str:
+        if not self._has_columns_blocks(markdown_text):
+            return markdown_text
+
+        columns_blocks = self._extract_columns_blocks(markdown_text)
+
+        for content in columns_blocks:
+            column_matches = self._find_column_blocks(content)
+            column_count = len(column_matches)
+            self._validate_minimum_columns(column_count)
+            ratios = self._extract_ratios(column_matches)
+            self._validate_ratios(ratios, column_count)
+        return markdown_text
+
+    def _has_columns_blocks(self, markdown_text: str) -> bool:
+        return self._column_list_syntax.start_delimiter in markdown_text
+
+    def _extract_columns_blocks(self, markdown_text: str) -> list[str]:
+        columns_blocks = []
+        lines = markdown_text.split("\n")
+        for index, line in enumerate(lines):
+            if line.strip() == self._column_list_syntax.start_delimiter:
+                content = self._extract_block_content(lines, index + 1)
+                if content is not None:
+                    columns_blocks.append(content)
+        return columns_blocks
+
+    def _extract_block_content(self, lines: list[str], start_index: int) -> str | None:
+        depth = 1
+        end_index = start_index
+        block_start = self._column_list_syntax.start_delimiter.split()[0]
+        while end_index < len(lines) and depth > 0:
+            line = lines[end_index].strip()
+            if line.startswith(f"{block_start} "):
+                depth += 1
+            elif line == self._column_list_syntax.end_delimiter:
+                depth -= 1
+            end_index += 1
+        if depth == 0:
+            return "\n".join(lines[start_index : end_index - 1])
+        return None
+
+    def _find_column_blocks(self, content: str) -> list[re.Match]:
+        return list(self._column_syntax.regex_pattern.finditer(content))
+
+    def _validate_minimum_columns(self, column_count: int) -> None:
+        if column_count < 2:
+            raise InsufficientColumnsError(column_count)
+
+    def _extract_ratios(self, column_matches: list[re.Match]) -> list[float]:
+        ratios = []
+        for match in column_matches:
+            ratio_str = match.group(1)
+            if ratio_str and ratio_str != "1":
+                ratios.append(float(ratio_str))
+        return ratios
+
+    def _validate_ratios(self, ratios: list[float], column_count: int) -> None:
+        if not ratios or len(ratios) != column_count:
+            return
+        total = sum(ratios)
+        if abs(total - 1.0) > RATIO_TOLERANCE:
+            raise InvalidColumnRatioSumError(total, RATIO_TOLERANCE)

notionary/page/content/parser/pre_processsing/handlers/port.py

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

notionary/page/content/parser/pre_processsing/handlers/whitespace.py

@@ -0,0 +1,68 @@
+from typing import override
+
+from notionary.page.content.parser.pre_processsing.handlers.port import PreProcessor
+
+
+class WhitespacePreProcessor(PreProcessor):
+    @override
+    def process(self, markdown_text: str) -> str:
+        if not markdown_text:
+            return ""
+
+        lines = markdown_text.split("\n")
+        processed_lines = []
+        code_block_lines = []
+        in_code_block = False
+
+        for line in lines:
+            if self._is_code_fence(line):
+                if in_code_block:
+                    processed_lines.extend(self._format_code_block(code_block_lines))
+                    processed_lines.append("```")
+                    code_block_lines = []
+                    in_code_block = False
+                else:
+                    language = self._extract_language(line)
+                    processed_lines.append(f"```{language}")
+                    in_code_block = True
+            elif in_code_block:
+                code_block_lines.append(line)
+            else:
+                processed_lines.append(line.lstrip())
+
+        return "\n".join(processed_lines)
+
+    def _is_code_fence(self, line: str) -> bool:
+        return line.lstrip().startswith("```")
+
+    def _extract_language(self, fence_line: str) -> str:
+        return fence_line.lstrip().removeprefix("```").strip()
+
+    def _format_code_block(self, lines: list[str]) -> list[str]:
+        """
+        Format code block by removing common leading whitespace.
+
+        Preserves relative indentation between lines.
+        Empty lines are preserved as-is.
+        """
+        if not lines:
+            return []
+
+        non_empty_lines = [line for line in lines if line.strip()]
+        if not non_empty_lines:
+            return ["" for _ in lines]
+
+        min_indent = min(self._count_leading_spaces(line) for line in non_empty_lines)
+
+        if min_indent == 0:
+            return lines
+
+        return [self._remove_indent(line, min_indent) for line in lines]
+
+    def _count_leading_spaces(self, line: str) -> int:
+        return len(line) - len(line.lstrip())
+
+    def _remove_indent(self, line: str, indent_size: int) -> str:
+        if not line.strip():
+            return ""
+        return line[indent_size:]

notionary/page/content/parser/pre_processsing/service.py

@@ -0,0 +1,15 @@
+from notionary.page.content.parser.pre_processsing.handlers.port import PreProcessor
+
+
+class MarkdownPreProcessor:
+    def __init__(self) -> None:
+        self._processors: list[PreProcessor] = []
+
+    def register(self, processor: PreProcessor) -> 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/parser/service.py

@@ -0,0 +1,69 @@
+from notionary.blocks.schemas import BlockCreatePayload
+from notionary.page.content.parser.parsers import (
+    BlockParsingContext,
+    ParentBlockContext,
+)
+from notionary.page.content.parser.parsers.base import LineParser
+from notionary.page.content.parser.post_processing.service import BlockPostProcessor
+from notionary.page.content.parser.pre_processsing.service import MarkdownPreProcessor
+from notionary.utils.mixins.logging import LoggingMixin
+
+
+class MarkdownToNotionConverter(LoggingMixin):
+    def __init__(
+        self, line_parser: LineParser, pre_processor: MarkdownPreProcessor, post_processor: BlockPostProcessor
+    ) -> None:
+        self._line_parser = line_parser
+        self._pre_processor = pre_processor
+        self._post_processor = post_processor
+
+    async def convert(self, markdown_text: str) -> list[BlockCreatePayload]:
+        if not markdown_text:
+            return []
+
+        markdown_text = self._pre_processor.process(markdown_text)
+        all_blocks = await self._process_lines(markdown_text)
+        all_blocks = self._post_processor.process(all_blocks)
+
+        return all_blocks
+
+    async def _process_lines(self, text: str) -> list[BlockCreatePayload]:
+        lines = text.split("\n")
+        result_blocks: list[BlockCreatePayload] = []
+        parent_stack: list[ParentBlockContext] = []
+
+        current_line_index = 0
+        while current_line_index < len(lines):
+            line = lines[current_line_index]
+
+            context = self._create_line_processing_context(
+                line=line,
+                lines=lines,
+                line_index=current_line_index,
+                result_blocks=result_blocks,
+                parent_stack=parent_stack,
+            )
+
+            await self._line_parser.handle(context)
+
+            current_line_index += 1 + context.lines_consumed
+
+        return result_blocks
+
+    def _create_line_processing_context(
+        self,
+        line: str,
+        lines: list[str],
+        line_index: int,
+        result_blocks: list[BlockCreatePayload],
+        parent_stack: list[ParentBlockContext],
+    ) -> BlockParsingContext:
+        return BlockParsingContext(
+            line=line,
+            result_blocks=result_blocks,
+            parent_stack=parent_stack,
+            parse_children_callback=self._process_lines,
+            all_lines=lines,
+            current_line_index=line_index,
+            lines_consumed=0,
+        )

notionary/page/content/renderer/context.py

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

notionary/page/content/renderer/factory.py

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

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

@@ -0,0 +1,5 @@
+from .numbered_list_placeholdere import NumberedListPlaceholderReplaceerPostProcessor
+
+__all__ = [
+    "NumberedListPlaceholderReplaceerPostProcessor",
+]