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

notionary/page/content/parser/parsers/table.py

@@ -0,0 +1,144 @@
+from typing import override
+
+from notionary.blocks.rich_text.markdown_rich_text_converter import MarkdownRichTextConverter
+from notionary.blocks.rich_text.models import RichText
+from notionary.blocks.schemas import CreateTableBlock, CreateTableData, CreateTableRowBlock, TableRowData
+from notionary.page.content.parser.parsers import BlockParsingContext, LineParser
+from notionary.page.content.syntax.service import SyntaxRegistry
+
+
+class TableParser(LineParser):
+    def __init__(self, syntax_registry: SyntaxRegistry, rich_text_converter: MarkdownRichTextConverter) -> None:
+        super().__init__(syntax_registry)
+        self._syntax = syntax_registry.get_table_syntax()
+        self._separator_syntax = syntax_registry.get_table_row_syntax()
+        self.rich_text_converter = rich_text_converter
+
+    @override
+    def _can_handle(self, context: BlockParsingContext) -> bool:
+        if context.is_inside_parent_context():
+            return False
+        return self._is_table_start(context)
+
+    @override
+    async def _process(self, context: BlockParsingContext) -> None:
+        if not self._is_table_start(context):
+            return
+
+        await self._process_complete_table(context)
+
+    def _is_table_start(self, context: BlockParsingContext) -> bool:
+        return self._syntax.regex_pattern.match(context.line) is not None
+
+    async def _process_complete_table(self, context: BlockParsingContext) -> None:
+        table_lines = [context.line]
+        remaining_lines = context.get_remaining_lines()
+        lines_consumed = self._collect_table_lines(table_lines, remaining_lines)
+
+        block = await self._create_table_block(table_lines)
+
+        if block:
+            context.lines_consumed = lines_consumed
+            context.result_blocks.append(block)
+
+    def _collect_table_lines(self, table_lines: list[str], remaining_lines: list[str]) -> int:
+        lines_consumed = 0
+
+        for index, line in enumerate(remaining_lines):
+            line_stripped = line.strip()
+
+            if not line_stripped:
+                table_lines.append(line)
+                continue
+
+            if self._is_table_line(line_stripped):
+                table_lines.append(line)
+            else:
+                lines_consumed = index
+                break
+        else:
+            lines_consumed = len(remaining_lines)
+
+        return lines_consumed
+
+    def _is_table_line(self, line: str) -> bool:
+        return self._syntax.regex_pattern.match(line) or self._separator_syntax.regex_pattern.match(line)
+
+    async def _create_table_block(self, table_lines: list[str]) -> CreateTableBlock | None:
+        if not table_lines:
+            return None
+
+        first_row = self._find_first_table_row(table_lines)
+        if not first_row:
+            return None
+
+        header_cells = self._parse_table_row(first_row)
+        column_count = len(header_cells)
+
+        table_rows, has_separator = await self._process_table_rows(table_lines)
+
+        table_data = CreateTableData(
+            table_width=column_count,
+            has_column_header=has_separator,
+            has_row_header=False,
+            children=table_rows,
+        )
+
+        return CreateTableBlock(table=table_data)
+
+    def _find_first_table_row(self, table_lines: list[str]) -> str | None:
+        for line in table_lines:
+            line_stripped = line.strip()
+            if line_stripped and self._syntax.regex_pattern.match(line_stripped):
+                return line_stripped
+        return None
+
+    async def _process_table_rows(self, table_lines: list[str]) -> tuple[list[CreateTableRowBlock], bool]:
+        table_rows = []
+        has_separator = False
+
+        for line in table_lines:
+            line_stripped = line.strip()
+
+            if not line_stripped:
+                continue
+
+            if self._is_separator_line(line_stripped):
+                has_separator = True
+                continue
+
+            if self._syntax.regex_pattern.match(line_stripped):
+                table_row = await self._create_table_row(line_stripped)
+                table_rows.append(table_row)
+
+        return table_rows, has_separator
+
+    def _is_separator_line(self, line: str) -> bool:
+        return self._separator_syntax.regex_pattern.match(line) is not None
+
+    async def _create_table_row(self, line: str) -> CreateTableRowBlock:
+        cells = self._parse_table_row(line)
+        rich_text_cells = await self._convert_cells_to_rich_text(cells)
+        table_row_data = TableRowData(cells=rich_text_cells)
+        return CreateTableRowBlock(table_row=table_row_data)
+
+    async def _convert_cells_to_rich_text(self, cells: list[str]) -> list[list[RichText]]:
+        rich_text_cells = []
+
+        for cell in cells:
+            rich_text = await self.rich_text_converter.to_rich_text(cell)
+            rich_text_cells.append(rich_text)
+
+        return rich_text_cells
+
+    def _parse_table_row(self, row_text: str) -> list[str]:
+        """Parse a table row by splitting on the table delimiter from SyntaxRegistry."""
+        row_content = row_text.strip()
+        delimiter = self._syntax.start_delimiter
+
+        if row_content.startswith(delimiter):
+            row_content = row_content[1:]
+        if row_content.endswith(delimiter):
+            row_content = row_content[:-1]
+
+        return row_content.split(delimiter)

notionary/page/content/parser/parsers/table_of_contents.py

@@ -0,0 +1,32 @@
+from typing import override
+
+from notionary.blocks.schemas import BlockColor, CreateTableOfContentsBlock, TableOfContentsData
+from notionary.page.content.parser.parsers.base import (
+    BlockParsingContext,
+    LineParser,
+)
+from notionary.page.content.syntax.service import SyntaxRegistry
+
+
+class TableOfContentsParser(LineParser):
+    def __init__(self, syntax_registry: SyntaxRegistry) -> None:
+        super().__init__(syntax_registry)
+        self._syntax = syntax_registry.get_table_of_contents_syntax()
+
+    @override
+    def _can_handle(self, context: BlockParsingContext) -> bool:
+        if context.is_inside_parent_context():
+            return False
+        return self._is_toc(context.line)
+
+    @override
+    async def _process(self, context: BlockParsingContext) -> None:
+        block = self._create_toc_block()
+        context.result_blocks.append(block)
+
+    def _is_toc(self, line: str) -> bool:
+        return self._syntax.regex_pattern.match(line) is not None
+
+    def _create_toc_block(self) -> CreateTableOfContentsBlock:
+        toc_data = TableOfContentsData(color=BlockColor.DEFAULT)
+        return CreateTableOfContentsBlock(table_of_contents=toc_data)

notionary/page/content/parser/parsers/todo.py

@@ -0,0 +1,58 @@
+"""Parser for todo/checkbox blocks."""
+
+from typing import override
+
+from notionary.blocks.rich_text.markdown_rich_text_converter import (
+    MarkdownRichTextConverter,
+)
+from notionary.blocks.schemas import BlockColor, CreateToDoBlock, ToDoData
+from notionary.page.content.parser.parsers.base import (
+    BlockParsingContext,
+    LineParser,
+)
+from notionary.page.content.syntax.service import SyntaxRegistry
+
+
+class TodoParser(LineParser):
+    def __init__(self, syntax_registry: SyntaxRegistry, rich_text_converter: MarkdownRichTextConverter) -> None:
+        super().__init__(syntax_registry)
+        self._syntax = syntax_registry.get_todo_syntax()
+        self._syntax_done = syntax_registry.get_todo_done_syntax()
+        self._rich_text_converter = rich_text_converter
+
+    @override
+    def _can_handle(self, context: BlockParsingContext) -> bool:
+        if context.is_inside_parent_context():
+            return False
+
+        return (
+            self._syntax.regex_pattern.match(context.line) is not None
+            or self._syntax_done.regex_pattern.match(context.line) is not None
+        )
+
+    @override
+    async def _process(self, context: BlockParsingContext) -> None:
+        block = await self._create_todo_block(context.line)
+        if block:
+            context.result_blocks.append(block)
+
+    async def _create_todo_block(self, text: str) -> CreateToDoBlock | None:
+        done_match = self._syntax_done.regex_pattern.match(text)
+        todo_match = None if done_match else self._syntax.regex_pattern.match(text)
+
+        if done_match:
+            content = done_match.group(1)
+            checked = True
+        elif todo_match:
+            content = todo_match.group(1)
+            checked = False
+        else:
+            return None
+
+        rich_text = await self._rich_text_converter.to_rich_text(content)
+        todo_content = ToDoData(
+            rich_text=rich_text,
+            checked=checked,
+            color=BlockColor.DEFAULT,
+        )
+        return CreateToDoBlock(to_do=todo_content)

notionary/page/content/parser/parsers/toggle.py

@@ -0,0 +1,127 @@
+from typing import override
+
+from notionary.blocks.rich_text.markdown_rich_text_converter import MarkdownRichTextConverter
+from notionary.blocks.schemas import BlockColor, CreateToggleBlock, CreateToggleData
+from notionary.page.content.parser.parsers import (
+    BlockParsingContext,
+    LineParser,
+    ParentBlockContext,
+)
+from notionary.page.content.syntax.service import SyntaxRegistry
+
+
+class ToggleParser(LineParser):
+    def __init__(self, syntax_registry: SyntaxRegistry, rich_text_converter: MarkdownRichTextConverter) -> None:
+        super().__init__(syntax_registry)
+        self._syntax = syntax_registry.get_toggle_syntax()
+        self._heading_syntax = syntax_registry.get_toggleable_heading_syntax()
+        self._rich_text_converter = rich_text_converter
+
+    @override
+    def _can_handle(self, context: BlockParsingContext) -> bool:
+        return self._is_toggle_start(context) or self._is_toggle_end(context) or self._is_toggle_content(context)
+
+    @override
+    async def _process(self, context: BlockParsingContext) -> None:
+        if self._is_toggle_start(context):
+            await self._start_toggle(context)
+
+        if self._is_toggle_end(context):
+            await self._finalize_toggle(context)
+
+        if self._is_toggle_content(context):
+            self._add_toggle_content(context)
+
+    def _is_toggle_start(self, context: BlockParsingContext) -> bool:
+        if not self._syntax.regex_pattern.match(context.line):
+            return False
+
+        # Exclude toggleable heading patterns to be more resilient to wrong order of chain
+        return not self.is_heading_start(context.line)
+
+    def is_heading_start(self, line: str) -> bool:
+        return self._heading_syntax.regex_pattern.match(line) is not None
+
+    def _is_toggle_end(self, context: BlockParsingContext) -> bool:
+        if not self._syntax.end_regex_pattern.match(context.line):
+            return False
+
+        if not context.parent_stack:
+            return False
+
+        current_parent = context.parent_stack[-1]
+        return isinstance(current_parent.block, CreateToggleBlock)
+
+    async def _start_toggle(self, context: BlockParsingContext) -> None:
+        block = await self._create_toggle_block(context.line)
+        if not block:
+            return
+
+        parent_context = ParentBlockContext(
+            block=block,
+            child_lines=[],
+        )
+        context.parent_stack.append(parent_context)
+
+    async def _create_toggle_block(self, line: str) -> CreateToggleBlock | None:
+        if not (match := self._syntax.regex_pattern.match(line)):
+            return None
+
+        title = match.group(1).strip()
+        rich_text = await self._rich_text_converter.to_rich_text(title)
+
+        toggle_content = CreateToggleData(rich_text=rich_text, color=BlockColor.DEFAULT, children=[])
+        return CreateToggleBlock(toggle=toggle_content)
+
+    async def _finalize_toggle(self, context: BlockParsingContext) -> None:
+        toggle_context = context.parent_stack.pop()
+        await self._assign_toggle_children_if_any(toggle_context, context)
+
+        if self._is_nested_in_other_parent_context(context):
+            self._assign_to_parent_context(context, toggle_context)
+        else:
+            context.result_blocks.append(toggle_context.block)
+
+    def _is_nested_in_other_parent_context(self, context: BlockParsingContext) -> bool:
+        return context.parent_stack
+
+    def _assign_to_parent_context(self, context: BlockParsingContext, toggle_context: ParentBlockContext) -> None:
+        parent_context = context.parent_stack[-1]
+        parent_context.add_child_block(toggle_context.block)
+
+    async def _assign_toggle_children_if_any(
+        self, toggle_context: ParentBlockContext, context: BlockParsingContext
+    ) -> None:
+        all_children = []
+
+        # Process text lines
+        if toggle_context.child_lines:
+            children_text = "\n".join(toggle_context.child_lines)
+            text_blocks = await self._parse_nested_content(children_text, context)
+            all_children.extend(text_blocks)
+
+        if toggle_context.child_blocks:
+            all_children.extend(toggle_context.child_blocks)
+
+        toggle_context.block.toggle.children = all_children
+
+    def _is_toggle_content(self, context: BlockParsingContext) -> bool:
+        if not context.parent_stack:
+            return False
+
+        current_parent = context.parent_stack[-1]
+        if not isinstance(current_parent.block, CreateToggleBlock):
+            return False
+
+        return not (
+            self._syntax.regex_pattern.match(context.line) or self._syntax.end_regex_pattern.match(context.line)
+        )
+
+    def _add_toggle_content(self, context: BlockParsingContext) -> None:
+        context.parent_stack[-1].add_child_line(context.line)
+
+    async def _parse_nested_content(self, text: str, context: BlockParsingContext) -> list:
+        if not text.strip():
+            return []
+
+        return await context.parse_nested_content(text)

notionary/page/content/parser/parsers/toggleable_heading.py

@@ -0,0 +1,150 @@
+from typing import override
+
+from notionary.blocks.rich_text.markdown_rich_text_converter import MarkdownRichTextConverter
+from notionary.blocks.schemas import (
+    BlockColor,
+    BlockCreatePayload,
+    BlockType,
+    CreateHeading1Block,
+    CreateHeading2Block,
+    CreateHeading3Block,
+    CreateHeadingBlock,
+    CreateHeadingData,
+)
+from notionary.page.content.parser.parsers import (
+    BlockParsingContext,
+    LineParser,
+    ParentBlockContext,
+)
+from notionary.page.content.syntax.service import SyntaxRegistry
+
+
+class ToggleableHeadingParser(LineParser):
+    MIN_HEADING_LEVEL = 1
+    MAX_HEADING_LEVEL = 3
+
+    HEADING_BLOCK_TYPES = (CreateHeading1Block, CreateHeading2Block, CreateHeading3Block)
+
+    def __init__(self, syntax_registry: SyntaxRegistry, rich_text_converter: MarkdownRichTextConverter) -> None:
+        super().__init__(syntax_registry)
+        self._syntax = syntax_registry.get_toggleable_heading_syntax()
+        self._rich_text_converter = rich_text_converter
+
+    @override
+    def _can_handle(self, context: BlockParsingContext) -> bool:
+        return self._is_heading_start(context) or self._is_heading_end(context) or self._is_heading_content(context)
+
+    @override
+    async def _process(self, context: BlockParsingContext) -> None:
+        if self._is_heading_start(context):
+            await self._start_toggleable_heading(context)
+        elif self._is_heading_end(context):
+            await self._finalize_toggleable_heading(context)
+        elif self._is_heading_content(context):
+            await self._add_heading_content(context)
+
+    def _is_heading_start(self, context: BlockParsingContext) -> bool:
+        return self._syntax.regex_pattern.match(context.line) is not None
+
+    def _is_heading_end(self, context: BlockParsingContext) -> bool:
+        if not self._syntax.end_regex_pattern.match(context.line):
+            return False
+        return self._has_heading_on_stack(context)
+
+    def _is_heading_content(self, context: BlockParsingContext) -> bool:
+        if not self._has_heading_on_stack(context):
+            return False
+
+        return not (
+            self._syntax.regex_pattern.match(context.line) or self._syntax.end_regex_pattern.match(context.line)
+        )
+
+    def _has_heading_on_stack(self, context: BlockParsingContext) -> bool:
+        if not context.parent_stack:
+            return False
+        current_parent = context.parent_stack[-1]
+        return isinstance(current_parent.block, self.HEADING_BLOCK_TYPES)
+
+    async def _start_toggleable_heading(self, context: BlockParsingContext) -> None:
+        block = await self._create_heading_block(context.line)
+        if not block:
+            return
+
+        parent_context = ParentBlockContext(
+            block=block,
+            child_lines=[],
+        )
+        context.parent_stack.append(parent_context)
+
+    async def _create_heading_block(self, line: str) -> CreateHeadingBlock | None:
+        match = self._syntax.regex_pattern.match(line)
+        if not match:
+            return None
+
+        level = len(match.group("level"))
+        content = match.group(2).strip()
+
+        if not self._is_valid_heading(level, content):
+            return None
+
+        heading_data = await self._build_heading_data(content)
+
+        if level == 1:
+            return CreateHeading1Block(heading_1=heading_data)
+        elif level == 2:
+            return CreateHeading2Block(heading_2=heading_data)
+        else:
+            return CreateHeading3Block(heading_3=heading_data)
+
+    def _is_valid_heading(self, level: int, content: str) -> bool:
+        return self.MIN_HEADING_LEVEL <= level <= self.MAX_HEADING_LEVEL and bool(content)
+
+    async def _build_heading_data(self, content: str) -> CreateHeadingData:
+        rich_text = await self._rich_text_converter.to_rich_text(content)
+        return CreateHeadingData(rich_text=rich_text, color=BlockColor.DEFAULT, is_toggleable=True, children=[])
+
+    async def _add_heading_content(self, context: BlockParsingContext) -> None:
+        context.parent_stack[-1].add_child_line(context.line)
+
+    async def _finalize_toggleable_heading(self, context: BlockParsingContext) -> None:
+        heading_context = context.parent_stack.pop()
+        await self._assign_children(heading_context, context)
+        self._add_to_parent_or_result(heading_context.block, context)
+
+    async def _assign_children(self, heading_context: ParentBlockContext, context: BlockParsingContext) -> None:
+        children = await self._collect_children(heading_context, context)
+        self._set_heading_children(heading_context.block, children)
+
+    async def _collect_children(
+        self, heading_context: ParentBlockContext, context: BlockParsingContext
+    ) -> list[BlockCreatePayload]:
+        children = []
+
+        if heading_context.child_lines:
+            text = "\n".join(heading_context.child_lines)
+            text_blocks = await self._parse_nested_content(text, context)
+            children.extend(text_blocks)
+
+        if heading_context.child_blocks:
+            children.extend(heading_context.child_blocks)
+
+        return children
+
+    def _set_heading_children(self, block: CreateHeadingBlock, children: list[BlockCreatePayload]) -> None:
+        if block.type == BlockType.HEADING_1:
+            block.heading_1.children = children
+        elif block.type == BlockType.HEADING_2:
+            block.heading_2.children = children
+        elif block.type == BlockType.HEADING_3:
+            block.heading_3.children = children
+
+    def _add_to_parent_or_result(self, block: CreateHeadingBlock, context: BlockParsingContext) -> None:
+        if context.parent_stack:
+            context.parent_stack[-1].add_child_block(block)
+        else:
+            context.result_blocks.append(block)
+
+    async def _parse_nested_content(self, text: str, context: BlockParsingContext) -> list:
+        if not text.strip():
+            return []
+        return await context.parse_nested_content(text)

notionary/page/content/parser/parsers/video.py

@@ -0,0 +1,42 @@
+"""Parser for video blocks."""
+
+from typing import override
+
+from notionary.blocks.schemas import (
+    CreateVideoBlock,
+    ExternalFile,
+    FileData,
+    FileType,
+)
+from notionary.page.content.parser.parsers.base import BlockParsingContext, LineParser
+from notionary.page.content.syntax.service import SyntaxRegistry
+
+
+class VideoParser(LineParser):
+    def __init__(self, syntax_registry: SyntaxRegistry) -> None:
+        super().__init__(syntax_registry)
+        self._syntax = syntax_registry.get_video_syntax()
+
+    @override
+    def _can_handle(self, context: BlockParsingContext) -> bool:
+        if context.is_inside_parent_context():
+            return False
+        return self._syntax.regex_pattern.search(context.line) is not None
+
+    @override
+    async def _process(self, context: BlockParsingContext) -> None:
+        url = self._extract_url(context.line)
+        if not url:
+            return
+
+        video_data = FileData(
+            type=FileType.EXTERNAL,
+            external=ExternalFile(url=url),
+            caption=[],
+        )
+        block = CreateVideoBlock(video=video_data)
+        context.result_blocks.append(block)
+
+    def _extract_url(self, line: str) -> str | None:
+        match = self._syntax.regex_pattern.search(line)
+        return match.group(1).strip() if match else None

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

@@ -0,0 +1,5 @@
+from .rich_text_length_truncation import RichTextLengthTruncationPostProcessor
+
+__all__ = [
+    "RichTextLengthTruncationPostProcessor",
+]

notionary/page/content/parser/post_processing/handlers/rich_text_length.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