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

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

@@ -0,0 +1,37 @@
+from typing import override
+
+from notionary.blocks.enums import BlockColor
+from notionary.blocks.rich_text.markdown_rich_text_converter import (
+    MarkdownRichTextConverter,
+)
+from notionary.blocks.schemas import CreateParagraphBlock, CreateParagraphData
+from notionary.page.content.parser.parsers.base import (
+    BlockParsingContext,
+    LineParser,
+)
+
+
+class ParagraphParser(LineParser):
+    def __init__(self, rich_text_converter: MarkdownRichTextConverter) -> None:
+        super().__init__()
+        self._rich_text_converter = rich_text_converter
+
+    @override
+    def _can_handle(self, context: BlockParsingContext) -> bool:
+        if context.is_inside_parent_context():
+            return False
+        return bool(context.line)
+
+    @override
+    async def _process(self, context: BlockParsingContext) -> None:
+        block = await self._create_paragraph_block(context.line)
+        if block:
+            context.result_blocks.append(block)
+
+    async def _create_paragraph_block(self, text: str) -> CreateParagraphBlock | None:
+        if not text:
+            return None
+
+        rich_text = await self._rich_text_converter.to_rich_text(text)
+        paragraph_content = CreateParagraphData(rich_text=rich_text, color=BlockColor.DEFAULT)
+        return CreateParagraphBlock(paragraph=paragraph_content)

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

@@ -0,0 +1,42 @@
+"""Parser for PDF blocks."""
+
+from typing import override
+
+from notionary.blocks.schemas import (
+    CreatePdfBlock,
+    ExternalFile,
+    FileData,
+    FileType,
+)
+from notionary.page.content.parser.parsers.base import BlockParsingContext, LineParser
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class PdfParser(LineParser):
+    def __init__(self, syntax_registry: SyntaxRegistry) -> None:
+        super().__init__(syntax_registry)
+        self._syntax = syntax_registry.get_pdf_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
+
+        pdf_data = FileData(
+            type=FileType.EXTERNAL,
+            external=ExternalFile(url=url),
+            caption=[],
+        )
+        block = CreatePdfBlock(pdf=pdf_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/parsers/quote.py

@@ -0,0 +1,125 @@
+from typing import override
+
+from notionary.blocks.rich_text.markdown_rich_text_converter import MarkdownRichTextConverter
+from notionary.blocks.schemas import BlockColor, CreateQuoteBlock, CreateQuoteData
+from notionary.page.content.parser.parsers.base import (
+    BlockParsingContext,
+    LineParser,
+)
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class QuoteParser(LineParser):
+    def __init__(self, syntax_registry: SyntaxRegistry, rich_text_converter: MarkdownRichTextConverter) -> None:
+        super().__init__(syntax_registry)
+        self._syntax = syntax_registry.get_quote_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_quote(context.line)
+
+    def _is_quote(self, line: str) -> bool:
+        return self._syntax.regex_pattern.match(line) is not None
+
+    @override
+    async def _process(self, context: BlockParsingContext) -> None:
+        quote_lines = self._collect_quote_lines(context)
+
+        block = await self._create_quote_block(quote_lines)
+        if not block:
+            return
+
+        # Lines consumed: all quote lines minus the current line (which is already being processed)
+        context.lines_consumed = len(quote_lines) - 1
+
+        await self._process_nested_children(block, context, quote_lines)
+        context.result_blocks.append(block)
+
+    def _collect_quote_lines(self, context: BlockParsingContext) -> list[str]:
+        quote_lines = [context.line]
+        for line in context.get_remaining_lines():
+            if not self._is_quote(line):
+                break
+            quote_lines.append(line)
+        return quote_lines
+
+    async def _process_nested_children(
+        self, block: CreateQuoteBlock, context: BlockParsingContext, quote_lines: list[str]
+    ) -> None:
+        # Calculate indent level after all quote lines
+        last_quote_line_index = len(quote_lines) - 1
+        child_lines = self._collect_child_lines_after_quote(context, last_quote_line_index)
+
+        if not child_lines:
+            return
+
+        child_blocks = await self._parse_child_blocks(child_lines, context)
+        if child_blocks:
+            block.quote.children = child_blocks
+
+        context.lines_consumed += len(child_lines)
+
+    def _collect_child_lines_after_quote(self, context: BlockParsingContext, last_quote_index: int) -> list[str]:
+        """Collect indented children after the quote block."""
+        parent_indent_level = context.get_line_indentation_level()
+        remaining_lines = context.get_remaining_lines()
+
+        # Skip the quote lines we already processed
+        lines_after_quote = remaining_lines[last_quote_index:]
+
+        child_lines = []
+        expected_child_indent = parent_indent_level + 1
+
+        for line in lines_after_quote:
+            if not line.strip():
+                child_lines.append(line)
+                continue
+
+            line_indent = context.get_line_indentation_level(line)
+            if line_indent >= expected_child_indent:
+                child_lines.append(line)
+            else:
+                break
+
+        return child_lines
+
+    async def _parse_child_blocks(self, child_lines: list[str], context: BlockParsingContext) -> list[CreateQuoteBlock]:
+        stripped_lines = self._remove_parent_indentation(child_lines, context)
+        children_text = self._convert_lines_to_text(stripped_lines)
+        return await context.parse_nested_markdown(children_text)
+
+    def _remove_parent_indentation(self, lines: list[str], context: BlockParsingContext) -> list[str]:
+        return context.strip_indentation_level(lines, levels=1)
+
+    def _convert_lines_to_text(self, lines: list[str]) -> str:
+        return "\n".join(lines)
+
+    async def _create_quote_block(self, quote_lines: list[str]) -> CreateQuoteBlock | None:
+        contents = self._extract_quote_contents(quote_lines)
+        if not contents:
+            return None
+
+        content = self._join_contents_for_multiline_quote(contents)
+        rich_text = await self._convert_to_rich_text(content)
+        return self._build_block(rich_text)
+
+    def _extract_quote_contents(self, quote_lines: list[str]) -> list[str]:
+        contents = []
+        for line in quote_lines:
+            match = self._syntax.regex_pattern.match(line)
+            if match:
+                contents.append(match.group(1).strip())
+        return contents
+
+    def _join_contents_for_multiline_quote(self, contents: list[str]) -> str:
+        return "\n".join(contents)
+
+    async def _convert_to_rich_text(self, content: str):
+        return await self._rich_text_converter.to_rich_text(content)
+
+    def _build_block(self, rich_text) -> CreateQuoteBlock:
+        quote_data = CreateQuoteData(rich_text=rich_text, color=BlockColor.DEFAULT)
+        return CreateQuoteBlock(quote=quote_data)

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

@@ -0,0 +1,41 @@
+from typing import override
+
+from notionary.blocks.enums import BlockColor
+from notionary.blocks.schemas import CreateParagraphBlock, CreateParagraphData
+from notionary.page.content.parser.parsers.base import (
+    BlockParsingContext,
+    LineParser,
+)
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class SpaceParser(LineParser):
+    def __init__(self, syntax_registry: SyntaxRegistry) -> None:
+        super().__init__(syntax_registry)
+        self._syntax = syntax_registry.get_space_syntax()
+
+    @override
+    def _can_handle(self, context: BlockParsingContext) -> bool:
+        if context.is_inside_parent_context():
+            return False
+
+        if self._is_explicit_space_marker(context):
+            return True
+
+        return self._is_second_consecutive_empty_line(context)
+
+    def _is_explicit_space_marker(self, context: BlockParsingContext) -> bool:
+        return self._syntax.regex_pattern.match(context.line.strip()) is not None
+
+    def _is_second_consecutive_empty_line(self, context: BlockParsingContext) -> bool:
+        return context.line.strip() == "" and context.is_previous_line_empty
+
+    @override
+    async def _process(self, context: BlockParsingContext) -> None:
+        block = self._create_space_block()
+        if block:
+            context.result_blocks.append(block)
+
+    def _create_space_block(self) -> CreateParagraphBlock:
+        paragraph_data = CreateParagraphData(rich_text=[], color=BlockColor.DEFAULT)
+        return CreateParagraphBlock(paragraph=paragraph_data)

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 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 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,96 @@
+from typing import override
+
+from notionary.blocks.rich_text.markdown_rich_text_converter import (
+    MarkdownRichTextConverter,
+)
+from notionary.blocks.schemas import BlockColor, CreateToDoBlock, CreateToDoData
+from notionary.page.content.parser.parsers.base import (
+    BlockParsingContext,
+    LineParser,
+)
+from notionary.page.content.syntax 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._is_todo_line(context.line)
+
+    def _is_todo_line(self, line: str) -> bool:
+        return (
+            self._syntax.regex_pattern.match(line) is not None
+            or self._syntax_done.regex_pattern.match(line) is not None
+        )
+
+    @override
+    async def _process(self, context: BlockParsingContext) -> None:
+        block = await self._create_todo_block(context.line)
+        if not block:
+            return
+
+        await self._process_nested_children(block, context)
+        context.result_blocks.append(block)
+
+    async def _process_nested_children(self, block: CreateToDoBlock, context: BlockParsingContext) -> None:
+        child_lines = self._collect_child_lines(context)
+        if not child_lines:
+            return
+
+        child_blocks = await self._parse_child_blocks(child_lines, context)
+        if child_blocks:
+            block.to_do.children = child_blocks
+
+        context.lines_consumed = len(child_lines)
+
+    def _collect_child_lines(self, context: BlockParsingContext) -> list[str]:
+        parent_indent_level = context.get_line_indentation_level()
+        return context.collect_indented_child_lines(parent_indent_level)
+
+    async def _parse_child_blocks(self, child_lines: list[str], context: BlockParsingContext) -> list[CreateToDoBlock]:
+        stripped_lines = self._remove_parent_indentation(child_lines, context)
+        children_text = self._convert_lines_to_text(stripped_lines)
+        return await context.parse_nested_markdown(children_text)
+
+    def _remove_parent_indentation(self, lines: list[str], context: BlockParsingContext) -> list[str]:
+        return context.strip_indentation_level(lines, levels=1)
+
+    def _convert_lines_to_text(self, lines: list[str]) -> str:
+        return "\n".join(lines)
+
+    async def _create_todo_block(self, text: str) -> CreateToDoBlock | None:
+        content, checked = self._extract_todo_content(text)
+        if content is None:
+            return None
+
+        rich_text = await self._convert_to_rich_text(content)
+        return self._build_block(rich_text, checked)
+
+    def _extract_todo_content(self, text: str) -> tuple[str | None, bool]:
+        done_match = self._syntax_done.regex_pattern.match(text)
+        if done_match:
+            return done_match.group(1), True
+
+        todo_match = self._syntax.regex_pattern.match(text)
+        if todo_match:
+            return todo_match.group(1), False
+
+        return None, False
+
+    async def _convert_to_rich_text(self, content: str):
+        return await self._rich_text_converter.to_rich_text(content)
+
+    def _build_block(self, rich_text, checked: bool) -> CreateToDoBlock:
+        todo_content = CreateToDoData(
+            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,70 @@
+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,
+)
+from notionary.page.content.syntax 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)
+
+    @override
+    async def _process(self, context: BlockParsingContext) -> None:
+        if self._is_toggle_start(context):
+            await self._process_toggle(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
+
+    async def _process_toggle(self, context: BlockParsingContext) -> None:
+        block = await self._create_toggle_block(context.line)
+        if not block:
+            return
+
+        await self._process_nested_children(block, context)
+
+        context.result_blocks.append(block)
+
+    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 _process_nested_children(self, block: CreateToggleBlock, context: BlockParsingContext) -> None:
+        parent_indent_level = context.get_line_indentation_level()
+        child_lines = context.collect_indented_child_lines(parent_indent_level)
+
+        if not child_lines:
+            return
+
+        stripped_lines = context.strip_indentation_level(child_lines, levels=1)
+        child_markdown = "\n".join(stripped_lines)
+
+        child_blocks = await context.parse_nested_markdown(child_markdown)
+        block.toggle.children = child_blocks
+
+        context.lines_consumed = len(child_lines)

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 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",
+]