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

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

@@ -0,0 +1,60 @@
+from ..context import BlockParsingContext, ParentBlockContext
+from .audio import AudioParser
+from .base import LineParser
+from .bookmark import BookmarkParser
+from .breadcrumb import BreadcrumbParser
+from .bulleted_list import BulletedListParser
+from .callout import CalloutParser
+from .caption import CaptionParser
+from .code import CodeParser
+from .column import ColumnParser
+from .column_list import ColumnListParser
+from .divider import DividerParser
+from .embed import EmbedParser
+from .equation import EquationParser
+from .file import FileParser
+from .heading import HeadingParser
+from .image import ImageParser
+from .numbered_list import NumberedListParser
+from .paragraph import ParagraphParser
+from .pdf import PdfParser
+from .quote import QuoteParser
+from .space import SpaceParser
+from .table import TableParser
+from .table_of_contents import TableOfContentsParser
+from .todo import TodoParser
+from .toggle import ToggleParser
+from .toggleable_heading import ToggleableHeadingParser
+from .video import VideoParser
+
+__all__ = [
+    "AudioParser",
+    "BlockParsingContext",
+    "BookmarkParser",
+    "BreadcrumbParser",
+    "BulletedListParser",
+    "CalloutParser",
+    "CaptionParser",
+    "CodeParser",
+    "ColumnListParser",
+    "ColumnParser",
+    "DividerParser",
+    "EmbedParser",
+    "EquationParser",
+    "FileParser",
+    "HeadingParser",
+    "ImageParser",
+    "LineParser",
+    "NumberedListParser",
+    "ParagraphParser",
+    "ParentBlockContext",
+    "PdfParser",
+    "QuoteParser",
+    "SpaceParser",
+    "TableOfContentsParser",
+    "TableParser",
+    "TodoParser",
+    "ToggleParser",
+    "ToggleableHeadingParser",
+    "VideoParser",
+]

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

@@ -0,0 +1,40 @@
+from typing import override
+
+from notionary.blocks.schemas import (
+    CreateAudioBlock,
+    ExternalFile,
+    FileData,
+    FileType,
+)
+from notionary.page.content.parser.parsers.base import BlockParsingContext, LineParser
+from notionary.page.content.syntax.service import SyntaxRegistry
+
+
+class AudioParser(LineParser):
+    def __init__(self, syntax_registry: SyntaxRegistry) -> None:
+        super().__init__(syntax_registry)
+        self._syntax = syntax_registry.get_audio_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 url is None:
+            return
+
+        audio_data = FileData(
+            type=FileType.EXTERNAL,
+            external=ExternalFile(url=url),
+            caption=[],
+        )
+        block = CreateAudioBlock(audio=audio_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/base.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+
+from notionary.page.content.parser.context import BlockParsingContext
+from notionary.page.content.syntax.service import SyntaxRegistry
+
+
+class LineParser(ABC):
+    def __init__(self, syntax_registry: SyntaxRegistry | None = None) -> None:
+        self._next_handler: LineParser | None = None
+        self._syntax_registry = syntax_registry
+
+    def set_next(self, handler: LineParser) -> LineParser:
+        self._next_handler = handler
+        return handler
+
+    async def handle(self, context: BlockParsingContext) -> None:
+        if self._can_handle(context):
+            await self._process(context)
+        elif self._next_handler:
+            await self._next_handler.handle(context)
+
+    @abstractmethod
+    def _can_handle(self, context: BlockParsingContext) -> bool:
+        pass
+
+    @abstractmethod
+    async def _process(self, context: BlockParsingContext) -> None:
+        pass

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

@@ -0,0 +1,33 @@
+"""Parser for bookmark blocks."""
+
+from typing import override
+
+from notionary.blocks.schemas import BookmarkData, CreateBookmarkBlock
+from notionary.page.content.parser.parsers.base import BlockParsingContext, LineParser
+from notionary.page.content.syntax.service import SyntaxRegistry
+
+
+class BookmarkParser(LineParser):
+    def __init__(self, syntax_registry: SyntaxRegistry) -> None:
+        super().__init__(syntax_registry)
+        self._syntax = syntax_registry.get_bookmark_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
+
+        bookmark_data = BookmarkData(url=url, caption=[])
+        block = CreateBookmarkBlock(bookmark=bookmark_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/breadcrumb.py

@@ -0,0 +1,33 @@
+from typing import override
+
+from notionary.blocks.schemas import BreadcrumbData, CreateBreadcrumbBlock
+from notionary.page.content.parser.parsers.base import (
+    BlockParsingContext,
+    LineParser,
+)
+from notionary.page.content.syntax.service import SyntaxRegistry
+
+
+class BreadcrumbParser(LineParser):
+    def __init__(self, syntax_registry: SyntaxRegistry) -> None:
+        super().__init__(syntax_registry)
+        self._syntax = syntax_registry.get_breadcrumb_syntax()
+
+    @override
+    def _can_handle(self, context: BlockParsingContext) -> bool:
+        if context.is_inside_parent_context():
+            return False
+        return self._is_breadcrumb(context.line)
+
+    @override
+    async def _process(self, context: BlockParsingContext) -> None:
+        block = self._create_breadcrumb_block()
+        if block:
+            context.result_blocks.append(block)
+
+    def _is_breadcrumb(self, line: str) -> bool:
+        return self._syntax.regex_pattern.match(line) is not None
+
+    def _create_breadcrumb_block(self) -> CreateBreadcrumbBlock:
+        breadcrumb_data = BreadcrumbData()
+        return CreateBreadcrumbBlock(breadcrumb=breadcrumb_data)

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

@@ -0,0 +1,41 @@
+from typing import override
+
+from notionary.blocks.rich_text.markdown_rich_text_converter import (
+    MarkdownRichTextConverter,
+)
+from notionary.blocks.schemas import BulletedListItemData, CreateBulletedListItemBlock
+from notionary.page.content.parser.parsers.base import (
+    BlockParsingContext,
+    LineParser,
+)
+from notionary.page.content.syntax.service import SyntaxRegistry
+
+
+class BulletedListParser(LineParser):
+    def __init__(self, syntax_registry: SyntaxRegistry, rich_text_converter: MarkdownRichTextConverter) -> None:
+        super().__init__(syntax_registry)
+        self._syntax = syntax_registry.get_bulleted_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_bulleted_list_block(context.line)
+        if block:
+            context.result_blocks.append(block)
+
+    async def _create_bulleted_list_block(self, text: str) -> CreateBulletedListItemBlock | None:
+        match = self._syntax.regex_pattern.match(text)
+        if not match:
+            return None
+
+        content = match.group(2)
+        rich_text = await self._rich_text_converter.to_rich_text(content)
+
+        bulleted_list_content = BulletedListItemData(rich_text=rich_text)
+        return CreateBulletedListItemBlock(bulleted_list_item=bulleted_list_content)

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

@@ -0,0 +1,129 @@
+from typing import override
+
+from notionary.blocks.rich_text.markdown_rich_text_converter import MarkdownRichTextConverter
+from notionary.blocks.schemas import CreateCalloutBlock, CreateCalloutData
+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
+from notionary.shared.models.icon import EmojiIcon
+
+
+class CalloutParser(LineParser):
+    DEFAULT_EMOJI = "💡"
+
+    def __init__(self, syntax_registry: SyntaxRegistry, rich_text_converter: MarkdownRichTextConverter) -> None:
+        super().__init__(syntax_registry)
+        self._syntax = syntax_registry.get_callout_syntax()
+        self._start_pattern = self._syntax.regex_pattern
+        self._end_pattern = self._syntax.end_regex_pattern
+        self._rich_text_converter = rich_text_converter
+
+    @override
+    def _can_handle(self, context: BlockParsingContext) -> bool:
+        return self._is_callout_start(context) or self._is_callout_end(context) or self._is_callout_content(context)
+
+    @override
+    async def _process(self, context: BlockParsingContext) -> None:
+        if self._is_callout_start(context):
+            await self._start_callout(context)
+
+        if self._is_callout_end(context):
+            await self._finalize_callout(context)
+
+        if self._is_callout_content(context):
+            self._add_callout_content(context)
+
+    def _is_callout_start(self, context: BlockParsingContext) -> bool:
+        return self._start_pattern.match(context.line) is not None
+
+    def _is_callout_end(self, context: BlockParsingContext) -> bool:
+        if not self._end_pattern.match(context.line):
+            return False
+
+        if not context.parent_stack:
+            return False
+
+        current_parent = context.parent_stack[-1]
+        return isinstance(current_parent.block, CreateCalloutBlock)
+
+    async def _start_callout(self, context: BlockParsingContext) -> None:
+        block = await self._create_callout_block(context.line)
+        if not block:
+            return
+
+        parent_context = ParentBlockContext(
+            block=block,
+            child_lines=[],
+        )
+        context.parent_stack.append(parent_context)
+
+    async def _create_callout_block(self, line: str) -> CreateCalloutBlock | None:
+        match = self._start_pattern.match(line)
+        if not match:
+            return None
+
+        emoji_part = match.group(1)
+        emoji = emoji_part.strip() if emoji_part else self.DEFAULT_EMOJI
+
+        # Create callout with empty rich_text initially
+        # The actual content will be added as children
+        callout_data = CreateCalloutData(
+            rich_text=[],
+            icon=EmojiIcon(emoji=emoji),
+            children=[],
+        )
+        return CreateCalloutBlock(callout=callout_data)
+
+    async def _finalize_callout(self, context: BlockParsingContext) -> None:
+        callout_context = context.parent_stack.pop()
+        await self._assign_callout_children_if_any(callout_context, context)
+
+        if self._is_nested_in_other_parent_context(context):
+            self._assign_to_parent_context(context, callout_context)
+        else:
+            context.result_blocks.append(callout_context.block)
+
+    def _is_nested_in_other_parent_context(self, context: BlockParsingContext) -> bool:
+        return bool(context.parent_stack)
+
+    def _assign_to_parent_context(self, context: BlockParsingContext, callout_context: ParentBlockContext) -> None:
+        parent_context = context.parent_stack[-1]
+        parent_context.add_child_block(callout_context.block)
+
+    async def _assign_callout_children_if_any(
+        self, callout_context: ParentBlockContext, context: BlockParsingContext
+    ) -> None:
+        all_children = []
+
+        if callout_context.child_lines:
+            children_text = "\n".join(callout_context.child_lines)
+            text_blocks = await self._parse_nested_content(children_text, context)
+            all_children.extend(text_blocks)
+
+        # Add any child blocks
+        if callout_context.child_blocks:
+            all_children.extend(callout_context.child_blocks)
+
+        callout_context.block.callout.children = all_children
+
+    def _is_callout_content(self, context: BlockParsingContext) -> bool:
+        if not context.parent_stack:
+            return False
+
+        current_parent = context.parent_stack[-1]
+        if not isinstance(current_parent.block, CreateCalloutBlock):
+            return False
+
+        return not (self._start_pattern.match(context.line) or self._end_pattern.match(context.line))
+
+    def _add_callout_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/caption.py

@@ -0,0 +1,55 @@
+from typing import override
+
+from notionary.blocks.rich_text.markdown_rich_text_converter import (
+    MarkdownRichTextConverter,
+)
+from notionary.blocks.schemas import BlockCreatePayload
+from notionary.page.content.parser.parsers.base import (
+    BlockParsingContext,
+    LineParser,
+)
+from notionary.page.content.syntax.service import SyntaxRegistry
+
+
+class CaptionParser(LineParser):
+    def __init__(self, syntax_registry: SyntaxRegistry, rich_text_converter: MarkdownRichTextConverter) -> None:
+        super().__init__(syntax_registry)
+        self._syntax = syntax_registry.get_caption_syntax()
+        self._rich_text_converter = rich_text_converter
+
+    @override
+    def _can_handle(self, context: BlockParsingContext) -> bool:
+        if context.is_inside_parent_context():
+            return False
+
+        if not self._syntax.regex_pattern.match(context.line):
+            return False
+
+        if not context.result_blocks:
+            return False
+
+        previous_block = context.result_blocks[-1]
+        return self._block_supports_caption(previous_block)
+
+    @override
+    async def _process(self, context: BlockParsingContext) -> None:
+        caption_match = self._syntax.regex_pattern.match(context.line)
+        if not caption_match:
+            return
+
+        caption_text = caption_match.group(1)
+        caption_rich_text = await self._rich_text_converter.to_rich_text(caption_text)
+
+        previous_block = context.result_blocks[-1]
+        self._attach_caption_to_block(previous_block, caption_rich_text)
+
+    def _block_supports_caption(self, block: BlockCreatePayload) -> bool:
+        block_data = getattr(block, block.type.value, None)
+        if block_data is None:
+            return False
+        return hasattr(block_data, "caption")
+
+    def _attach_caption_to_block(self, block: BlockCreatePayload, caption_rich_text: list) -> None:
+        block_data = getattr(block, block.type.value)
+        if hasattr(block_data, "caption"):
+            block_data.caption = caption_rich_text

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, CodeLanguage, CreateCodeBlock
+from notionary.page.content.parser.parsers.base import BlockParsingContext, LineParser
+from notionary.page.content.syntax.service import SyntaxRegistry
+
+
+class CodeParser(LineParser):
+    DEFAULT_LANGUAGE = CodeLanguage.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) -> CodeLanguage:
+        return CodeLanguage.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,117 @@
+from typing import override
+
+from notionary.blocks.schemas import CreateColumnBlock, CreateColumnData, CreateColumnListBlock
+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 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) or self._is_column_end(context) or self._is_column_content(context)
+
+    @override
+    async def _process(self, context: BlockParsingContext) -> None:
+        if self._is_column_start(context):
+            await self._start_column(context)
+        elif self._is_column_end(context):
+            await self._finalize_column(context)
+        elif self._is_column_content(context):
+            await self._add_column_content(context)
+
+    def _is_column_start(self, context: BlockParsingContext) -> bool:
+        return self._syntax.regex_pattern.match(context.line) is not None
+
+    def _is_column_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, CreateColumnBlock)
+
+    def _is_column_content(self, context: BlockParsingContext) -> bool:
+        if not context.parent_stack:
+            return False
+
+        current_parent = context.parent_stack[-1]
+        if not isinstance(current_parent.block, CreateColumnBlock):
+            return False
+
+        line = context.line.strip()
+        return not (self._syntax.regex_pattern.match(line) or self._syntax.end_regex_pattern.match(line))
+
+    async def _add_column_content(self, context: BlockParsingContext) -> None:
+        context.parent_stack[-1].add_child_line(context.line)
+
+    async def _start_column(self, context: BlockParsingContext) -> None:
+        block = self._create_column_block(context.line)
+        if not block:
+            return
+
+        parent_context = ParentBlockContext(
+            block=block,
+            child_lines=[],
+        )
+        context.parent_stack.append(parent_context)
+
+    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)
+
+        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.MIN_WIDTH_RATIO < width_ratio <= self.MAX_WIDTH_RATIO else None
+        except ValueError:
+            return None
+
+    async def _finalize_column(self, context: BlockParsingContext) -> None:
+        column_context = context.parent_stack.pop()
+        await self._assign_column_children(column_context, context)
+
+        if self._has_column_list_parent(context):
+            parent = context.parent_stack[-1]
+            parent.add_child_block(column_context.block)
+        else:
+            context.result_blocks.append(column_context.block)
+
+    def _has_column_list_parent(self, context: BlockParsingContext) -> bool:
+        if not context.parent_stack:
+            return False
+        return isinstance(context.parent_stack[-1].block, CreateColumnListBlock)
+
+    async def _assign_column_children(self, column_context: ParentBlockContext, context: BlockParsingContext) -> None:
+        all_children = []
+
+        if column_context.child_lines:
+            children_text = "\n".join(column_context.child_lines)
+            text_blocks = await context.parse_nested_content(children_text)
+            all_children.extend(text_blocks)
+
+        if column_context.child_blocks:
+            all_children.extend(column_context.child_blocks)
+
+        column_context.block.column.children = all_children