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

notionary/page/content/parser/factory.py

@@ -0,0 +1,210 @@
+from notionary.blocks.rich_text.markdown_rich_text_converter import (
+    MarkdownRichTextConverter,
+)
+from notionary.page.content.parser.parsers import (
+    AudioParser,
+    BookmarkParser,
+    BreadcrumbParser,
+    BulletedListParser,
+    CalloutParser,
+    CaptionParser,
+    CodeParser,
+    ColumnListParser,
+    ColumnParser,
+    DividerParser,
+    EmbedParser,
+    EquationParser,
+    FileParser,
+    HeadingParser,
+    ImageParser,
+    LineParser,
+    NumberedListParser,
+    ParagraphParser,
+    PdfParser,
+    QuoteParser,
+    SpaceParser,
+    TableOfContentsParser,
+    TableParser,
+    TodoParser,
+    ToggleParser,
+    VideoParser,
+)
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class ConverterChainFactory:
+    def __init__(
+        self,
+        rich_text_converter: MarkdownRichTextConverter | None = None,
+        syntax_registry: SyntaxRegistry | None = None,
+    ) -> None:
+        self._rich_text_converter = rich_text_converter or MarkdownRichTextConverter()
+        self._syntax_registry = syntax_registry or SyntaxRegistry()
+
+    def create(self) -> LineParser:
+        # multi-line (structural) blocks
+        code_parser = self._create_code_parser()
+        equation_parser = self._create_equation_parser()
+        table_parser = self._create_table_parser()
+        column_parser = self._create_column_parser()
+        column_list_parser = self._create_column_list_parser()
+        toggle_parser = self._create_toggle_parser()
+
+        # Single-line blocks
+        divider_parser = self._create_divider_parser()
+        breadcrumb_parser = self._create_breadcrumb_parser()
+        table_of_contents_parser = self._create_table_of_contents_parser()
+        space_parser = self._create_space_parser()
+        heading_parser = self._create_heading_parser()
+        quote_parser = self._create_quote_parser()
+        callout_parser = self._create_callout_parser()
+        todo_parser = self._create_todo_parser()
+        bulleted_list_parser = self._create_bulleted_list_parser()
+        numbered_list_parser = self._create_numbered_list_parser()
+
+        # Media blocks
+        bookmark_parser = self._create_bookmark_parser()
+        embed_parser = self._create_embed_parser()
+        image_parser = self._create_image_parser()
+        video_parser = self._create_video_parser()
+        audio_parser = self._create_audio_parser()
+        file_parser = self._create_file_parser()
+        pdf_parser = self._create_pdf_parser()
+
+        # Caption and Fallback
+        caption_parser = self._create_caption_parser()
+        paragraph_parser = self._create_paragraph_parser()
+
+        (
+            code_parser.set_next(equation_parser)
+            .set_next(table_parser)
+            .set_next(column_parser)
+            .set_next(column_list_parser)
+            .set_next(toggle_parser)
+            .set_next(divider_parser)
+            .set_next(breadcrumb_parser)
+            .set_next(table_of_contents_parser)
+            .set_next(space_parser)
+            .set_next(heading_parser)
+            .set_next(quote_parser)
+            .set_next(callout_parser)
+            .set_next(todo_parser)
+            .set_next(bulleted_list_parser)
+            .set_next(numbered_list_parser)
+            .set_next(bookmark_parser)
+            .set_next(embed_parser)
+            .set_next(image_parser)
+            .set_next(video_parser)
+            .set_next(audio_parser)
+            .set_next(file_parser)
+            .set_next(pdf_parser)
+            .set_next(caption_parser)
+            .set_next(paragraph_parser)
+        )
+
+        return code_parser
+
+    def _create_code_parser(self) -> CodeParser:
+        return CodeParser(
+            syntax_registry=self._syntax_registry,
+            rich_text_converter=self._rich_text_converter,
+        )
+
+    def _create_equation_parser(self) -> EquationParser:
+        return EquationParser(syntax_registry=self._syntax_registry)
+
+    def _create_table_parser(self) -> TableParser:
+        return TableParser(
+            syntax_registry=self._syntax_registry,
+            rich_text_converter=self._rich_text_converter,
+        )
+
+    def _create_column_parser(self) -> ColumnParser:
+        return ColumnParser(syntax_registry=self._syntax_registry)
+
+    def _create_column_list_parser(self) -> ColumnListParser:
+        return ColumnListParser(syntax_registry=self._syntax_registry)
+
+    def _create_toggle_parser(self) -> ToggleParser:
+        return ToggleParser(
+            syntax_registry=self._syntax_registry,
+            rich_text_converter=self._rich_text_converter,
+        )
+
+    def _create_divider_parser(self) -> DividerParser:
+        return DividerParser(syntax_registry=self._syntax_registry)
+
+    def _create_breadcrumb_parser(self) -> BreadcrumbParser:
+        return BreadcrumbParser(syntax_registry=self._syntax_registry)
+
+    def _create_table_of_contents_parser(self) -> TableOfContentsParser:
+        return TableOfContentsParser(syntax_registry=self._syntax_registry)
+
+    def _create_space_parser(self) -> SpaceParser:
+        return SpaceParser(syntax_registry=self._syntax_registry)
+
+    def _create_heading_parser(self) -> HeadingParser:
+        return HeadingParser(
+            syntax_registry=self._syntax_registry,
+            rich_text_converter=self._rich_text_converter,
+        )
+
+    def _create_quote_parser(self) -> QuoteParser:
+        return QuoteParser(
+            syntax_registry=self._syntax_registry,
+            rich_text_converter=self._rich_text_converter,
+        )
+
+    def _create_callout_parser(self) -> CalloutParser:
+        return CalloutParser(
+            syntax_registry=self._syntax_registry,
+            rich_text_converter=self._rich_text_converter,
+        )
+
+    def _create_todo_parser(self) -> TodoParser:
+        return TodoParser(
+            syntax_registry=self._syntax_registry,
+            rich_text_converter=self._rich_text_converter,
+        )
+
+    def _create_bulleted_list_parser(self) -> BulletedListParser:
+        return BulletedListParser(
+            syntax_registry=self._syntax_registry,
+            rich_text_converter=self._rich_text_converter,
+        )
+
+    def _create_numbered_list_parser(self) -> NumberedListParser:
+        return NumberedListParser(
+            syntax_registry=self._syntax_registry,
+            rich_text_converter=self._rich_text_converter,
+        )
+
+    def _create_bookmark_parser(self) -> BookmarkParser:
+        return BookmarkParser(syntax_registry=self._syntax_registry)
+
+    def _create_embed_parser(self) -> EmbedParser:
+        return EmbedParser(syntax_registry=self._syntax_registry)
+
+    def _create_image_parser(self) -> ImageParser:
+        return ImageParser(syntax_registry=self._syntax_registry)
+
+    def _create_video_parser(self) -> VideoParser:
+        return VideoParser(syntax_registry=self._syntax_registry)
+
+    def _create_audio_parser(self) -> AudioParser:
+        return AudioParser(syntax_registry=self._syntax_registry)
+
+    def _create_file_parser(self) -> FileParser:
+        return FileParser(syntax_registry=self._syntax_registry)
+
+    def _create_pdf_parser(self) -> PdfParser:
+        return PdfParser(syntax_registry=self._syntax_registry)
+
+    def _create_caption_parser(self) -> CaptionParser:
+        return CaptionParser(
+            syntax_registry=self._syntax_registry,
+            rich_text_converter=self._rich_text_converter,
+        )
+
+    def _create_paragraph_parser(self) -> ParagraphParser:
+        return ParagraphParser(rich_text_converter=self._rich_text_converter)

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

@@ -0,0 +1,58 @@
+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 .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",
+    "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 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 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 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 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,85 @@
+from typing import override
+
+from notionary.blocks.rich_text.markdown_rich_text_converter import (
+    MarkdownRichTextConverter,
+)
+from notionary.blocks.schemas import CreateBulletedListItemBlock, CreateBulletedListItemData
+from notionary.page.content.parser.parsers.base import (
+    BlockParsingContext,
+    LineParser,
+)
+from notionary.page.content.syntax 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._is_bulleted_list_line(context.line)
+
+    def _is_bulleted_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_bulleted_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: CreateBulletedListItemBlock, 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.bulleted_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[CreateBulletedListItemBlock]:
+        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_bulleted_list_block(self, text: str) -> CreateBulletedListItemBlock | 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(2)
+
+    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) -> CreateBulletedListItemBlock:
+        bulleted_list_content = CreateBulletedListItemData(rich_text=rich_text)
+        return CreateBulletedListItemBlock(bulleted_list_item=bulleted_list_content)

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

@@ -0,0 +1,100 @@
+import re
+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.parsers.base import (
+    BlockParsingContext,
+    LineParser,
+)
+from notionary.page.content.syntax 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._pattern = self._syntax.regex_pattern
+        self._rich_text_converter = rich_text_converter
+
+    @override
+    def _can_handle(self, context: BlockParsingContext) -> bool:
+        return self._pattern.search(context.line) is not None
+
+    @override
+    async def _process(self, context: BlockParsingContext) -> None:
+        block = await self._create_callout_block(context.line)
+        if not block:
+            return
+
+        await self._process_nested_children(block, context)
+
+        if self._is_nested_in_parent_context(context):
+            context.parent_stack[-1].add_child_block(block)
+        else:
+            context.result_blocks.append(block)
+
+    async def _process_nested_children(self, block: CreateCalloutBlock, 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.callout.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[CreateCalloutBlock]:
+        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_callout_block(self, line: str) -> CreateCalloutBlock | None:
+        match = self._pattern.search(line)
+        if not match:
+            return None
+
+        content, emoji = self._extract_content_and_emoji(match)
+        rich_text = await self._convert_to_rich_text(content)
+        return self._build_block(rich_text, emoji)
+
+    def _extract_content_and_emoji(self, match: re.Match[str]) -> tuple[str, str]:
+        inline_content = match.group(1)
+        if inline_content:
+            return inline_content.strip(), match.group(2) or self.DEFAULT_EMOJI
+
+        block_content = match.group(3)
+        if block_content:
+            return block_content.strip(), match.group(4) or self.DEFAULT_EMOJI
+
+        return "", self.DEFAULT_EMOJI
+
+    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, emoji: str) -> CreateCalloutBlock:
+        callout_data = CreateCalloutData(
+            rich_text=rich_text,
+            icon=EmojiIcon(emoji=emoji),
+            children=[],
+        )
+        return CreateCalloutBlock(callout=callout_data)
+
+    def _is_nested_in_parent_context(self, context: BlockParsingContext) -> bool:
+        return bool(context.parent_stack)

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 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