notionary 0.2.19__py3-none-any.whl → 0.2.22__py3-none-any.whl

notionary/blocks/registry/block_registry_builder.py

@@ -1,32 +1,34 @@
 from __future__ import annotations
-from typing import Type, TYPE_CHECKING, Self
-from collections import OrderedDict
 
-from notionary.blocks import (
-    ParagraphElement,
-    AudioElement,
-    BulletedListElement,
-    CalloutElement,
-    CodeElement,
-    ColumnElement,
-    DividerElement,
-    EmbedElement,
-    HeadingElement,
-    ImageElement,
-    MentionElement,
-    NumberedListElement,
-    TableElement,
-    TodoElement,
-    ToggleElement,
-    ToggleableHeadingElement,
-    VideoElement,
-    BookmarkElement,
-    QuoteElement,
-    NotionBlockElement,
-)
+from collections import OrderedDict
+from typing import TYPE_CHECKING, Self, Type
+
+from notionary.blocks.audio import AudioElement
+from notionary.blocks.base_block_element import BaseBlockElement
+from notionary.blocks.bookmark import BookmarkElement
+from notionary.blocks.breadcrumbs import BreadcrumbElement
+from notionary.blocks.bulleted_list import BulletedListElement
+from notionary.blocks.callout import CalloutElement
+from notionary.blocks.child_database import ChildDatabaseElement
+from notionary.blocks.code import CodeElement
+from notionary.blocks.column import ColumnElement, ColumnListElement
+from notionary.blocks.divider import DividerElement
+from notionary.blocks.embed import EmbedElement
+from notionary.blocks.equation import EquationElement
+from notionary.blocks.heading import HeadingElement
+from notionary.blocks.image_block import ImageElement
+from notionary.blocks.numbered_list import NumberedListElement
+from notionary.blocks.paragraph import ParagraphElement
+from notionary.blocks.quote import QuoteElement
+from notionary.blocks.table import TableElement
+from notionary.blocks.table_of_contents import TableOfContentsElement
+from notionary.blocks.todo import TodoElement
+from notionary.blocks.toggle import ToggleElement
+from notionary.blocks.toggleable_heading import ToggleableHeadingElement
+from notionary.blocks.video import VideoElement
 
 if TYPE_CHECKING:
-    from notionary.blocks import BlockRegistry
+    from notionary.blocks.registry.block_registry import BlockRegistry
 
 
 class BlockRegistryBuilder:
@@ -63,13 +65,16 @@ class BlockRegistryBuilder:
             .with_videos()
             .with_embeds()
             .with_audio()
-            .with_columns()
-            .with_mention()
             .with_paragraphs()
             .with_toggleable_heading_element()
+            .with_columns()
+            .with_equation()
+            .with_table_of_contents()
+            .with_breadcrumbs()
+            .with_child_database()
         ).build()
 
-    def remove_element(self, element_class: Type[NotionBlockElement]) -> Self:
+    def remove_element(self, element_class: Type[BaseBlockElement]) -> Self:
         """
         Remove an element class from the registry configuration.
 
@@ -84,92 +89,143 @@ class BlockRegistryBuilder:
 
     # WITH methods (existing)
     def with_paragraphs(self) -> Self:
-        """Add support for paragraph elements."""
         return self._add_element(ParagraphElement)
 
     def with_headings(self) -> Self:
-        """Add support for heading elements."""
         return self._add_element(HeadingElement)
 
     def with_callouts(self) -> Self:
-        """Add support for callout elements."""
         return self._add_element(CalloutElement)
 
     def with_code(self) -> Self:
-        """Add support for code blocks."""
         return self._add_element(CodeElement)
 
     def with_dividers(self) -> Self:
-        """Add support for divider elements."""
         return self._add_element(DividerElement)
 
     def with_tables(self) -> Self:
-        """Add support for tables."""
         return self._add_element(TableElement)
 
     def with_bulleted_list(self) -> Self:
-        """Add support for bulleted list elements (unordered lists)."""
         return self._add_element(BulletedListElement)
 
     def with_numbered_list(self) -> Self:
-        """Add support for numbered list elements (ordered lists)."""
         return self._add_element(NumberedListElement)
 
     def with_toggles(self) -> Self:
-        """Add support for toggle elements."""
         return self._add_element(ToggleElement)
 
     def with_quotes(self) -> Self:
-        """Add support for quote elements."""
         return self._add_element(QuoteElement)
 
     def with_todos(self) -> Self:
-        """Add support for todo elements."""
         return self._add_element(TodoElement)
 
     def with_bookmarks(self) -> Self:
-        """Add support for bookmark elements."""
         return self._add_element(BookmarkElement)
 
     def with_images(self) -> Self:
-        """Add support for image elements."""
         return self._add_element(ImageElement)
 
     def with_videos(self) -> Self:
-        """Add support for video elements."""
         return self._add_element(VideoElement)
 
     def with_embeds(self) -> Self:
-        """Add support for embed elements."""
         return self._add_element(EmbedElement)
 
     def with_audio(self) -> Self:
-        """Add support for audio elements."""
         return self._add_element(AudioElement)
 
-    def with_mention(self) -> Self:
-        """Add support for mention elements."""
-        return self._add_element(MentionElement)
-
     def with_toggleable_heading_element(self) -> Self:
-        """Add support for toggleable heading elements."""
         return self._add_element(ToggleableHeadingElement)
 
     def with_columns(self) -> Self:
-        """Add support for column elements."""
-        return self._add_element(ColumnElement)
+        self._add_element(ColumnListElement)
+        self._add_element(ColumnElement)
+        return self
+
+    def with_equation(self) -> Self:
+        return self._add_element(EquationElement)
+
+    def with_table_of_contents(self) -> Self:
+        return self._add_element(TableOfContentsElement)
+
+    def with_breadcrumbs(self) -> Self:
+        return self._add_element(BreadcrumbElement)
+
+    def with_child_database(self) -> Self:
+        return self._add_element(ChildDatabaseElement)
+
+    def without_headings(self) -> Self:
+        return self.remove_element(HeadingElement)
+
+    def without_callouts(self) -> Self:
+        return self.remove_element(CalloutElement)
+
+    def without_code(self) -> Self:
+        return self.remove_element(CodeElement)
+
+    def without_dividers(self) -> Self:
+        return self.remove_element(DividerElement)
+
+    def without_tables(self) -> Self:
+        return self.remove_element(TableElement)
+
+    def without_bulleted_list(self) -> Self:
+        return self.remove_element(BulletedListElement)
+
+    def without_numbered_list(self) -> Self:
+        return self.remove_element(NumberedListElement)
+
+    def without_toggles(self) -> Self:
+        return self.remove_element(ToggleElement)
+
+    def without_quotes(self) -> Self:
+        return self.remove_element(QuoteElement)
+
+    def without_todos(self) -> Self:
+        return self.remove_element(TodoElement)
+
+    def without_bookmarks(self) -> Self:
+        return self.remove_element(BookmarkElement)
+
+    def without_images(self) -> Self:
+        return self.remove_element(ImageElement)
+
+    def without_videos(self) -> Self:
+        return self.remove_element(VideoElement)
+
+    def without_embeds(self) -> Self:
+        return self.remove_element(EmbedElement)
+
+    def without_audio(self) -> Self:
+        return self.remove_element(AudioElement)
+
+    def without_toggleable_heading_element(self) -> Self:
+        return self.remove_element(ToggleableHeadingElement)
+
+    def without_columns(self) -> Self:
+        self.remove_element(ColumnListElement)
+        self.remove_element(ColumnElement)
+        return self
+
+    def without_equation(self) -> Self:
+        return self.remove_element(EquationElement)
+
+    def without_table_of_contents(self) -> Self:
+        return self.remove_element(TableOfContentsElement)
+
+    def without_breadcrumbs(self) -> Self:
+        return self.remove_element(BreadcrumbElement)
+
+    def without_child_database(self) -> Self:
+        return self.remove_element(ChildDatabaseElement)
 
     def build(self) -> BlockRegistry:
         """
         Build and return the configured BlockRegistry instance.
-
-        This automatically ensures that ParagraphElement is at the end
-        of the registry as a fallback element.
-
-        Returns:
-            A configured BlockRegistry instance
         """
-        from notionary.blocks import BlockRegistry
+        from notionary.blocks.registry.block_registry import BlockRegistry
 
         # Ensure ParagraphElement is always present and at the end
         self._ensure_paragraph_at_end()
@@ -191,7 +247,7 @@ class BlockRegistryBuilder:
         self._elements.pop(ParagraphElement.__name__, None)
         self._elements[ParagraphElement.__name__] = ParagraphElement
 
-    def _add_element(self, element_class: Type[NotionBlockElement]) -> Self:
+    def _add_element(self, element_class: Type[BaseBlockElement]) -> Self:
         """
         Add an element class to the registry configuration.
         If the element already exists, it's moved to the end.

notionary/blocks/rich_text/__init__.py

@@ -0,0 +1,33 @@
+"""Rich text handling for Notionary."""
+
+from notionary.blocks.rich_text.rich_text_models import (
+    EquationObject,
+    LinkObject,
+    MentionDatabaseRef,
+    MentionDate,
+    MentionLinkPreview,
+    MentionObject,
+    MentionPageRef,
+    MentionTemplateMention,
+    MentionUserRef,
+    RichTextObject,
+    TextAnnotations,
+    TextContent,
+)
+from notionary.blocks.rich_text.text_inline_formatter import TextInlineFormatter
+
+__all__ = [
+    "RichTextObject",
+    "TextAnnotations",
+    "LinkObject",
+    "TextContent",
+    "EquationObject",
+    "MentionUserRef",
+    "MentionPageRef",
+    "MentionDatabaseRef",
+    "MentionLinkPreview",
+    "MentionDate",
+    "MentionTemplateMention",
+    "MentionObject",
+    "TextInlineFormatter",
+]

notionary/blocks/rich_text/name_to_id_resolver.py

@@ -0,0 +1,205 @@
+from __future__ import annotations
+
+import logging
+from contextlib import contextmanager
+from typing import Optional
+
+from notionary.user.notion_user_manager import NotionUserManager
+from notionary.util import format_uuid
+from notionary.util.fuzzy import find_best_match
+
+
+class NameIdResolver:
+    """
+    Bidirectional resolver for Notion page and database names and IDs.
+    """
+
+    def __init__(
+        self,
+        *,
+        token: Optional[str] = None,
+        search_limit: int = 10,
+    ):
+        """
+        Initialize the resolver with a Notion workspace.
+        """
+        from notionary import NotionWorkspace
+
+        self.workspace = NotionWorkspace(token=token)
+        self.notion_user_manager = NotionUserManager(token=token)
+        self.search_limit = search_limit
+
+    async def resolve_page_id(self, name: str) -> Optional[str]:
+        """
+        Convert a page name to its Notion page ID.
+        Specifically searches only pages, not databases.
+        """
+        if not name:
+            return None
+
+        cleaned_name = name.strip()
+
+        # Return if already a valid Notion ID
+        formatted_uuid = format_uuid(cleaned_name)
+        if formatted_uuid:
+            return formatted_uuid
+
+        # Search for page by name
+        return await self._resolve_page_id(cleaned_name)
+
+    async def resolve_database_id(self, name: str) -> Optional[str]:
+        """
+        Convert a database name to its Notion database ID.
+        Specifically searches only databases, not pages.
+        """
+        if not name:
+            return None
+
+        cleaned_name = name.strip()
+
+        formatted_uuid = format_uuid(cleaned_name)
+        if formatted_uuid:
+            return formatted_uuid
+
+        return await self._resolve_database_id(cleaned_name)
+
+    async def resolve_page_name(self, page_id: str) -> Optional[str]:
+        """
+        Convert a Notion page ID to its human-readable title.
+        """
+        if not page_id:
+            return None
+
+        formatted_id = format_uuid(page_id)
+        if not formatted_id:
+            return None
+
+        try:
+            from notionary import NotionPage
+
+            page = await NotionPage.from_page_id(formatted_id)
+            return page.title if page else None
+        except Exception:
+            return None
+
+    async def resolve_database_name(self, database_id: str) -> Optional[str]:
+        """
+        Convert a Notion database ID to its human-readable title.
+        """
+        if not database_id:
+            return None
+
+        # Validate and format UUID
+        formatted_id = format_uuid(database_id)
+        if not formatted_id:
+            return None
+
+        try:
+            from notionary.database import NotionDatabase
+
+            database = await NotionDatabase.from_database_id(formatted_id)
+            return database.title if database else None
+        except Exception:
+            return None
+
+    async def resolve_user_id(self, name: str) -> Optional[str]:
+        """
+        Convert a user name to its Notion user ID.
+        Specifically searches only users.
+        """
+        if not name:
+            return None
+
+        cleaned_name = name.strip()
+
+        # Return if already a valid Notion ID
+        formatted_uuid = format_uuid(cleaned_name)
+        if formatted_uuid:
+            return formatted_uuid
+
+        # Search for user by name
+        return await self._resolve_user_id(cleaned_name)
+
+    async def resolve_user_name(self, user_id: str) -> Optional[str]:
+        """
+        Convert a Notion user ID to its human-readable name.
+
+        Args:
+            user_id: Notion user ID to resolve
+
+        Returns:
+            User name if found, None if not found or inaccessible
+        """
+        if not user_id:
+            return None
+
+        # Validate and format UUID
+        formatted_id = format_uuid(user_id)
+        if not formatted_id:
+            return None
+
+        try:
+            user = await self.notion_user_manager.get_user_by_id(formatted_id)
+            return user.name if user else None
+        except Exception:
+            return None
+
+    async def _resolve_user_id(self, name: str) -> Optional[str]:
+        """Search for users matching the name."""
+        try:
+            users = await self.notion_user_manager.find_users_by_name(name)
+
+            if not users:
+                return None
+
+            # Use fuzzy matching to find best match
+            best_match = find_best_match(
+                query=name,
+                items=users,
+                text_extractor=lambda user: user.name or "",
+            )
+
+            return best_match.item.id if best_match else None
+        except Exception:
+            return None
+
+    async def _resolve_page_id(self, name: str) -> Optional[str]:
+        """Search for pages matching the name."""
+        search_results = await self.workspace.search_pages(
+            query=name, limit=self.search_limit
+        )
+
+        return self._find_best_fuzzy_match(query=name, candidate_objects=search_results)
+
+    async def _resolve_database_id(self, name: str) -> Optional[str]:
+        """Search for databases matching the name."""
+        search_results = await self.workspace.search_databases(
+            query=name, limit=self.search_limit
+        )
+
+        return self._find_best_fuzzy_match(query=name, candidate_objects=search_results)
+
+    def _find_best_fuzzy_match(
+        self, query: str, candidate_objects: list
+    ) -> Optional[str]:
+        """
+        Find the best fuzzy match among candidate objects using existing fuzzy matching logic.
+
+        Args:
+            query: The search query to match against
+            candidate_objects: Objects (pages or databases) with .id and .title attributes
+
+        Returns:
+            ID of best match, or None if no match meets threshold
+        """
+        if not candidate_objects:
+            return None
+
+        # Use existing fuzzy matching logic
+        best_match = find_best_match(
+            query=query,
+            items=candidate_objects,
+            text_extractor=lambda obj: obj.title,
+        )
+
+        return best_match.item.id if best_match else None