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

notionary/blocks/rich_text/markdown_rich_text_converter.py

@@ -0,0 +1,266 @@
+import re
+from collections.abc import Callable
+from dataclasses import dataclass
+from re import Match
+from typing import ClassVar
+
+from notionary.blocks.rich_text.models import MentionType, RichText, RichTextType, TextAnnotations
+from notionary.blocks.rich_text.name_id_resolver import (
+    DatabaseNameIdResolver,
+    NameIdResolver,
+    PageNameIdResolver,
+    PersonNameIdResolver,
+)
+from notionary.blocks.rich_text.rich_text_patterns import RichTextPatterns
+from notionary.blocks.schemas import BlockColor
+
+
+@dataclass
+class PatternMatch:
+    match: Match
+    handler: Callable[[Match], RichText | list[RichText]]
+    position: int
+
+    @property
+    def matched_text(self) -> str:
+        return self.match.group(0)
+
+    @property
+    def end_position(self) -> int:
+        return self.position + len(self.matched_text)
+
+
+@dataclass
+class PatternHandler:
+    pattern: str
+    handler: Callable[[Match], RichText | list[RichText]]
+
+
+class MarkdownRichTextConverter:
+    VALID_COLORS: ClassVar[set[str]] = {color.value for color in BlockColor}
+
+    def __init__(
+        self,
+        *,
+        page_resolver: NameIdResolver | None = None,
+        database_resolver: NameIdResolver | None = None,
+        person_resolver: NameIdResolver | None = None,
+    ):
+        self.page_resolver = page_resolver or PageNameIdResolver()
+        self.database_resolver = database_resolver or DatabaseNameIdResolver()
+        self.person_resolver = person_resolver or PersonNameIdResolver()
+        self.format_handlers = self._setup_format_handlers()
+
+    def _setup_format_handlers(self) -> list[PatternHandler]:
+        return [
+            PatternHandler(RichTextPatterns.BOLD, self._handle_bold_pattern),
+            PatternHandler(RichTextPatterns.ITALIC, self._handle_italic_pattern),
+            PatternHandler(RichTextPatterns.ITALIC_UNDERSCORE, self._handle_italic_pattern),
+            PatternHandler(RichTextPatterns.UNDERLINE, self._handle_underline_pattern),
+            PatternHandler(RichTextPatterns.STRIKETHROUGH, self._handle_strikethrough_pattern),
+            PatternHandler(RichTextPatterns.CODE, self._handle_code_pattern),
+            PatternHandler(RichTextPatterns.LINK, self._handle_link_pattern),
+            PatternHandler(RichTextPatterns.INLINE_EQUATION, self._handle_equation_pattern),
+            PatternHandler(RichTextPatterns.COLOR, self._handle_color_pattern),
+            PatternHandler(RichTextPatterns.PAGE_MENTION, self._handle_page_mention_pattern),
+            PatternHandler(RichTextPatterns.DATABASE_MENTION, self._handle_database_mention_pattern),
+            PatternHandler(RichTextPatterns.USER_MENTION, self._handle_user_mention_pattern),
+        ]
+
+    async def to_rich_text(self, text: str) -> list[RichText]:
+        if not text:
+            return []
+        return await self._split_text_into_segments(text)
+
+    async def _split_text_into_segments(self, text: str) -> list[RichText]:
+        segments: list[RichText] = []
+        remaining_text = text
+
+        while remaining_text:
+            pattern_match = self._find_earliest_pattern_match(remaining_text)
+
+            if not pattern_match:
+                segments.append(RichText.from_plain_text(remaining_text))
+                break
+
+            plain_text_before = remaining_text[: pattern_match.position]
+            if plain_text_before:
+                segments.append(RichText.from_plain_text(plain_text_before))
+
+            pattern_result = await self._process_pattern_match(pattern_match)
+            self._add_pattern_result_to_segments(segments, pattern_result)
+
+            remaining_text = remaining_text[pattern_match.end_position :]
+
+        return segments
+
+    def _find_earliest_pattern_match(self, text: str) -> PatternMatch | None:
+        """Find the pattern that appears earliest in the text."""
+        earliest_match = None
+        earliest_position = len(text)
+
+        for pattern_handler in self.format_handlers:
+            match = re.search(pattern_handler.pattern, text)
+            if match and match.start() < earliest_position:
+                earliest_match = PatternMatch(match=match, handler=pattern_handler.handler, position=match.start())
+                earliest_position = match.start()
+
+        return earliest_match
+
+    async def _process_pattern_match(self, pattern_match: PatternMatch) -> RichText | list[RichText]:
+        handler_method = pattern_match.handler
+
+        if self._is_async_handler(handler_method):
+            return await handler_method(pattern_match.match)
+        else:
+            return handler_method(pattern_match.match)
+
+    def _is_async_handler(self, handler_method: Callable) -> bool:
+        async_handlers = {
+            self._handle_page_mention_pattern,
+            self._handle_database_mention_pattern,
+            self._handle_color_pattern,  # Color pattern needs async for recursive parsing
+            self._handle_user_mention_pattern,
+        }
+        return handler_method in async_handlers
+
+    def _add_pattern_result_to_segments(
+        self, segments: list[RichText], pattern_result: RichText | list[RichText]
+    ) -> None:
+        if isinstance(pattern_result, list):
+            segments.extend(pattern_result)
+        elif pattern_result:
+            segments.append(pattern_result)
+
+    async def _handle_color_pattern(self, match: Match) -> list[RichText]:
+        color, content = match.group(1).lower(), match.group(2)
+
+        if color not in self.VALID_COLORS:
+            return [RichText.from_plain_text(f"({match.group(1)}:{content})")]
+
+        parsed_segments = await self._split_text_into_segments(content)
+
+        colored_segments = []
+        for segment in parsed_segments:
+            if segment.type == RichTextType.TEXT:
+                colored_segment = self._apply_color_to_text_segment(segment, color)
+                colored_segments.append(colored_segment)
+            else:
+                colored_segments.append(segment)
+
+        return colored_segments
+
+    def _apply_color_to_text_segment(self, segment: RichText, color: str) -> RichText:
+        if segment.type != RichTextType.TEXT:
+            return segment
+
+        has_link = segment.text and segment.text.link
+
+        if has_link:
+            return self._apply_color_to_link_segment(segment, color)
+        else:
+            return self._apply_color_to_plain_text_segment(segment, color)
+
+    def _apply_color_to_link_segment(self, segment: RichText, color: str) -> RichText:
+        formatting = self._extract_formatting_attributes(segment.annotations)
+
+        return RichText.for_link(segment.plain_text, segment.text.link.url, color=color, **formatting)
+
+    def _apply_color_to_plain_text_segment(self, segment: RichText, color: str) -> RichText:
+        if segment.type != RichTextType.TEXT:
+            return segment
+
+        formatting = self._extract_formatting_attributes(segment.annotations)
+
+        return RichText.from_plain_text(segment.plain_text, color=color, **formatting)
+
+    def _extract_formatting_attributes(self, annotations: TextAnnotations) -> dict[str, bool]:
+        if not annotations:
+            return {
+                "bold": False,
+                "italic": False,
+                "strikethrough": False,
+                "underline": False,
+                "code": False,
+            }
+
+        return {
+            "bold": annotations.bold,
+            "italic": annotations.italic,
+            "strikethrough": annotations.strikethrough,
+            "underline": annotations.underline,
+            "code": annotations.code,
+        }
+
+    async def _handle_page_mention_pattern(self, match: Match) -> RichText:
+        identifier = match.group(1)
+        return await self._create_mention_or_fallback(
+            identifier=identifier,
+            resolve_func=self.page_resolver.resolve_name_to_id,
+            create_mention_func=RichText.mention_page,
+            mention_type=MentionType.PAGE,
+        )
+
+    async def _handle_database_mention_pattern(self, match: Match) -> RichText:
+        identifier = match.group(1)
+        return await self._create_mention_or_fallback(
+            identifier=identifier,
+            resolve_func=self.database_resolver.resolve_name_to_id,
+            create_mention_func=RichText.mention_database,
+            mention_type=MentionType.DATABASE,
+        )
+
+    async def _handle_user_mention_pattern(self, match: Match) -> RichText:
+        identifier = match.group(1)
+        return await self._create_mention_or_fallback(
+            identifier=identifier,
+            resolve_func=self.person_resolver.resolve_name_to_id,
+            create_mention_func=RichText.mention_user,
+            mention_type=MentionType.USER,
+        )
+
+    async def _create_mention_or_fallback(
+        self,
+        identifier: str,
+        resolve_func: Callable[[str], str | None],
+        create_mention_func: Callable[[str], RichText],
+        mention_type: MentionType,
+    ) -> RichText:
+        try:
+            resolved_id = await resolve_func(identifier)
+
+            if resolved_id:
+                return create_mention_func(resolved_id)
+            else:
+                return self._create_unresolved_mention_fallback(identifier, mention_type)
+
+        except Exception:
+            # If resolution throws an error, fallback to plain text
+            return self._create_unresolved_mention_fallback(identifier, mention_type)
+
+    def _create_unresolved_mention_fallback(self, identifier: str, mention_type: MentionType) -> RichText:
+        fallback_text = f"@{mention_type.value}[{identifier}]"
+        return RichText.for_caption(fallback_text)
+
+    def _handle_bold_pattern(self, match: Match) -> RichText:
+        return RichText.from_plain_text(match.group(1), bold=True)
+
+    def _handle_italic_pattern(self, match: Match) -> RichText:
+        return RichText.from_plain_text(match.group(1), italic=True)
+
+    def _handle_underline_pattern(self, match: Match) -> RichText:
+        return RichText.from_plain_text(match.group(1), underline=True)
+
+    def _handle_strikethrough_pattern(self, match: Match) -> RichText:
+        return RichText.from_plain_text(match.group(1), strikethrough=True)
+
+    def _handle_code_pattern(self, match: Match) -> RichText:
+        return RichText.from_plain_text(match.group(1), code=True)
+
+    def _handle_link_pattern(self, match: Match) -> RichText:
+        link_text, url = match.group(1), match.group(2)
+        return RichText.for_link(link_text, url)
+
+    def _handle_equation_pattern(self, match: Match) -> RichText:
+        expression = match.group(1)
+        return RichText.equation_inline(expression)

notionary/blocks/rich_text/models.py

@@ -0,0 +1,164 @@
+from enum import StrEnum
+from typing import Self
+
+from pydantic import BaseModel
+
+from notionary.blocks.enums import BlockColor
+
+
+class RichTextType(StrEnum):
+    TEXT = "text"
+    MENTION = "mention"
+    EQUATION = "equation"
+
+
+class MentionType(StrEnum):
+    USER = "user"
+    PAGE = "page"
+    DATABASE = "database"
+    DATE = "date"
+    LINK_PREVIEW = "link_preview"
+    TEMPLATE_MENTION = "template_mention"
+
+
+class TemplateMentionType(StrEnum):
+    USER = "template_mention_user"
+    DATE = "template_mention_date"
+
+
+class TextAnnotations(BaseModel):
+    bold: bool = False
+    italic: bool = False
+    strikethrough: bool = False
+    underline: bool = False
+    code: bool = False
+    color: BlockColor | None = None
+
+
+class LinkObject(BaseModel):
+    url: str
+
+
+class TextContent(BaseModel):
+    content: str
+    link: LinkObject | None = None
+
+
+class EquationObject(BaseModel):
+    expression: str
+
+
+class MentionUserRef(BaseModel):
+    id: str  # Notion user id
+
+
+class MentionPageRef(BaseModel):
+    id: str
+
+
+class MentionDatabaseRef(BaseModel):
+    id: str
+
+
+class MentionLinkPreview(BaseModel):
+    url: str
+
+
+class MentionDate(BaseModel):
+    # entspricht Notion date object (start Pflicht, end/time_zone optional)
+    start: str  # ISO 8601 date or datetime
+    end: str | None = None
+    time_zone: str | None = None
+
+
+class MentionTemplateMention(BaseModel):
+    # Notion hat zwei Template-Mention-Typen
+    type: TemplateMentionType
+
+
+class MentionObject(BaseModel):
+    type: MentionType
+    user: MentionUserRef | None = None
+    page: MentionPageRef | None = None
+    database: MentionDatabaseRef | None = None
+    date: MentionDate | None = None
+    link_preview: MentionLinkPreview | None = None
+    template_mention: MentionTemplateMention | None = None
+
+
+class RichText(BaseModel):
+    type: RichTextType = RichTextType.TEXT
+
+    text: TextContent | None = None
+    annotations: TextAnnotations | None = None
+    plain_text: str = ""
+    href: str | None = None
+
+    mention: MentionObject | None = None
+
+    equation: EquationObject | None = None
+
+    @classmethod
+    def from_plain_text(cls, content: str, **ann) -> Self:
+        return cls(
+            type=RichTextType.TEXT,
+            text=TextContent(content=content),
+            annotations=TextAnnotations(**ann) if ann else TextAnnotations(),
+            plain_text=content,
+        )
+
+    @classmethod
+    def for_caption(cls, content: str) -> Self:
+        return cls(
+            type=RichTextType.TEXT,
+            text=TextContent(content=content),
+            annotations=None,
+            plain_text=content,
+        )
+
+    @classmethod
+    def for_code_block(cls, content: str) -> Self:
+        # keine annotations setzen → Notion Code-Highlight bleibt an
+        return cls.for_caption(content)
+
+    @classmethod
+    def for_link(cls, content: str, url: str, **ann) -> Self:
+        return cls(
+            type=RichTextType.TEXT,
+            text=TextContent(content=content, link=LinkObject(url=url)),
+            annotations=TextAnnotations(**ann) if ann else TextAnnotations(),
+            plain_text=content,
+        )
+
+    @classmethod
+    def mention_user(cls, user_id: str) -> Self:
+        return cls(
+            type=RichTextType.MENTION,
+            mention=MentionObject(type=MentionType.USER, user=MentionUserRef(id=user_id)),
+            annotations=TextAnnotations(),
+        )
+
+    @classmethod
+    def mention_page(cls, page_id: str) -> Self:
+        return cls(
+            type=RichTextType.MENTION,
+            mention=MentionObject(type=MentionType.PAGE, page=MentionPageRef(id=page_id)),
+            annotations=TextAnnotations(),
+        )
+
+    @classmethod
+    def mention_database(cls, database_id: str) -> Self:
+        return cls(
+            type=RichTextType.MENTION,
+            mention=MentionObject(type=MentionType.DATABASE, database=MentionDatabaseRef(id=database_id)),
+            annotations=TextAnnotations(),
+        )
+
+    @classmethod
+    def equation_inline(cls, expression: str) -> Self:
+        return cls(
+            type=RichTextType.EQUATION,
+            equation=EquationObject(expression=expression),
+            annotations=TextAnnotations(),
+            plain_text=expression,
+        )

notionary/blocks/rich_text/name_id_resolver/__init__.py

@@ -0,0 +1,11 @@
+from .database import DatabaseNameIdResolver
+from .page import PageNameIdResolver
+from .person import PersonNameIdResolver
+from .port import NameIdResolver
+
+__all__ = [
+    "DatabaseNameIdResolver",
+    "NameIdResolver",
+    "PageNameIdResolver",
+    "PersonNameIdResolver",
+]

notionary/blocks/rich_text/name_id_resolver/database.py

@@ -0,0 +1,31 @@
+from typing import override
+
+from notionary.blocks.rich_text.name_id_resolver.port import NameIdResolver
+from notionary.workspace.query.service import WorkspaceQueryService
+
+
+class DatabaseNameIdResolver(NameIdResolver):
+    def __init__(self, search_service: WorkspaceQueryService | None = None) -> None:
+        self.search_service = search_service or WorkspaceQueryService()
+
+    @override
+    async def resolve_name_to_id(self, name: str) -> str | None:
+        if not name:
+            return None
+
+        cleaned_name = name.strip()
+        database = await self.search_service.find_database(query=cleaned_name)
+        return database.id if database else None
+
+    @override
+    async def resolve_id_to_name(self, database_id: str) -> str | None:
+        if not database_id:
+            return None
+
+        try:
+            from notionary import NotionDatabase
+
+            database = await NotionDatabase.from_id(database_id)
+            return database.title if database else None
+        except Exception:
+            return None

notionary/blocks/rich_text/name_id_resolver/page.py

@@ -0,0 +1,34 @@
+from typing import override
+
+from notionary.blocks.rich_text.name_id_resolver.port import NameIdResolver
+from notionary.workspace.query.service import WorkspaceQueryService
+
+
+class PageNameIdResolver(NameIdResolver):
+    def __init__(self, search_service: WorkspaceQueryService | None = None) -> None:
+        self.search_service = search_service or WorkspaceQueryService()
+
+    @override
+    async def resolve_name_to_id(self, name: str) -> str | None:
+        if not name:
+            return None
+
+        cleaned_name = name.strip()
+        return await self._resolve_page_id(cleaned_name)
+
+    @override
+    async def resolve_id_to_name(self, page_id: str) -> str | None:
+        if not page_id:
+            return None
+
+        try:
+            from notionary import NotionPage
+
+            page = await NotionPage.from_id(page_id)
+            return page.title if page else None
+        except Exception:
+            return None
+
+    async def _resolve_page_id(self, name: str) -> str | None:
+        page = await self.search_service.find_page(query=name)
+        return page.id if page else None

notionary/blocks/rich_text/name_id_resolver/person.py

@@ -0,0 +1,37 @@
+from typing import override
+
+from notionary.blocks.rich_text.name_id_resolver.port import NameIdResolver
+from notionary.user.client import UserHttpClient
+from notionary.user.person import PersonUser
+
+
+class PersonNameIdResolver(NameIdResolver):
+    def __init__(self, person_user_factory=None, http_client: UserHttpClient | None = None) -> None:
+        if person_user_factory is None:
+            person_user_factory = PersonUser
+        self.person_user_factory = person_user_factory
+        self.http_client = http_client
+
+    @override
+    async def resolve_name_to_id(self, name: str | None) -> str | None:
+        if not name or not name.strip():
+            return None
+
+        name = name.strip()
+
+        try:
+            user = await self.person_user_factory.from_name(name, self.http_client)
+            return user.id if user else None
+        except Exception:
+            return None
+
+    @override
+    async def resolve_id_to_name(self, user_id: str | None) -> str | None:
+        if not user_id or not user_id.strip():
+            return None
+
+        try:
+            user = await self.person_user_factory.from_id(user_id.strip(), self.http_client)
+            return user.name if user else None
+        except Exception:
+            return None

notionary/blocks/rich_text/name_id_resolver/port.py

@@ -0,0 +1,11 @@
+from abc import ABC, abstractmethod
+
+
+class NameIdResolver(ABC):
+    @abstractmethod
+    def resolve_name_to_id(self, name: str) -> str | None:
+        pass
+
+    @abstractmethod
+    def resolve_id_to_name(self, id: str) -> str | None:
+        pass

notionary/blocks/rich_text/rich_text_markdown_converter.py

@@ -0,0 +1,132 @@
+from typing import ClassVar
+
+from notionary.blocks.rich_text.models import (
+    MentionDate,
+    MentionType,
+    RichText,
+    RichTextType,
+)
+from notionary.blocks.rich_text.name_id_resolver import (
+    DatabaseNameIdResolver,
+    NameIdResolver,
+    PageNameIdResolver,
+    PersonNameIdResolver,
+)
+from notionary.blocks.schemas import BlockColor
+
+
+class RichTextToMarkdownConverter:
+    VALID_COLORS: ClassVar[set[str]] = {color.value for color in BlockColor}
+
+    def __init__(
+        self,
+        *,
+        page_resolver: NameIdResolver | None = None,
+        database_resolver: NameIdResolver | None = None,
+        person_resolver: NameIdResolver | None = None,
+    ) -> None:
+        self.page_resolver = page_resolver or PageNameIdResolver()
+        self.database_resolver = database_resolver or DatabaseNameIdResolver()
+        self.person_resolver = person_resolver or PersonNameIdResolver()
+
+    async def to_markdown(self, rich_text: list[RichText]) -> str:
+        if not rich_text:
+            return ""
+
+        parts: list[str] = []
+
+        for rich_obj in rich_text:
+            formatted_text = await self._convert_rich_text_to_markdown(rich_obj)
+            parts.append(formatted_text)
+
+        return "".join(parts)
+
+    async def _convert_rich_text_to_markdown(self, obj: RichText) -> str:
+        if obj.type == RichTextType.EQUATION and obj.equation:
+            return f"${obj.equation.expression}$"
+
+        if obj.type == RichTextType.MENTION:
+            mention_markdown = await self._extract_mention_markdown(obj)
+            if mention_markdown:
+                return mention_markdown
+
+        content = obj.plain_text or (obj.text.content if obj.text else "")
+        return self._apply_text_formatting_to_content(obj, content)
+
+    async def _extract_mention_markdown(self, obj: RichText) -> str | None:
+        if not obj.mention:
+            return None
+
+        mention = obj.mention
+
+        if mention.type == MentionType.PAGE and mention.page:
+            return await self._extract_page_mention_markdown(mention.page.id)
+
+        elif mention.type == MentionType.DATABASE and mention.database:
+            return await self._extract_database_mention_markdown(mention.database.id)
+
+        elif mention.type == MentionType.USER and mention.user:
+            return await self._extract_user_mention_markdown(mention.user.id)
+
+        elif mention.type == MentionType.DATE and mention.date:
+            return self._extract_date_mention_markdown(mention.date)
+
+        return None
+
+    async def _extract_page_mention_markdown(self, page_id: str) -> str:
+        page_name = await self.page_resolver.resolve_id_to_name(page_id)
+        return f"@page[{page_name or page_id}]"
+
+    async def _extract_database_mention_markdown(self, database_id: str) -> str:
+        database_name = await self.database_resolver.resolve_id_to_name(database_id)
+        return f"@database[{database_name or database_id}]"
+
+    async def _extract_user_mention_markdown(self, user_id: str) -> str:
+        user_name = await self.person_resolver.resolve_id_to_name(user_id)
+        return f"@user[{user_name or user_id}]"
+
+    def _extract_date_mention_markdown(self, date_mention: MentionDate) -> str:
+        date_range = date_mention.start
+        if date_mention.end:
+            date_range += f"–{date_mention.end}"
+        return f"@date[{date_range}]"
+
+    def _apply_text_formatting_to_content(self, obj: RichText, content: str) -> str:
+        if obj.text and obj.text.link:
+            content = f"[{content}]({obj.text.link.url})"
+
+        if not obj.annotations:
+            return content
+
+        annotations = obj.annotations
+
+        if annotations.code:
+            content = f"`{content}`"
+        if annotations.strikethrough:
+            content = f"~~{content}~~"
+        if annotations.underline:
+            content = f"__{content}__"
+        if annotations.italic:
+            content = f"*{content}*"
+        if annotations.bold:
+            content = f"**{content}**"
+
+        if annotations.color != BlockColor.DEFAULT and annotations.color in self.VALID_COLORS:
+            content = f"({annotations.color}:{content})"
+
+        return content
+
+
+async def convert_rich_text_to_markdown(
+    rich_text: list[RichText],
+    *,
+    page_resolver: NameIdResolver | None = None,
+    database_resolver: NameIdResolver | None = None,
+    person_resolver: NameIdResolver | None = None,
+) -> str:
+    converter = RichTextToMarkdownConverter(
+        page_resolver=page_resolver,
+        database_resolver=database_resolver,
+        person_resolver=person_resolver,
+    )
+    return await converter.to_markdown(rich_text)