notionary 0.3.1__py3-none-any.whl → 0.4.1__py3-none-any.whl

notionary/page/content/syntax/models.py

@@ -1,66 +0,0 @@
-import re
-from dataclasses import dataclass
-from enum import StrEnum
-
-
-class SyntaxRegistryKey(StrEnum):
-    AUDIO = "audio"
-    BOOKMARK = "bookmark"
-    IMAGE = "image"
-    VIDEO = "video"
-    FILE = "file"
-    PDF = "pdf"
-
-    # List blocks
-    BULLETED_LIST = "bulleted_list"
-    NUMBERED_LIST = "numbered_list"
-    TO_DO = "todo"
-    TO_DO_DONE = "todo_done"
-
-    TOGGLE = "toggle"
-    TOGGLEABLE_HEADING = "toggleable_heading"
-    CALLOUT = "callout"
-    QUOTE = "quote"
-    CODE = "code"
-
-    COLUMN_LIST = "column_list"
-    COLUMN = "column"
-
-    # Heading blocks
-    HEADING_1 = "heading_1"
-    HEADING_2 = "heading_2"
-    HEADING_3 = "heading_3"
-    HEADING = "heading"  # Shared pattern for regular headings
-
-    DIVIDER = "divider"
-    BREADCRUMB = "breadcrumb"
-    TABLE_OF_CONTENTS = "table_of_contents"
-    EQUATION = "equation"
-    EMBED = "embed"
-    TABLE = "table"
-    TABLE_ROW = "table_row"
-
-    CAPTION = "caption"
-    SPACE = "space"
-
-
-# some elemente need closing delimiters, others not
-# either use union type or validate config in service
-@dataclass(frozen=True)
-class SyntaxDefinition:
-    """
-    Defines the syntax pattern for a block type.
-
-    Attributes:
-        start_delimiter: The opening delimiter (e.g., "```", "+++", ">")
-        end_delimiter: The optional closing delimiter (empty string if none)
-        regex_pattern: The compiled regex pattern to match this syntax
-        end_regex_pattern: Optional compiled regex pattern for end delimiter
-        is_multiline_block: Whether this block can contain child blocks
-        is_inline: Whether this is an inline syntax (like [audio](url))
-    """
-
-    start_delimiter: str
-    end_delimiter: str
-    regex_pattern: re.Pattern
-    end_regex_pattern: re.Pattern | None = None

notionary/page/content/syntax/registry.py

@@ -1,393 +0,0 @@
-import re
-
-from notionary.page.content.syntax.grammar import MarkdownGrammar
-from notionary.page.content.syntax.models import SyntaxDefinition, SyntaxRegistryKey
-
-
-class SyntaxRegistry:
-    def __init__(self, markdown_markdown_grammar: MarkdownGrammar | None = None) -> None:
-        self._markdown_grammar = markdown_markdown_grammar or MarkdownGrammar()
-
-        self._definitions: dict[SyntaxRegistryKey, SyntaxDefinition] = {}
-        self._register_defaults()
-
-    def get_audio_syntax(self) -> SyntaxDefinition:
-        return self._definitions[SyntaxRegistryKey.AUDIO]
-
-    def get_bookmark_syntax(self) -> SyntaxDefinition:
-        return self._definitions[SyntaxRegistryKey.BOOKMARK]
-
-    def get_breadcrumb_syntax(self) -> SyntaxDefinition:
-        return self._definitions[SyntaxRegistryKey.BREADCRUMB]
-
-    def get_bulleted_list_syntax(self) -> SyntaxDefinition:
-        return self._definitions[SyntaxRegistryKey.BULLETED_LIST]
-
-    def get_callout_syntax(self) -> SyntaxDefinition:
-        return self._definitions[SyntaxRegistryKey.CALLOUT]
-
-    def get_code_syntax(self) -> SyntaxDefinition:
-        return self._definitions[SyntaxRegistryKey.CODE]
-
-    def get_column_syntax(self) -> SyntaxDefinition:
-        return self._definitions[SyntaxRegistryKey.COLUMN]
-
-    def get_column_list_syntax(self) -> SyntaxDefinition:
-        return self._definitions[SyntaxRegistryKey.COLUMN_LIST]
-
-    def get_divider_syntax(self) -> SyntaxDefinition:
-        return self._definitions[SyntaxRegistryKey.DIVIDER]
-
-    def get_embed_syntax(self) -> SyntaxDefinition:
-        return self._definitions[SyntaxRegistryKey.EMBED]
-
-    def get_equation_syntax(self) -> SyntaxDefinition:
-        return self._definitions[SyntaxRegistryKey.EQUATION]
-
-    def get_file_syntax(self) -> SyntaxDefinition:
-        return self._definitions[SyntaxRegistryKey.FILE]
-
-    def get_image_syntax(self) -> SyntaxDefinition:
-        return self._definitions[SyntaxRegistryKey.IMAGE]
-
-    def get_numbered_list_syntax(self) -> SyntaxDefinition:
-        return self._definitions[SyntaxRegistryKey.NUMBERED_LIST]
-
-    def get_pdf_syntax(self) -> SyntaxDefinition:
-        return self._definitions[SyntaxRegistryKey.PDF]
-
-    def get_quote_syntax(self) -> SyntaxDefinition:
-        return self._definitions[SyntaxRegistryKey.QUOTE]
-
-    def get_table_syntax(self) -> SyntaxDefinition:
-        return self._definitions[SyntaxRegistryKey.TABLE]
-
-    def get_table_row_syntax(self) -> SyntaxDefinition:
-        return self._definitions[SyntaxRegistryKey.TABLE_ROW]
-
-    def get_table_of_contents_syntax(self) -> SyntaxDefinition:
-        return self._definitions[SyntaxRegistryKey.TABLE_OF_CONTENTS]
-
-    def get_todo_syntax(self) -> SyntaxDefinition:
-        return self._definitions[SyntaxRegistryKey.TO_DO]
-
-    def get_todo_done_syntax(self) -> SyntaxDefinition:
-        return self._definitions[SyntaxRegistryKey.TO_DO_DONE]
-
-    def get_toggle_syntax(self) -> SyntaxDefinition:
-        return self._definitions[SyntaxRegistryKey.TOGGLE]
-
-    def get_toggleable_heading_syntax(self) -> SyntaxDefinition:
-        return self._definitions[SyntaxRegistryKey.TOGGLEABLE_HEADING]
-
-    def get_video_syntax(self) -> SyntaxDefinition:
-        return self._definitions[SyntaxRegistryKey.VIDEO]
-
-    def get_caption_syntax(self) -> SyntaxDefinition:
-        return self._definitions[SyntaxRegistryKey.CAPTION]
-
-    def get_space_syntax(self) -> SyntaxDefinition:
-        return self._definitions[SyntaxRegistryKey.SPACE]
-
-    def get_heading_syntax(self) -> SyntaxDefinition:
-        return self._definitions[SyntaxRegistryKey.HEADING]
-
-    def _register_defaults(self) -> None:
-        self._register_audio_syntax()
-        self._register_bookmark_syntax()
-        self._register_image_syntax()
-        self._register_video_syntax()
-        self._register_file_syntax()
-        self._register_pdf_syntax()
-
-        # List blocks
-        self._register_bulleted_list_syntax()
-        self._register_numbered_list_syntax()
-        self._register_todo_syntax()
-        self._register_todo_done_syntax()
-
-        # Container blocks
-        self._register_toggle_syntax()
-        self._register_toggleable_heading_syntax()
-        self._register_callout_syntax()
-        self._register_quote_syntax()
-        self._register_code_syntax()
-
-        # Column layout blocks
-        self._register_column_list_syntax()
-        self._register_column_syntax()
-
-        self._register_heading_1_syntax()
-        self._register_heading_2_syntax()
-        self._register_heading_3_syntax()
-        self._register_heading_syntax()  # Shared pattern for regular headings
-
-        self._register_divider_syntax()
-        self._register_breadcrumb_syntax()
-        self._register_table_of_contents_syntax()
-        self._register_equation_syntax()
-        self._register_embed_syntax()
-        self._register_table_syntax()
-        self._register_table_row_syntax()
-
-        # Post-processing and utility blocks
-        self._register_caption_syntax()
-        self._register_space_syntax()
-
-    def _register_audio_syntax(self) -> None:
-        definition = SyntaxDefinition(
-            start_delimiter="[audio](",
-            end_delimiter=")",
-            regex_pattern=re.compile(r"\[audio\]\(([^)]+)\)"),
-        )
-        self._definitions[SyntaxRegistryKey.AUDIO] = definition
-
-    def _register_bookmark_syntax(self) -> None:
-        definition = SyntaxDefinition(
-            start_delimiter="[bookmark](",
-            end_delimiter=")",
-            regex_pattern=re.compile(r"\[bookmark\]\((https?://[^\s\"]+)\)"),
-        )
-        self._definitions[SyntaxRegistryKey.BOOKMARK] = definition
-
-    def _register_breadcrumb_syntax(self) -> None:
-        definition = SyntaxDefinition(
-            start_delimiter="[breadcrumb]",
-            end_delimiter="",
-            regex_pattern=re.compile(r"^\[breadcrumb\]\s*$", re.IGNORECASE),
-        )
-        self._definitions[SyntaxRegistryKey.BREADCRUMB] = definition
-
-    def _register_bulleted_list_syntax(self) -> None:
-        definition = SyntaxDefinition(
-            start_delimiter="- ",
-            end_delimiter="",
-            regex_pattern=re.compile(r"^(\s*)-\s+(?!\[[ xX]\])(.+)$"),
-        )
-        self._definitions[SyntaxRegistryKey.BULLETED_LIST] = definition
-
-    def _register_callout_syntax(self) -> None:
-        definition = SyntaxDefinition(
-            start_delimiter="[callout]",
-            end_delimiter=")",
-            regex_pattern=re.compile(
-                r'\[callout\](?:\(([^")]+?)(?:\s+"([^"]+)")?\)|(?:\s+([^"\n]+?)(?:\s+"([^"]+)")?)(?:\n|$))'
-            ),
-        )
-        self._definitions[SyntaxRegistryKey.CALLOUT] = definition
-
-    def _register_code_syntax(self) -> None:
-        code_delimiter = "```"
-        definition = SyntaxDefinition(
-            start_delimiter=code_delimiter,
-            end_delimiter=code_delimiter,
-            regex_pattern=re.compile("^" + re.escape(code_delimiter) + r"(\w*)\s*$"),
-            end_regex_pattern=re.compile("^" + re.escape(code_delimiter) + r"\s*$"),
-        )
-        self._definitions[SyntaxRegistryKey.CODE] = definition
-
-    def _register_column_syntax(self) -> None:
-        delimiter = self._markdown_grammar.column_delimiter
-        definition = SyntaxDefinition(
-            start_delimiter=f"{delimiter} column",
-            end_delimiter=delimiter,
-            regex_pattern=re.compile(
-                rf"^{re.escape(delimiter)}\s*column(?:\s+(0?\.\d+|1(?:\.0?)?))??\s*$",
-                re.IGNORECASE | re.MULTILINE,
-            ),
-            end_regex_pattern=re.compile(rf"^{re.escape(delimiter)}\s*$", re.MULTILINE),
-        )
-        self._definitions[SyntaxRegistryKey.COLUMN] = definition
-
-    def _register_column_list_syntax(self) -> None:
-        delimiter = self._markdown_grammar.column_delimiter
-        definition = SyntaxDefinition(
-            start_delimiter=f"{delimiter} columns",
-            end_delimiter=delimiter,
-            regex_pattern=re.compile(rf"^{re.escape(delimiter)}\s*columns?\s*$", re.IGNORECASE),
-            end_regex_pattern=re.compile(rf"^{re.escape(delimiter)}\s*$"),
-        )
-        self._definitions[SyntaxRegistryKey.COLUMN_LIST] = definition
-
-    def _register_divider_syntax(self) -> None:
-        definition = SyntaxDefinition(
-            start_delimiter="---",
-            end_delimiter="",
-            regex_pattern=re.compile(r"^\s*-{3,}\s*$"),
-        )
-        self._definitions[SyntaxRegistryKey.DIVIDER] = definition
-
-    def _register_embed_syntax(self) -> None:
-        definition = SyntaxDefinition(
-            start_delimiter="[embed](",
-            end_delimiter=")",
-            regex_pattern=re.compile(r"\[embed\]\((https?://[^\s)]+)\)"),
-        )
-        self._definitions[SyntaxRegistryKey.EMBED] = definition
-
-    def _register_equation_syntax(self) -> None:
-        definition = SyntaxDefinition(
-            start_delimiter="$$",
-            end_delimiter="$$",
-            regex_pattern=re.compile(r"^\$\$\s*$"),
-        )
-        self._definitions[SyntaxRegistryKey.EQUATION] = definition
-
-    def _register_file_syntax(self) -> None:
-        definition = SyntaxDefinition(
-            start_delimiter="[file](",
-            end_delimiter=")",
-            regex_pattern=re.compile(r"\[file\]\(([^)]+)\)"),
-        )
-        self._definitions[SyntaxRegistryKey.FILE] = definition
-
-    def _register_heading_1_syntax(self) -> None:
-        definition = SyntaxDefinition(
-            start_delimiter="# ",
-            end_delimiter="",
-            regex_pattern=re.compile(r"^#\s+(.+)$"),
-        )
-        self._definitions[SyntaxRegistryKey.HEADING_1] = definition
-
-    def _register_heading_2_syntax(self) -> None:
-        definition = SyntaxDefinition(
-            start_delimiter="## ",
-            end_delimiter="",
-            regex_pattern=re.compile(r"^#{2}\s+(.+)$"),
-        )
-        self._definitions[SyntaxRegistryKey.HEADING_2] = definition
-
-    def _register_heading_3_syntax(self) -> None:
-        definition = SyntaxDefinition(
-            start_delimiter="### ",
-            end_delimiter="",
-            regex_pattern=re.compile(r"^#{3}\s+(.+)$"),
-        )
-        self._definitions[SyntaxRegistryKey.HEADING_3] = definition
-
-    def _register_image_syntax(self) -> None:
-        definition = SyntaxDefinition(
-            start_delimiter="[image](",
-            end_delimiter=")",
-            regex_pattern=re.compile(r"(?<!!)\[image\]\(([^)]+)\)"),
-        )
-        self._definitions[SyntaxRegistryKey.IMAGE] = definition
-
-    def _register_numbered_list_syntax(self) -> None:
-        definition = SyntaxDefinition(
-            start_delimiter="1. ",
-            end_delimiter="",
-            regex_pattern=re.compile(r"^(\s*)(\d+)\.\s+(.+)$"),
-        )
-        self._definitions[SyntaxRegistryKey.NUMBERED_LIST] = definition
-
-    def _register_pdf_syntax(self) -> None:
-        definition = SyntaxDefinition(
-            start_delimiter="[pdf](",
-            end_delimiter=")",
-            regex_pattern=re.compile(r"\[pdf\]\(([^)]+)\)"),
-        )
-        self._definitions[SyntaxRegistryKey.PDF] = definition
-
-    def _register_quote_syntax(self) -> None:
-        definition = SyntaxDefinition(
-            start_delimiter="> ",
-            end_delimiter="",
-            regex_pattern=re.compile(r"^>(?!>)\s*(.+)$"),
-        )
-        self._definitions[SyntaxRegistryKey.QUOTE] = definition
-
-    def _register_table_syntax(self) -> None:
-        delimiter = self._markdown_grammar.table_delimiter
-        definition = SyntaxDefinition(
-            start_delimiter=delimiter,
-            end_delimiter="",
-            regex_pattern=re.compile(rf"^\s*{re.escape(delimiter)}(.+){re.escape(delimiter)}\s*$"),
-        )
-        self._definitions[SyntaxRegistryKey.TABLE] = definition
-
-    def _register_table_row_syntax(self) -> None:
-        delimiter = self._markdown_grammar.table_delimiter
-        definition = SyntaxDefinition(
-            start_delimiter=delimiter,
-            end_delimiter="",
-            regex_pattern=re.compile(rf"^\s*{re.escape(delimiter)}([\s\-:|]+){re.escape(delimiter)}\s*$"),
-        )
-        self._definitions[SyntaxRegistryKey.TABLE_ROW] = definition
-
-    def _register_table_of_contents_syntax(self) -> None:
-        definition = SyntaxDefinition(
-            start_delimiter="[toc]",
-            end_delimiter="",
-            regex_pattern=re.compile(r"^\[toc\]$", re.IGNORECASE),
-        )
-        self._definitions[SyntaxRegistryKey.TABLE_OF_CONTENTS] = definition
-
-    def _register_todo_syntax(self) -> None:
-        definition = SyntaxDefinition(
-            start_delimiter="- [ ]",
-            end_delimiter="",
-            regex_pattern=re.compile(r"^\s*-\s+\[ \]\s+(.+)$"),
-        )
-        self._definitions[SyntaxRegistryKey.TO_DO] = definition
-
-    def _register_todo_done_syntax(self) -> None:
-        definition = SyntaxDefinition(
-            start_delimiter="- [x]",
-            end_delimiter="",
-            regex_pattern=re.compile(r"^\s*-\s+\[x\]\s+(.+)$", re.IGNORECASE),
-        )
-        self._definitions[SyntaxRegistryKey.TO_DO_DONE] = definition
-
-    def _register_toggle_syntax(self) -> None:
-        delimiter = self._markdown_grammar.toggle_delimiter
-        definition = SyntaxDefinition(
-            start_delimiter=delimiter,
-            end_delimiter=delimiter,
-            regex_pattern=re.compile(rf"^{re.escape(delimiter)}\s+(.+)$"),
-            end_regex_pattern=re.compile(rf"^{re.escape(delimiter)}\s*$"),
-        )
-        self._definitions[SyntaxRegistryKey.TOGGLE] = definition
-
-    def _register_toggleable_heading_syntax(self) -> None:
-        delimiter = self._markdown_grammar.toggle_delimiter
-        escaped_delimiter = re.escape(delimiter)
-        definition = SyntaxDefinition(
-            start_delimiter=f"{delimiter} #",
-            end_delimiter=delimiter,
-            regex_pattern=re.compile(rf"^{escaped_delimiter}\s*(?P<level>#{{1,3}})(?!#)\s*(.+)$", re.IGNORECASE),
-            end_regex_pattern=re.compile(rf"^{escaped_delimiter}\s*$"),
-        )
-        self._definitions[SyntaxRegistryKey.TOGGLEABLE_HEADING] = definition
-
-    def _register_video_syntax(self) -> None:
-        definition = SyntaxDefinition(
-            start_delimiter="[video](",
-            end_delimiter=")",
-            regex_pattern=re.compile(r"\[video\]\(([^)]+)\)"),
-        )
-        self._definitions[SyntaxRegistryKey.VIDEO] = definition
-
-    def _register_caption_syntax(self) -> None:
-        definition = SyntaxDefinition(
-            start_delimiter="[caption]",
-            end_delimiter="",
-            regex_pattern=re.compile(r"^\[caption\]\s+(\S.*)$"),
-        )
-        self._definitions[SyntaxRegistryKey.CAPTION] = definition
-
-    def _register_space_syntax(self) -> None:
-        definition = SyntaxDefinition(
-            start_delimiter="[space]",
-            end_delimiter="",
-            regex_pattern=re.compile(r"^\[space\]\s*$"),
-        )
-        self._definitions[SyntaxRegistryKey.SPACE] = definition
-
-    def _register_heading_syntax(self) -> None:
-        definition = SyntaxDefinition(
-            start_delimiter="#",
-            end_delimiter="",
-            regex_pattern=re.compile(r"^(#{1,3})[ \t]+(.+)$"),
-        )
-        self._definitions[SyntaxRegistryKey.HEADING] = definition

notionary/page/page_context.py

@@ -1,50 +0,0 @@
-from __future__ import annotations
-
-from contextvars import ContextVar
-from dataclasses import dataclass
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from notionary.file_upload import FileUploadHttpClient
-
-
-@dataclass(frozen=True)
-class PageContextProvider:
-    """Context object that provides dependencies for block conversion operations."""
-
-    page_id: str
-    file_upload_client: FileUploadHttpClient
-
-
-# Context variable
-_page_context: ContextVar[PageContextProvider | None] = ContextVar("page_context", default=None)
-
-
-def get_page_context() -> PageContextProvider:
-    """Get current page context or raise if not available."""
-    context = _page_context.get()
-    if context is None:
-        raise RuntimeError("No page context available. Use 'async with page_context(...)'")
-    return context
-
-
-class page_context:
-    def __init__(self, provider: PageContextProvider) -> None:
-        self.provider = provider
-        self._token = None
-
-    def _set_context(self) -> PageContextProvider:
-        self._token = _page_context.set(self.provider)
-        return self.provider
-
-    def _reset_context(self) -> None:
-        """Helper to reset context."""
-        if self._token is not None:
-            _page_context.reset(self._token)
-
-    async def __aenter__(self) -> PageContextProvider:
-        return self._set_context()
-
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        self._reset_context()
-        return False

notionary/shared/models/cover.py

@@ -1,20 +0,0 @@
-from enum import StrEnum
-from typing import Literal, Self
-
-from pydantic import BaseModel
-
-from notionary.shared.models.file import ExternalFile
-
-
-class CoverType(StrEnum):
-    EXTERNAL = "external"
-    FILE = "file"
-
-
-class NotionCover(BaseModel):
-    type: Literal[CoverType.EXTERNAL, CoverType.FILE] = CoverType.EXTERNAL
-    external: ExternalFile | None = None
-
-    @classmethod
-    def from_url(cls, url: str) -> Self:
-        return cls(external=ExternalFile(url=url))