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

notionary/page/content/markdown/nodes/divider.py

@@ -0,0 +1,14 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class DividerMarkdownNode(MarkdownNode):
+    def __init__(self, syntax_registry: SyntaxRegistry | None = None) -> None:
+        super().__init__(syntax_registry=syntax_registry)
+
+    @override
+    def to_markdown(self) -> str:
+        divider_syntax = self._syntax_registry.get_divider_syntax()
+        return divider_syntax.start_delimiter

notionary/page/content/markdown/nodes/embed.py

@@ -0,0 +1,23 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.markdown.nodes.mixins.caption import CaptionMarkdownNodeMixin
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class EmbedMarkdownNode(MarkdownNode, CaptionMarkdownNodeMixin):
+    def __init__(
+        self,
+        url: str,
+        caption: str | None = None,
+        syntax_registry: SyntaxRegistry | None = None,
+    ) -> None:
+        super().__init__(syntax_registry=syntax_registry)
+        self.url = url
+        self.caption = caption
+
+    @override
+    def to_markdown(self) -> str:
+        embed_syntax = self._syntax_registry.get_embed_syntax()
+        base_markdown = f"{embed_syntax.start_delimiter}{self.url}{embed_syntax.end_delimiter}"
+        return self._append_caption_to_markdown(base_markdown, self.caption)

notionary/page/content/markdown/nodes/equation.py

@@ -0,0 +1,19 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class EquationMarkdownNode(MarkdownNode):
+    def __init__(self, expression: str, syntax_registry: SyntaxRegistry | None = None) -> None:
+        super().__init__(syntax_registry=syntax_registry)
+        self.expression = expression
+
+    @override
+    def to_markdown(self) -> str:
+        expr = self.expression.strip()
+        equation_syntax = self._syntax_registry.get_equation_syntax()
+        if not expr:
+            return f"{equation_syntax.start_delimiter}{equation_syntax.end_delimiter}"
+
+        return f"{equation_syntax.start_delimiter}{expr}{equation_syntax.end_delimiter}"

notionary/page/content/markdown/nodes/file.py

@@ -0,0 +1,23 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.markdown.nodes.mixins.caption import CaptionMarkdownNodeMixin
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class FileMarkdownNode(MarkdownNode, CaptionMarkdownNodeMixin):
+    def __init__(
+        self,
+        url: str,
+        caption: str | None = None,
+        syntax_registry: SyntaxRegistry | None = None,
+    ) -> None:
+        super().__init__(syntax_registry=syntax_registry)
+        self.url = url
+        self.caption = caption
+
+    @override
+    def to_markdown(self) -> str:
+        file_syntax = self._syntax_registry.get_file_syntax()
+        base_markdown = f"{file_syntax.start_delimiter}{self.url}{file_syntax.end_delimiter}"
+        return self._append_caption_to_markdown(base_markdown, self.caption)

notionary/page/content/markdown/nodes/heading.py

@@ -0,0 +1,36 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.markdown.nodes.container import ContainerNode
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class HeadingMarkdownNode(ContainerNode):
+    MIN_LEVEL = 1
+    MAX_LEVEL = 3
+
+    def __init__(
+        self,
+        text: str,
+        level: int = 1,
+        children: list[MarkdownNode] | None = None,
+        syntax_registry: SyntaxRegistry | None = None,
+    ) -> None:
+        super().__init__(syntax_registry=syntax_registry)
+        self.text = text
+        self.level = self._validate_level(level)
+        self.children = children or []
+
+    @override
+    def to_markdown(self) -> str:
+        heading_prefix = self._get_heading_prefix()
+        result = f"{heading_prefix} {self.text}"
+        result += self.render_children()
+        return result
+
+    def _validate_level(self, level: int) -> int:
+        return max(self.MIN_LEVEL, min(self.MAX_LEVEL, level))
+
+    def _get_heading_prefix(self) -> str:
+        delimiter = self._syntax_registry.get_heading_syntax().start_delimiter
+        return delimiter * self.level

notionary/page/content/markdown/nodes/image.py

@@ -0,0 +1,23 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.markdown.nodes.mixins.caption import CaptionMarkdownNodeMixin
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class ImageMarkdownNode(MarkdownNode, CaptionMarkdownNodeMixin):
+    def __init__(
+        self,
+        url: str,
+        caption: str | None = None,
+        syntax_registry: SyntaxRegistry | None = None,
+    ) -> None:
+        super().__init__(syntax_registry=syntax_registry)
+        self.url = url
+        self.caption = caption
+
+    @override
+    def to_markdown(self) -> str:
+        image_syntax = self._syntax_registry.get_image_syntax()
+        base_markdown = f"{image_syntax.start_delimiter}{self.url}{image_syntax.end_delimiter}"
+        return self._append_caption_to_markdown(base_markdown, self.caption)

notionary/page/content/markdown/nodes/mixins/__init__.py

@@ -0,0 +1,5 @@
+from .caption import CaptionMarkdownNodeMixin
+
+__all__ = [
+    "CaptionMarkdownNodeMixin",
+]

notionary/page/content/markdown/nodes/mixins/caption.py

@@ -0,0 +1,12 @@
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class CaptionMarkdownNodeMixin:
+    _syntax_registry: SyntaxRegistry
+
+    def _append_caption_to_markdown(self, base_markdown: str, caption: str | None) -> str:
+        if not caption:
+            return base_markdown
+
+        caption_syntax = self._syntax_registry.get_caption_syntax()
+        return f"{base_markdown}\n{caption_syntax.start_delimiter} {caption}"

notionary/page/content/markdown/nodes/numbered_list.py

@@ -0,0 +1,38 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.markdown.nodes.container import ContainerNode
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class NumberedListMarkdownNode(ContainerNode):
+    def __init__(
+        self,
+        texts: list[str],
+        children: list[MarkdownNode | None] | None = None,
+        syntax_registry: SyntaxRegistry | None = None,
+    ):
+        super().__init__(syntax_registry=syntax_registry)
+        self.texts = texts
+        self.children = children or []
+
+    @override
+    def to_markdown(self) -> str:
+        list_items = [self._render_list_item(index, text) for index, text in enumerate(self.texts)]
+        return "\n".join(list_items)
+
+    def _render_list_item(self, index: int, text: str) -> str:
+        item_number = index + 1
+        item_line = f"{item_number}. {text}"
+
+        child = self._get_child_for_item(index)
+        if child:
+            child_content = self.render_child(child)
+            return f"{item_line}\n{child_content}"
+
+        return item_line
+
+    def _get_child_for_item(self, index: int) -> MarkdownNode | None:
+        if not self.children or index >= len(self.children):
+            return None
+        return self.children[index]

notionary/page/content/markdown/nodes/paragraph.py

@@ -0,0 +1,14 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class ParagraphMarkdownNode(MarkdownNode):
+    def __init__(self, text: str, syntax_registry: SyntaxRegistry | None = None):
+        super().__init__(syntax_registry=syntax_registry)
+        self.text = text
+
+    @override
+    def to_markdown(self) -> str:
+        return self.text

notionary/page/content/markdown/nodes/pdf.py

@@ -0,0 +1,23 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.markdown.nodes.mixins.caption import CaptionMarkdownNodeMixin
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class PdfMarkdownNode(MarkdownNode, CaptionMarkdownNodeMixin):
+    def __init__(
+        self,
+        url: str,
+        caption: str | None = None,
+        syntax_registry: SyntaxRegistry | None = None,
+    ) -> None:
+        super().__init__(syntax_registry=syntax_registry)
+        self.url = url
+        self.caption = caption
+
+    @override
+    def to_markdown(self) -> str:
+        pdf_syntax = self._syntax_registry.get_pdf_syntax()
+        base_markdown = f"{pdf_syntax.start_delimiter}{self.url}{pdf_syntax.end_delimiter}"
+        return self._append_caption_to_markdown(base_markdown, self.caption)

notionary/page/content/markdown/nodes/quote.py

@@ -0,0 +1,27 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.markdown.nodes.container import ContainerNode
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class QuoteMarkdownNode(ContainerNode):
+    def __init__(
+        self,
+        text: str,
+        children: list[MarkdownNode] | None = None,
+        syntax_registry: SyntaxRegistry | None = None,
+    ) -> None:
+        super().__init__(syntax_registry=syntax_registry)
+        self.text = text
+        self.children = children or []
+
+    @override
+    def to_markdown(self) -> str:
+        quote_delimiter = self._get_quote_delimiter()
+        result = f"{quote_delimiter}{self.text}"
+        result += self.render_children()
+        return result
+
+    def _get_quote_delimiter(self) -> str:
+        return self._syntax_registry.get_quote_syntax().start_delimiter

notionary/page/content/markdown/nodes/space.py

@@ -0,0 +1,14 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class SpaceMarkdownNode(MarkdownNode):
+    def __init__(self, syntax_registry: SyntaxRegistry | None = None) -> None:
+        super().__init__(syntax_registry=syntax_registry)
+
+    @override
+    def to_markdown(self) -> str:
+        space_syntax = self._syntax_registry.get_space_syntax()
+        return space_syntax.start_delimiter

notionary/page/content/markdown/nodes/table.py

@@ -0,0 +1,45 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class TableMarkdownNode(MarkdownNode):
+    def __init__(
+        self, headers: list[str], rows: list[list[str]], syntax_registry: SyntaxRegistry | None = None
+    ) -> None:
+        super().__init__(syntax_registry=syntax_registry)
+        self._validate_input(headers, rows)
+        self.headers = headers
+        self.rows = rows
+
+    def _validate_input(self, headers: list[str], rows: list[list[str]]) -> None:
+        if not headers:
+            raise ValueError("headers must not be empty")
+        if not all(isinstance(row, list) for row in rows):
+            raise ValueError("rows must be a list of lists")
+
+    @override
+    def to_markdown(self) -> str:
+        header = self._build_header_row()
+        separator = self._build_separator_row()
+        data_rows = self._build_data_rows()
+        return "\n".join([header, separator, *data_rows])
+
+    def _build_header_row(self) -> str:
+        return self._format_row(self.headers)
+
+    def _format_row(self, cells: list[str]) -> str:
+        table_syntax = self._syntax_registry.get_table_syntax()
+        delimiter = table_syntax.start_delimiter
+        joined_cells = f" {delimiter} ".join(cells)
+        return f"{delimiter} {joined_cells} {delimiter}"
+
+    def _build_separator_row(self) -> str:
+        table_syntax = self._syntax_registry.get_table_syntax()
+        col_count = len(self.headers)
+        separators = [table_syntax.end_delimiter] * col_count
+        return self._format_row(separators)
+
+    def _build_data_rows(self) -> list[str]:
+        return [self._format_row(row) for row in self.rows]

notionary/page/content/markdown/nodes/table_of_contents.py

@@ -0,0 +1,14 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class TableOfContentsMarkdownNode(MarkdownNode):
+    def __init__(self, syntax_registry: SyntaxRegistry | None = None) -> None:
+        super().__init__(syntax_registry=syntax_registry)
+
+    @override
+    def to_markdown(self) -> str:
+        toc_syntax = self._syntax_registry.get_table_of_contents_syntax()
+        return toc_syntax.start_delimiter

notionary/page/content/markdown/nodes/todo.py

@@ -0,0 +1,38 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.markdown.nodes.container import ContainerNode
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class TodoMarkdownNode(ContainerNode):
+    VALID_MARKER = "-"
+
+    def __init__(
+        self,
+        text: str,
+        checked: bool = False,
+        marker: str = "-",
+        children: list[MarkdownNode] | None = None,
+        syntax_registry: SyntaxRegistry | None = None,
+    ):
+        super().__init__(syntax_registry=syntax_registry)
+        self.text = text
+        self.checked = checked
+        self.marker = marker
+        self.children = children or []
+
+    @override
+    def to_markdown(self) -> str:
+        validated_marker = self._get_validated_marker()
+        checkbox_state = self._get_checkbox_state()
+        result = f"{validated_marker}{checkbox_state} {self.text}"
+        result += self.render_children()
+        return result
+
+    def _get_validated_marker(self) -> str:
+        return self.marker if self.marker == self.VALID_MARKER else self.VALID_MARKER
+
+    def _get_checkbox_state(self) -> str:
+        todo_syntax = self._syntax_registry.get_todo_syntax()
+        return todo_syntax.end_delimiter if self.checked else todo_syntax.start_delimiter

notionary/page/content/markdown/nodes/toggle.py

@@ -0,0 +1,27 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.markdown.nodes.container import ContainerNode
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class ToggleMarkdownNode(ContainerNode):
+    def __init__(
+        self,
+        title: str,
+        children: list[MarkdownNode] | None = None,
+        syntax_registry: SyntaxRegistry | None = None,
+    ):
+        super().__init__(syntax_registry=syntax_registry)
+        self.title = title
+        self.children = children or []
+
+    @override
+    def to_markdown(self) -> str:
+        toggle_delimiter = self._get_toggle_delimiter()
+        result = f"{toggle_delimiter} {self.title}"
+        result += self.render_children()
+        return result
+
+    def _get_toggle_delimiter(self) -> str:
+        return self._syntax_registry.get_toggle_syntax().start_delimiter

notionary/page/content/markdown/nodes/video.py

@@ -0,0 +1,23 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.markdown.nodes.mixins.caption import CaptionMarkdownNodeMixin
+from notionary.page.content.syntax import SyntaxRegistry
+
+
+class VideoMarkdownNode(MarkdownNode, CaptionMarkdownNodeMixin):
+    def __init__(
+        self,
+        url: str,
+        caption: str | None = None,
+        syntax_registry: SyntaxRegistry | None = None,
+    ) -> None:
+        super().__init__(syntax_registry=syntax_registry)
+        self.url = url
+        self.caption = caption
+
+    @override
+    def to_markdown(self) -> str:
+        video_syntax = self._syntax_registry.get_video_syntax()
+        base_markdown = f"{video_syntax.start_delimiter}{self.url}{video_syntax.end_delimiter}"
+        return self._append_caption_to_markdown(base_markdown, self.caption)

notionary/page/content/parser/context.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+
+from notionary.blocks.schemas import BlockCreatePayload
+from notionary.page.content.syntax.grammar import MarkdownGrammar
+
+
+class ParentBlockContext:
+    def __init__(
+        self,
+        block: BlockCreatePayload,
+        child_lines: list[str],
+        child_blocks: list[BlockCreatePayload] | None = None,
+    ) -> None:
+        self.block = block
+        self.child_lines = child_lines
+        self.child_blocks = child_blocks if child_blocks is not None else []
+
+    def add_child_line(self, content: str) -> None:
+        self.child_lines.append(content)
+
+    def add_child_block(self, block: BlockCreatePayload) -> None:
+        self.child_blocks.append(block)
+
+
+_ParseChildrenCallback = Callable[[str], Awaitable[list[BlockCreatePayload]]]
+
+
+class BlockParsingContext:
+    def __init__(
+        self,
+        line: str,
+        result_blocks: list[BlockCreatePayload],
+        parent_stack: list[ParentBlockContext],
+        parse_children_callback: _ParseChildrenCallback | None = None,
+        all_lines: list[str] | None = None,
+        current_line_index: int | None = None,
+        lines_consumed: int = 0,
+        is_previous_line_empty: bool = False,
+        markdown_grammar: MarkdownGrammar | None = None,
+    ) -> None:
+        self.line = line
+        self.result_blocks = result_blocks
+        self.parent_stack = parent_stack
+        self.parse_children_callback = parse_children_callback
+        self.all_lines = all_lines
+        self.current_line_index = current_line_index
+        self.lines_consumed = lines_consumed
+        self.is_previous_line_empty = is_previous_line_empty
+        markdown_grammar = markdown_grammar or MarkdownGrammar()
+        self._spaces_per_nesting_level = markdown_grammar.spaces_per_nesting_level
+
+    async def parse_nested_markdown(self, text: str) -> list[BlockCreatePayload]:
+        if not self._can_parse_children(text):
+            return []
+
+        return await self.parse_children_callback(text)
+
+    def _can_parse_children(self, text: str) -> bool:
+        return self.parse_children_callback is not None and bool(text)
+
+    def get_remaining_lines(self) -> list[str]:
+        if not self._has_remaining_lines():
+            return []
+        return self.all_lines[self.current_line_index + 1 :]
+
+    def _has_remaining_lines(self) -> bool:
+        return self.all_lines is not None and self.current_line_index is not None
+
+    def is_inside_parent_context(self) -> bool:
+        return len(self.parent_stack) > 0
+
+    def get_line_indentation_level(self, line: str | None = None) -> int:
+        target_line = self._get_target_line(line)
+        leading_spaces = self._count_leading_spaces(target_line)
+        return self._calculate_indentation_level(leading_spaces)
+
+    def _get_target_line(self, line: str | None) -> str:
+        return line if line is not None else self.line
+
+    def _count_leading_spaces(self, line: str) -> int:
+        return len(line) - len(line.lstrip())
+
+    def _calculate_indentation_level(self, leading_spaces: int) -> int:
+        return leading_spaces // self._spaces_per_nesting_level
+
+    def collect_indented_child_lines(self, parent_indent_level: int) -> list[str]:
+        child_lines = []
+        expected_child_indent = parent_indent_level + 1
+
+        for line in self.get_remaining_lines():
+            if self._should_include_line_as_child(line, expected_child_indent):
+                child_lines.append(line)
+            else:
+                break
+
+        return child_lines
+
+    def _should_include_line_as_child(self, line: str, expected_indent: int) -> bool:
+        if self._is_empty_line(line):
+            return True
+
+        line_indent = self.get_line_indentation_level(line)
+        return line_indent >= expected_indent
+
+    def _is_empty_line(self, line: str) -> bool:
+        return not line.strip()
+
+    def strip_indentation_level(self, lines: list[str], levels: int = 1) -> list[str]:
+        return [self._strip_line_indentation(line, levels) for line in lines]
+
+    def _strip_line_indentation(self, line: str, levels: int) -> str:
+        if self._is_empty_line(line):
+            return line
+
+        spaces_to_remove = self._calculate_spaces_to_remove(levels)
+        return self._remove_leading_spaces(line, spaces_to_remove)
+
+    def _calculate_spaces_to_remove(self, levels: int) -> int:
+        return self._spaces_per_nesting_level * levels
+
+    def _remove_leading_spaces(self, line: str, spaces: int) -> str:
+        if len(line) < spaces:
+            return line
+        return line[spaces:]