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

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

@@ -0,0 +1,81 @@
+import re
+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 CodeData, CodingLanguage, CreateCodeBlock
+from notionary.page.content.parser.parsers.base import BlockParsingContext, LineParser
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class CodeParser(LineParser):
+    DEFAULT_LANGUAGE = CodingLanguage.PLAIN_TEXT
+
+    def __init__(self, syntax_registry: SyntaxRegistry, rich_text_converter: MarkdownRichTextConverter) -> None:
+        super().__init__(syntax_registry)
+        self._syntax = syntax_registry.get_code_syntax()
+        self._rich_text_converter = rich_text_converter
+        self._code_start_pattern = self._syntax.regex_pattern
+        self._code_end_pattern = self._syntax.end_regex_pattern or re.compile(r"^```\s*$")
+
+    @override
+    def _can_handle(self, context: BlockParsingContext) -> bool:
+        if context.is_inside_parent_context():
+            return False
+        return self._is_code_fence_start(context.line)
+
+    @override
+    async def _process(self, context: BlockParsingContext) -> None:
+        code_lines = self._collect_code_lines(context)
+        lines_consumed = self._count_lines_consumed(context)
+
+        block = await self._create_code_block(opening_line=context.line, code_lines=code_lines)
+        if not block:
+            return
+
+        context.lines_consumed = lines_consumed
+        context.result_blocks.append(block)
+
+    def _is_code_fence_start(self, line: str) -> bool:
+        return self._code_start_pattern.match(line) is not None
+
+    def _is_code_fence_end(self, line: str) -> bool:
+        return self._code_end_pattern.match(line) is not None
+
+    def _collect_code_lines(self, context: BlockParsingContext) -> list[str]:
+        code_lines = []
+        for line in context.get_remaining_lines():
+            if self._is_code_fence_end(line):
+                break
+            code_lines.append(line)
+        return code_lines
+
+    def _count_lines_consumed(self, context: BlockParsingContext) -> int:
+        for line_index, line in enumerate(context.get_remaining_lines()):
+            if self._is_code_fence_end(line):
+                return line_index + 1
+        return len(context.get_remaining_lines())
+
+    async def _create_code_block(self, opening_line: str, code_lines: list[str]) -> CreateCodeBlock | None:
+        match = self._code_start_pattern.match(opening_line)
+        if not match:
+            return None
+
+        language = self._parse_language(match.group(1))
+        rich_text = await self._create_rich_text_from_code(code_lines)
+
+        code_data = CodeData(rich_text=rich_text, language=language, caption=[])
+        return CreateCodeBlock(code=code_data)
+
+    def _parse_language(self, language_str: str | None) -> CodingLanguage:
+        return CodingLanguage.from_string(language_str, default=self.DEFAULT_LANGUAGE)
+
+    async def _create_rich_text_from_code(self, code_lines: list[str]) -> list[RichText]:
+        content = "\n".join(code_lines) if code_lines else ""
+        return await self._rich_text_converter.to_rich_text(content)
+
+    def _is_code_fence_start(self, line: str) -> bool:
+        return self._code_start_pattern.match(line) is not None
+
+    def _is_code_fence_end(self, line: str) -> bool:
+        return self._code_end_pattern.match(line) is not None

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

@@ -0,0 +1,76 @@
+from typing import override
+
+from notionary.blocks.schemas import CreateColumnBlock, CreateColumnData
+from notionary.page.content.parser.parsers.base import (
+    BlockParsingContext,
+    LineParser,
+)
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class ColumnParser(LineParser):
+    MIN_WIDTH_RATIO = 0
+    MAX_WIDTH_RATIO = 1.0
+
+    def __init__(self, syntax_registry: SyntaxRegistry) -> None:
+        super().__init__(syntax_registry)
+        self._syntax = syntax_registry.get_column_syntax()
+
+    @override
+    def _can_handle(self, context: BlockParsingContext) -> bool:
+        return self._is_column_start(context)
+
+    @override
+    async def _process(self, context: BlockParsingContext) -> None:
+        if self._is_column_start(context):
+            await self._process_column(context)
+
+    def _is_column_start(self, context: BlockParsingContext) -> bool:
+        return self._syntax.regex_pattern.match(context.line) is not None
+
+    async def _process_column(self, context: BlockParsingContext) -> None:
+        block = self._create_column_block(context.line)
+        if not block:
+            return
+
+        await self._populate_children(block, context)
+        context.result_blocks.append(block)
+
+    def _create_column_block(self, line: str) -> CreateColumnBlock | None:
+        match = self._syntax.regex_pattern.match(line)
+        if not match:
+            return None
+
+        width_ratio = self._parse_width_ratio(match.group(1))
+        column_data = CreateColumnData(width_ratio=width_ratio, children=[])
+
+        return CreateColumnBlock(column=column_data)
+
+    def _parse_width_ratio(self, ratio_str: str | None) -> float | None:
+        if not ratio_str:
+            return None
+
+        try:
+            width_ratio = float(ratio_str)
+            return width_ratio if self._is_valid_width_ratio(width_ratio) else None
+        except ValueError:
+            return None
+
+    def _is_valid_width_ratio(self, width_ratio: float) -> bool:
+        return self.MIN_WIDTH_RATIO < width_ratio <= self.MAX_WIDTH_RATIO
+
+    async def _populate_children(self, block: CreateColumnBlock, 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
+
+        child_blocks = await self._parse_indented_children(child_lines, context)
+        block.column.children = child_blocks
+        context.lines_consumed = len(child_lines)
+
+    async def _parse_indented_children(self, child_lines: list[str], context: BlockParsingContext) -> list:
+        stripped_lines = context.strip_indentation_level(child_lines, levels=1)
+        child_markdown = "\n".join(stripped_lines)
+        return await context.parse_nested_markdown(child_markdown)

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

@@ -0,0 +1,81 @@
+from typing import override
+
+from notionary.blocks.enums import BlockType
+from notionary.blocks.schemas import BlockCreatePayload, CreateColumnListBlock, CreateColumnListData
+from notionary.page.content.parser.parsers.base import (
+    BlockParsingContext,
+    LineParser,
+)
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class ColumnListParser(LineParser):
+    def __init__(self, syntax_registry: SyntaxRegistry) -> None:
+        super().__init__(syntax_registry)
+        self._syntax = syntax_registry.get_column_list_syntax()
+
+    @override
+    def _can_handle(self, context: BlockParsingContext) -> bool:
+        return self._is_column_list_start(context)
+
+    @override
+    async def _process(self, context: BlockParsingContext) -> None:
+        if self._is_column_list_start(context):
+            await self._process_column_list(context)
+
+    def _is_column_list_start(self, context: BlockParsingContext) -> bool:
+        return self._syntax.regex_pattern.match(context.line) is not None
+
+    async def _process_column_list(self, context: BlockParsingContext) -> None:
+        block = self._create_column_list_block()
+        await self._populate_columns(block, context)
+        context.result_blocks.append(block)
+
+    def _create_column_list_block(self) -> CreateColumnListBlock:
+        column_list_data = CreateColumnListData(children=[])
+        return CreateColumnListBlock(column_list=column_list_data)
+
+    async def _populate_columns(self, block: CreateColumnListBlock, context: BlockParsingContext) -> None:
+        parent_indent_level = context.get_line_indentation_level()
+        child_lines = self._collect_children_allowing_empty_lines(context, parent_indent_level)
+
+        if not child_lines:
+            return
+
+        column_blocks = await self._parse_column_children(child_lines, context)
+        block.column_list.children = column_blocks
+        context.lines_consumed = len(child_lines)
+
+    async def _parse_column_children(self, child_lines: list[str], context: BlockParsingContext) -> list:
+        stripped_lines = context.strip_indentation_level(child_lines, levels=1)
+        child_markdown = "\n".join(stripped_lines)
+        parsed_blocks = await context.parse_nested_markdown(child_markdown)
+        return self._extract_column_blocks(parsed_blocks)
+
+    def _collect_children_allowing_empty_lines(
+        self, context: BlockParsingContext, parent_indent_level: int
+    ) -> list[str]:
+        child_lines = []
+        expected_child_indent = parent_indent_level + 1
+        remaining_lines = context.get_remaining_lines()
+
+        for line in remaining_lines:
+            if self._should_include_as_child(line, expected_child_indent, context):
+                child_lines.append(line)
+            else:
+                break
+
+        return child_lines
+
+    def _should_include_as_child(self, line: str, expected_indent: int, context: BlockParsingContext) -> bool:
+        if not line.strip():
+            return True
+
+        line_indent = context.get_line_indentation_level(line)
+        return line_indent >= expected_indent
+
+    def _extract_column_blocks(self, blocks: list[BlockCreatePayload]) -> list:
+        return [block for block in blocks if self._is_valid_column_block(block)]
+
+    def _is_valid_column_block(self, block: BlockCreatePayload) -> bool:
+        return block.type == BlockType.COLUMN and block.column is not None

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

@@ -0,0 +1,33 @@
+from typing import override
+
+from notionary.blocks.schemas import CreateDividerBlock, DividerData
+from notionary.page.content.parser.parsers.base import (
+    BlockParsingContext,
+    LineParser,
+)
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class DividerParser(LineParser):
+    def __init__(self, syntax_registry: SyntaxRegistry) -> None:
+        super().__init__(syntax_registry)
+        self._syntax = syntax_registry.get_divider_syntax()
+
+    @override
+    def _can_handle(self, context: BlockParsingContext) -> bool:
+        if context.is_inside_parent_context():
+            return False
+        return self._is_divider(context.line)
+
+    @override
+    async def _process(self, context: BlockParsingContext) -> None:
+        block = self._create_divider_block()
+        if block:
+            context.result_blocks.append(block)
+
+    def _is_divider(self, line: str) -> bool:
+        return self._syntax.regex_pattern.match(line) is not None
+
+    def _create_divider_block(self) -> CreateDividerBlock:
+        divider_data = DividerData()
+        return CreateDividerBlock(divider=divider_data)

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

@@ -0,0 +1,33 @@
+"""Parser for embed blocks."""
+
+from typing import override
+
+from notionary.blocks.schemas import CreateEmbedBlock, EmbedData
+from notionary.page.content.parser.parsers.base import BlockParsingContext, LineParser
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class EmbedParser(LineParser):
+    def __init__(self, syntax_registry: SyntaxRegistry) -> None:
+        super().__init__(syntax_registry)
+        self._syntax = syntax_registry.get_embed_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
+
+        embed_data = EmbedData(url=url, caption=[])
+        block = CreateEmbedBlock(embed=embed_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) if match else None

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

@@ -0,0 +1,65 @@
+from typing import override
+
+from notionary.blocks.schemas import CreateEquationBlock, EquationData
+from notionary.page.content.parser.parsers.base import (
+    BlockParsingContext,
+    LineParser,
+)
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class EquationParser(LineParser):
+    def __init__(self, syntax_registry: SyntaxRegistry) -> None:
+        super().__init__(syntax_registry)
+        self._syntax = syntax_registry.get_equation_syntax()
+
+    @override
+    def _can_handle(self, context: BlockParsingContext) -> bool:
+        if context.is_inside_parent_context():
+            return False
+        return self._is_equation_delimiter(context.line)
+
+    @override
+    async def _process(self, context: BlockParsingContext) -> None:
+        equation_content = self._collect_equation_content(context)
+        lines_consumed = self._count_lines_consumed(context)
+
+        block = self._create_equation_block(opening_line=context.line, equation_lines=equation_content)
+
+        if block:
+            context.lines_consumed = lines_consumed
+            context.result_blocks.append(block)
+
+    def _is_equation_delimiter(self, line: str) -> bool:
+        return self._syntax.regex_pattern.match(line) is not None
+
+    def _collect_equation_content(self, context: BlockParsingContext) -> list[str]:
+        content_lines = []
+
+        for line in context.get_remaining_lines():
+            if self._is_equation_delimiter(line):
+                break
+            content_lines.append(line)
+
+        return content_lines
+
+    def _count_lines_consumed(self, context: BlockParsingContext) -> int:
+        for line_index, line in enumerate(context.get_remaining_lines()):
+            if self._is_equation_delimiter(line):
+                return line_index + 1
+
+        return len(context.get_remaining_lines())
+
+    def _create_equation_block(self, opening_line: str, equation_lines: list[str]) -> CreateEquationBlock | None:
+        if opening_line.strip() != self._syntax.start_delimiter:
+            return None
+
+        if not equation_lines:
+            return None
+
+        expression = "\n".join(equation_lines).strip()
+
+        if expression:
+            return CreateEquationBlock(equation=EquationData(expression=expression))
+
+        return None

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

@@ -0,0 +1,42 @@
+"""Parser for file blocks."""
+
+from typing import override
+
+from notionary.blocks.schemas import (
+    CreateFileBlock,
+    ExternalFile,
+    FileData,
+    FileType,
+)
+from notionary.page.content.parser.parsers.base import BlockParsingContext, LineParser
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class FileParser(LineParser):
+    def __init__(self, syntax_registry: SyntaxRegistry) -> None:
+        super().__init__(syntax_registry)
+        self._syntax = syntax_registry.get_file_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
+
+        file_data = FileData(
+            type=FileType.EXTERNAL,
+            external=ExternalFile(url=url),
+            caption=[],
+        )
+        block = CreateFileBlock(file=file_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/heading.py

@@ -0,0 +1,115 @@
+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.base import (
+    BlockParsingContext,
+    LineParser,
+)
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class HeadingParser(LineParser):
+    MIN_HEADING_LEVEL = 1
+    MAX_HEADING_LEVEL = 3
+
+    def __init__(self, syntax_registry: SyntaxRegistry, rich_text_converter: MarkdownRichTextConverter) -> None:
+        super().__init__(syntax_registry)
+        self._syntax = syntax_registry.get_heading_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
+
+    @override
+    async def _process(self, context: BlockParsingContext) -> None:
+        block = await self._create_heading_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: CreateHeadingBlock, 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
+
+        child_lines = self._remove_trailing_empty_lines(child_lines)
+
+        if not child_lines:
+            return
+
+        self._set_heading_toggleable(block, True)
+
+        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)
+        self._set_heading_children(block, child_blocks)
+
+        context.lines_consumed = len(child_lines)
+
+    def _set_heading_toggleable(self, block: CreateHeadingBlock, is_toggleable: bool) -> None:
+        if block.type == BlockType.HEADING_1:
+            block.heading_1.is_toggleable = is_toggleable
+        elif block.type == BlockType.HEADING_2:
+            block.heading_2.is_toggleable = is_toggleable
+        elif block.type == BlockType.HEADING_3:
+            block.heading_3.is_toggleable = is_toggleable
+
+    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 _remove_trailing_empty_lines(self, lines: list[str]) -> list[str]:
+        while lines and not lines[-1].strip():
+            lines.pop()
+        return lines
+
+    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(1))
+        content = match.group(2).strip()
+
+        if not self._is_valid_heading(level, content):
+            return None
+
+        heading_data = await self._build_heading_data(content)
+        return self._create_heading_block_by_level(level, 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=False, children=[])
+
+    def _create_heading_block_by_level(self, level: int, heading_data: CreateHeadingData) -> CreateHeadingBlock:
+        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)

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

@@ -0,0 +1,42 @@
+"""Parser for image blocks."""
+
+from typing import override
+
+from notionary.blocks.schemas import (
+    CreateImageBlock,
+    ExternalFile,
+    FileData,
+    FileType,
+)
+from notionary.page.content.parser.parsers.base import BlockParsingContext, LineParser
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class ImageParser(LineParser):
+    def __init__(self, syntax_registry: SyntaxRegistry) -> None:
+        super().__init__(syntax_registry)
+        self._syntax = syntax_registry.get_image_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
+
+        image_data = FileData(
+            type=FileType.EXTERNAL,
+            external=ExternalFile(url=url),
+            caption=[],
+        )
+        block = CreateImageBlock(image=image_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/numbered_list.py

@@ -0,0 +1,89 @@
+from typing import override
+
+from notionary.blocks.rich_text.markdown_rich_text_converter import (
+    MarkdownRichTextConverter,
+)
+from notionary.blocks.schemas import (
+    BlockColor,
+    CreateNumberedListItemBlock,
+    CreateNumberedListItemData,
+)
+from notionary.page.content.parser.parsers.base import (
+    BlockParsingContext,
+    LineParser,
+)
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class NumberedListParser(LineParser):
+    def __init__(self, syntax_registry: SyntaxRegistry, rich_text_converter: MarkdownRichTextConverter) -> None:
+        super().__init__(syntax_registry)
+        self._syntax = syntax_registry.get_numbered_list_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_numbered_list_line(context.line)
+
+    def _is_numbered_list_line(self, line: str) -> bool:
+        return self._syntax.regex_pattern.match(line) is not None
+
+    @override
+    async def _process(self, context: BlockParsingContext) -> None:
+        block = await self._create_numbered_list_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: CreateNumberedListItemBlock, 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.numbered_list_item.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[CreateNumberedListItemBlock]:
+        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_numbered_list_block(self, text: str) -> CreateNumberedListItemBlock | None:
+        content = self._extract_list_content(text)
+        if content is None:
+            return None
+
+        rich_text = await self._convert_to_rich_text(content)
+        return self._build_block(rich_text)
+
+    def _extract_list_content(self, text: str) -> str | None:
+        match = self._syntax.regex_pattern.match(text)
+        if not match:
+            return None
+        return match.group(3)
+
+    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) -> CreateNumberedListItemBlock:
+        numbered_list_content = CreateNumberedListItemData(rich_text=rich_text, color=BlockColor.DEFAULT)
+        return CreateNumberedListItemBlock(numbered_list_item=numbered_list_content)