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

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.context import ParentBlockContext
+from notionary.page.content.parser.parsers.base import (
+    BlockParsingContext,
+    LineParser,
+)
+from notionary.page.content.syntax.service 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) or self._is_column_list_end(context)
+
+    @override
+    async def _process(self, context: BlockParsingContext) -> None:
+        if self._is_column_list_start(context):
+            await self._start_column_list(context)
+        elif self._is_column_list_end(context):
+            await self._finalize_column_list(context)
+
+    def _is_column_list_start(self, context: BlockParsingContext) -> bool:
+        return self._syntax.regex_pattern.match(context.line) is not None
+
+    def _is_column_list_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, CreateColumnListBlock)
+
+    async def _start_column_list(self, context: BlockParsingContext) -> None:
+        column_list_data = CreateColumnListData()
+        block = CreateColumnListBlock(column_list=column_list_data)
+
+        parent_context = ParentBlockContext(
+            block=block,
+            child_lines=[],
+        )
+        context.parent_stack.append(parent_context)
+
+    async def _finalize_column_list(self, context: BlockParsingContext) -> None:
+        column_list_context = context.parent_stack.pop()
+        await self._assign_column_list_children(column_list_context, context)
+
+        if context.parent_stack:
+            parent_context = context.parent_stack[-1]
+            parent_context.add_child_block(column_list_context.block)
+        else:
+            context.result_blocks.append(column_list_context.block)
+
+    async def _assign_column_list_children(
+        self, column_list_context: ParentBlockContext, context: BlockParsingContext
+    ) -> None:
+        all_children = []
+
+        if column_list_context.child_lines:
+            children_text = "\n".join(column_list_context.child_lines)
+            text_blocks = await context.parse_nested_content(children_text)
+            all_children.extend(text_blocks)
+
+        if column_list_context.child_blocks:
+            all_children.extend(column_list_context.child_blocks)
+
+        column_children = self._filter_column_blocks(all_children)
+        column_list_context.block.column_list.children = column_children
+
+    def _filter_column_blocks(self, blocks: list[BlockCreatePayload]) -> list:
+        return [
+            block for block in blocks if block.type == BlockType.COLUMN and hasattr(block, "column") and block.column
+        ]

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.service 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.service 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.service 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.service 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,58 @@
+from typing import override
+
+from notionary.blocks.rich_text.markdown_rich_text_converter import MarkdownRichTextConverter
+from notionary.blocks.schemas import (
+    BlockColor,
+    CreateHeading1Block,
+    CreateHeading2Block,
+    CreateHeading3Block,
+    CreateHeadingBlock,
+    CreateHeadingData,
+)
+from notionary.page.content.parser.parsers.base import (
+    BlockParsingContext,
+    LineParser,
+)
+from notionary.page.content.syntax.service import SyntaxRegistry
+
+
+class HeadingParser(LineParser):
+    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 block:
+            context.result_blocks.append(block)
+
+    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))
+        if level < 1 or level > 3:
+            return None
+
+        content = match.group(2).strip()
+        if not content:
+            return None
+
+        rich_text = await self._rich_text_converter.to_rich_text(content)
+        heading_data = CreateHeadingData(rich_text=rich_text, color=BlockColor.DEFAULT, is_toggleable=False)
+
+        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.service 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,45 @@
+from typing import override
+
+from notionary.blocks.rich_text.markdown_rich_text_converter import (
+    MarkdownRichTextConverter,
+)
+from notionary.blocks.schemas import (
+    BlockColor,
+    CreateNumberedListItemBlock,
+    NumberedListItemData,
+)
+from notionary.page.content.parser.parsers.base import (
+    BlockParsingContext,
+    LineParser,
+)
+from notionary.page.content.syntax.service 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._syntax.regex_pattern.match(context.line) is not None
+
+    @override
+    async def _process(self, context: BlockParsingContext) -> None:
+        block = await self._create_numbered_list_block(context.line)
+        if block:
+            context.result_blocks.append(block)
+
+    async def _create_numbered_list_block(self, text: str) -> CreateNumberedListItemBlock | None:
+        match = self._syntax.regex_pattern.match(text)
+        if not match:
+            return None
+
+        content = match.group(3)
+        rich_text = await self._rich_text_converter.to_rich_text(content)
+
+        numbered_list_content = NumberedListItemData(rich_text=rich_text, color=BlockColor.DEFAULT)
+        return CreateNumberedListItemBlock(numbered_list_item=numbered_list_content)

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

@@ -0,0 +1,36 @@
+from typing import override
+
+from notionary.blocks.rich_text.markdown_rich_text_converter import (
+    MarkdownRichTextConverter,
+)
+from notionary.blocks.schemas import BlockColor, CreateParagraphBlock, ParagraphData
+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 = ParagraphData(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.service 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,65 @@
+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.service 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)
+
+    @override
+    async def _process(self, context: BlockParsingContext) -> None:
+        quote_lines = self._collect_quote_lines(context)
+        lines_consumed = len(quote_lines)
+
+        block = await self._create_quote_block(quote_lines)
+        if block:
+            context.result_blocks.append(block)
+            context.lines_consumed = lines_consumed
+
+    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
+
+    def _is_quote(self, line: str) -> bool:
+        return self._syntax.regex_pattern.match(line) is not None
+
+    async def _create_quote_block(self, quote_lines: list[str]) -> CreateQuoteBlock | None:
+        if not quote_lines:
+            return None
+
+        contents = []
+        for line in quote_lines:
+            match = self._syntax.regex_pattern.match(line)
+            if match:
+                contents.append(match.group(1).strip())
+
+        if not contents:
+            return None
+
+        content = self._join_contents_for_multiline_quote(contents)
+
+        rich_text = await self._rich_text_converter.to_rich_text(content)
+        quote_data = CreateQuoteData(rich_text=rich_text, color=BlockColor.DEFAULT)
+        return CreateQuoteBlock(quote=quote_data)
+
+    def _join_contents_for_multiline_quote(self, contents: list[str]) -> str:
+        return "\n".join(contents)

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

@@ -0,0 +1,35 @@
+from typing import override
+
+from notionary.blocks.schemas import BlockColor, CreateParagraphBlock, ParagraphData
+from notionary.page.content.parser.parsers.base import (
+    BlockParsingContext,
+    LineParser,
+)
+from notionary.page.content.syntax.service import SyntaxRegistry
+
+
+class SpaceParser(LineParser):
+    """
+    Parser for [space] markers that create empty paragraph blocks.
+    Uses SyntaxRegistry for centralized syntax definition.
+    """
+
+    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
+        return self._syntax.regex_pattern.match(context.line.strip()) is not None
+
+    @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 = ParagraphData(rich_text=[], color=BlockColor.DEFAULT)
+        return CreateParagraphBlock(paragraph=paragraph_data)